1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
module ActiveRecord
class Base
class ConnectionSpecification #:nodoc:
attr_reader :config, :adapter_method
def initialize (config, adapter_method)
@config, @adapter_method = config, adapter_method
end
end
# Check connections for active? after +@@connection_cache_timeout+ seconds
# defaults to 5 minutes
cattr_accessor :connection_cache_timeout
@@connection_cache_timeout = 300
# The class -> [adapter_method, config] map
@@defined_connections = {}
# The class -> thread id -> adapter cache. (class -> adapter if not allow_concurrency)
@@connection_cache = {}
# retrieve the connection cache
def self.connection_cache
if @@allow_concurrency
@@connection_cache[Thread.current.object_id] ||= {}
else
@@connection_cache
end
end
@connection_cache_key = nil
def self.connection_cache_key
@connection_cache_key ||=
if active_connections[name] || @@defined_connections[name]
name
elsif self == ActiveRecord::Base
nil
else
superclass.connection_cache_key
end
end
def self.clear_connection_cache_key
@connection_cache_key = nil
subclasses.each{|klass| klass.clear_connection_cache_key }
end
# Returns the connection currently associated with the class. This can
# also be used to "borrow" the connection to do database work unrelated
# to any of the specific Active Records.
def self.connection
if (cache_key = @connection_cache_key) && (conn = connection_cache[cache_key])
conn
else
conn = retrieve_connection # this will set @connection_cache_key
connection_cache[@connection_cache_key] = conn
end
end
# Clears the cache which maps classes to connections.
def self.clear_connection_cache!
if @@allow_concurrency
@@connection_cache.delete(Thread.current.object_id)
else
@@connection_cache = {}
end
end
# Verify connection cache.
def self.verify_connection_cache!
timeout = @@connection_cache_timeout
connection_cache.each_value { |connection| connection.verify!(timeout) }
end
# Returns the connection currently associated with the class. This can
# also be used to "borrow" the connection to do database work that isn't
# easily done without going straight to SQL.
def connection
self.class.connection
end
# Establishes the connection to the database. Accepts a hash as input where
# the :adapter key must be specified with the name of a database adapter (in lower-case)
# example for regular databases (MySQL, Postgresql, etc):
#
# ActiveRecord::Base.establish_connection(
# :adapter => "mysql",
# :host => "localhost",
# :username => "myuser",
# :password => "mypass",
# :database => "somedatabase"
# )
#
# Example for SQLite database:
#
# ActiveRecord::Base.establish_connection(
# :adapter => "sqlite",
# :database => "path/to/dbfile"
# )
#
# Also accepts keys as strings (for parsing from yaml for example):
# ActiveRecord::Base.establish_connection(
# "adapter" => "sqlite",
# "database" => "path/to/dbfile"
# )
#
# The exceptions AdapterNotSpecified, AdapterNotFound and ArgumentError
# may be returned on an error.
def self.establish_connection(spec = nil)
case spec
when nil
raise AdapterNotSpecified unless defined? RAILS_ENV
establish_connection(RAILS_ENV)
when ConnectionSpecification
clear_connection_cache_key
@connection_cache_key = name
@@defined_connections[name] = spec
when Symbol, String
if configuration = configurations[spec.to_s]
establish_connection(configuration)
else
raise AdapterNotSpecified, "#{spec} database is not configured"
end
else
spec = spec.symbolize_keys
unless spec.key?(:adapter) then raise AdapterNotSpecified, "database configuration does not specify adapter" end
adapter_method = "#{spec[:adapter]}_connection"
unless respond_to?(adapter_method) then raise AdapterNotFound, "database configuration specifies nonexistent #{spec[:adapter]} adapter" end
remove_connection
establish_connection(ConnectionSpecification.new(spec, adapter_method))
end
end
def self.active_connections #:nodoc:
if @@allow_concurrency
Thread.current['active_connections'] ||= {}
else
@@active_connections ||= {}
end
end
# Locate the connection of the nearest super class. This can be an
# active or defined connections: if it is the latter, it will be
# opened and set as the active connection for the class it was defined
# for (not necessarily the current class).
def self.retrieve_connection #:nodoc:
cache_key = connection_cache_key
# cache_key is nil if establish_connection hasn't been called for
# some class along the inheritance chain up to AR::Base yet
raise ConnectionNotEstablished unless cache_key
if conn = active_connections[cache_key]
# Verify the connection.
conn.verify!(@@connection_cache_timeout)
return conn
elsif conn = @@defined_connections[cache_key]
# Activate this connection specification.
klass = cache_key.constantize
klass.connection = conn
return active_connections[cache_key]
else
raise ConnectionNotEstablished
end
end
# Returns true if a connection that's accessible to this class have already been opened.
def self.connected?
active_connections[connection_cache_key] ? true : false
end
# Remove the connection for this class. This will close the active
# connection and the defined connection (if they exist). The result
# can be used as argument for establish_connection, for easy
# re-establishing of the connection.
def self.remove_connection(klass=self)
spec = @@defined_connections[klass.name]
konn = active_connections[klass.name]
@@defined_connections.delete_if { |key, value| value == spec }
connection_cache.delete_if { |key, value| value == konn }
active_connections.delete_if { |key, value| value == konn }
konn.disconnect! if konn
spec.config if spec
end
# Set the connection for the class.
def self.connection=(spec)
if spec.kind_of?(ActiveRecord::ConnectionAdapters::AbstractAdapter)
active_connections[name] = spec
elsif spec.kind_of?(ConnectionSpecification)
self.connection = self.send(spec.adapter_method, spec.config)
elsif spec.nil?
raise ConnectionNotEstablished
else
establish_connection spec
end
end
# connection state logging
def self.log_connections
if logger
logger.info "Defined connections: #{@@defined_connections.inspect}"
logger.info "Active connections: #{active_connections.inspect}"
logger.info "Connection cache: #{connection_cache.inspect}"
logger.info "Connection cache key: #{@connection_cache_key}"
end
end
end
end
|
