Class: ActiveRecord::ConnectionAdapters::ConnectionPool
- Includes:
- AbstractPool, QueryCache::ConnectionPoolConfiguration, MonitorMixin
- Defined in:
- activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb,
activerecord/lib/active_record/connection_adapters/abstract/connection_pool/queue.rb,
activerecord/lib/active_record/connection_adapters/abstract/connection_pool/reaper.rb
Overview
Active Record Connection Pool
Connection pool base class for managing Active Record database connections.
Introduction
A connection pool synchronizes thread access to a limited number of database connections. The basic idea is that each thread checks out a database connection from the pool, uses that connection, and checks the connection back in. ConnectionPool is completely thread-safe, and will ensure that a connection cannot be used by two threads at the same time, as long as ConnectionPool’s contract is correctly followed. It will also handle cases in which there are more threads than connections: if all connections have been checked out, and a thread tries to checkout a connection anyway, then ConnectionPool will wait until some other thread has checked in a connection, or the checkout_timeout
has expired.
Obtaining (checking out) a connection
Connections can be obtained and used from a connection pool in several ways:
-
Simply use ActiveRecord::Base.lease_connection. When you’re done with the connection(s) and wish it to be returned to the pool, you call ActiveRecord::Base.connection_handler.clear_active_connections!. This is the default behavior for Active Record when used in conjunction with Action Pack’s request handling cycle.
-
Manually check out a connection from the pool with ActiveRecord::Base.connection_pool.checkout. You are responsible for returning this connection to the pool when finished by calling ActiveRecord::Base.connection_pool.checkin(connection).
-
Use ActiveRecord::Base.connection_pool.with_connection(&block), which obtains a connection, yields it as the sole argument to the block, and returns it to the pool after the block completes.
Connections in the pool are actually AbstractAdapter objects (or objects compatible with AbstractAdapter’s interface).
While a thread has a connection checked out from the pool using one of the above three methods, that connection will automatically be the one used by ActiveRecord queries executing on that thread. It is not required to explicitly pass the checked out connection to Rails models or queries, for example.
Options
There are several connection-pooling-related options that you can add to your database connection configuration:
-
pool
: maximum number of connections the pool may manage (default 5). -
idle_timeout
: number of seconds that a connection will be kept unused in the pool before it is automatically disconnected (default 300 seconds). Set this to zero to keep connections forever. -
checkout_timeout
: number of seconds to wait for a connection to become available before giving up and raising a timeout error (default 5 seconds).
– Synchronization policy:
-
all public methods can be called outside
synchronize
-
access to these instance variables needs to be in
synchronize
:-
@connections
-
@now_connecting
-
-
private methods that require being called in a
synchronize
blocks are now explicitly documented
Defined Under Namespace
Modules: BiasableQueue, ExecutorHooks Classes: ConnectionLeasingQueue, Lease, LeaseRegistry, Queue, Reaper, WeakThreadKeyMap
Instance Attribute Summary collapse
-
#async_executor ⇒ Object
readonly
Returns the value of attribute async_executor.
-
#automatic_reconnect ⇒ Object
Returns the value of attribute automatic_reconnect.
-
#checkout_timeout ⇒ Object
Returns the value of attribute checkout_timeout.
-
#db_config ⇒ Object
readonly
Returns the value of attribute db_config.
-
#pool_config ⇒ Object
readonly
Returns the value of attribute pool_config.
-
#reaper ⇒ Object
readonly
Returns the value of attribute reaper.
-
#role ⇒ Object
readonly
Returns the value of attribute role.
-
#shard ⇒ Object
readonly
Returns the value of attribute shard.
-
#size ⇒ Object
readonly
Returns the value of attribute size.
Class Method Summary collapse
Instance Method Summary collapse
-
#active_connection? ⇒ Boolean
(also: #active_connection)
Returns true if there is an open connection being used for the current thread.
-
#checkin(conn) ⇒ Object
Check-in a database connection back into the pool, indicating that you no longer need this connection.
-
#checkout(checkout_timeout = @checkout_timeout) ⇒ Object
Check-out a database connection from the pool, indicating that you want to use it.
-
#clear_reloadable_connections(raise_on_acquisition_timeout = true) ⇒ Object
Clears the cache which maps classes and re-connects connections that require reloading.
-
#clear_reloadable_connections! ⇒ Object
Clears the cache which maps classes and re-connects connections that require reloading.
-
#connected? ⇒ Boolean
Returns true if a connection has already been opened.
-
#connection_descriptor ⇒ Object
:nodoc:.
-
#connections ⇒ Object
Returns an array containing the connections currently in the pool.
-
#discard! ⇒ Object
Discards all connections in the pool (even if they’re currently leased!), along with the pool itself.
-
#discarded? ⇒ Boolean
:nodoc:.
-
#disconnect(raise_on_acquisition_timeout = true) ⇒ Object
Disconnects all connections in the pool, and clears the pool.
-
#disconnect! ⇒ Object
Disconnects all connections in the pool, and clears the pool.
-
#flush(minimum_idle = @idle_timeout) ⇒ Object
Disconnect all connections that have been idle for at least
minimum_idle
seconds. -
#flush! ⇒ Object
Disconnect all currently idle connections.
-
#initialize(pool_config) ⇒ ConnectionPool
constructor
Creates a new ConnectionPool object.
-
#inspect ⇒ Object
:nodoc:.
-
#internal_metadata ⇒ Object
:nodoc:.
-
#lease_connection ⇒ Object
Retrieve the connection associated with the current thread, or call #checkout to obtain one if necessary.
-
#migration_context ⇒ Object
:nodoc:.
-
#migrations_paths ⇒ Object
:nodoc:.
-
#new_connection ⇒ Object
:nodoc:.
-
#num_waiting_in_queue ⇒ Object
:nodoc:.
-
#permanent_lease? ⇒ Boolean
:nodoc:.
-
#pin_connection!(lock_thread) ⇒ Object
:nodoc:.
- #pool_transaction_isolation_level ⇒ Object
- #pool_transaction_isolation_level=(isolation_level) ⇒ Object
-
#reap ⇒ Object
Recover lost connections for the pool.
-
#release_connection(existing_lease = nil) ⇒ Object
Signal that the thread is finished with the current connection.
-
#remove(conn) ⇒ Object
Remove a connection from the connection pool.
-
#schedule_query(future_result) ⇒ Object
:nodoc:.
- #schema_cache ⇒ Object
-
#schema_migration ⇒ Object
:nodoc:.
- #schema_reflection=(schema_reflection) ⇒ Object
-
#stat ⇒ Object
Returns the connection pool’s usage statistic.
-
#unpin_connection! ⇒ Object
:nodoc:.
-
#with_connection(prevent_permanent_checkout: false) ⇒ Object
Yields a connection from the connection pool to the block.
-
#with_pool_transaction_isolation_level(isolation_level, transaction_open, &block) ⇒ Object
:nodoc:.
Methods included from QueryCache::ConnectionPoolConfiguration
#clear_query_cache, #dirties_query_cache, #disable_query_cache, #disable_query_cache!, #enable_query_cache, #enable_query_cache!, #query_cache, #query_cache_enabled
Constructor Details
#initialize(pool_config) ⇒ ConnectionPool
Creates a new ConnectionPool object. pool_config
is a PoolConfig object which describes database connection information (e.g. adapter, host name, username, password, etc), as well as the maximum size for this ConnectionPool.
The default ConnectionPool maximum size is 5.
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 237 def initialize(pool_config) super() @pool_config = pool_config @db_config = pool_config.db_config @role = pool_config.role @shard = pool_config.shard @checkout_timeout = db_config.checkout_timeout @idle_timeout = db_config.idle_timeout @size = db_config.pool # This variable tracks the cache of threads mapped to reserved connections, with the # sole purpose of speeding up the +connection+ method. It is not the authoritative # registry of which thread owns which connection. Connection ownership is tracked by # the +connection.owner+ attr on each +connection+ instance. # The invariant works like this: if there is mapping of <tt>thread => conn</tt>, # then that +thread+ does indeed own that +conn+. However, an absence of such # mapping does not mean that the +thread+ doesn't own the said connection. In # that case +conn.owner+ attr should be consulted. # Access and modification of <tt>@leases</tt> does not require # synchronization. @leases = LeaseRegistry.new @connections = [] @automatic_reconnect = true # Connection pool allows for concurrent (outside the main +synchronize+ section) # establishment of new connections. This variable tracks the number of threads # currently in the process of independently establishing connections to the DB. @now_connecting = 0 @threads_blocking_new_connections = 0 @available = ConnectionLeasingQueue.new self @pinned_connection = nil @pinned_connections_depth = 0 @async_executor = build_async_executor @schema_cache = nil @reaper = Reaper.new(self, db_config.reaping_frequency) @reaper.run end |
Instance Attribute Details
#async_executor ⇒ Object (readonly)
Returns the value of attribute async_executor.
227 228 229 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 227 def async_executor @async_executor end |
#automatic_reconnect ⇒ Object
Returns the value of attribute automatic_reconnect.
226 227 228 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 226 def automatic_reconnect @automatic_reconnect end |
#checkout_timeout ⇒ Object
Returns the value of attribute checkout_timeout.
226 227 228 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 226 def checkout_timeout @checkout_timeout end |
#db_config ⇒ Object (readonly)
Returns the value of attribute db_config.
227 228 229 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 227 def db_config @db_config end |
#pool_config ⇒ Object (readonly)
Returns the value of attribute pool_config.
227 228 229 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 227 def pool_config @pool_config end |
#reaper ⇒ Object (readonly)
Returns the value of attribute reaper.
227 228 229 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 227 def reaper @reaper end |
#role ⇒ Object (readonly)
Returns the value of attribute role.
227 228 229 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 227 def role @role end |
#shard ⇒ Object (readonly)
Returns the value of attribute shard.
227 228 229 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 227 def shard @shard end |
#size ⇒ Object (readonly)
Returns the value of attribute size.
227 228 229 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 227 def size @size end |
Class Method Details
.install_executor_hooks(executor = ActiveSupport::Executor) ⇒ Object
217 218 219 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 217 def install_executor_hooks(executor = ActiveSupport::Executor) executor.register_hook(ExecutorHooks) end |
Instance Method Details
#active_connection? ⇒ Boolean Also known as: active_connection
Returns true if there is an open connection being used for the current thread.
This method only works for connections that have been obtained through #lease_connection or #with_connection methods. Connections obtained through #checkout will not be detected by #active_connection?
381 382 383 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 381 def active_connection? connection_lease.connection end |
#checkin(conn) ⇒ Object
Check-in a database connection back into the pool, indicating that you no longer need this connection.
conn
: an AbstractAdapter object, which was obtained by earlier by calling #checkout on this pool.
598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 598 def checkin(conn) return if @pinned_connection.equal?(conn) conn.lock.synchronize do synchronize do connection_lease.clear(conn) conn._run_checkin_callbacks do conn.expire end @available.add conn end end end |
#checkout(checkout_timeout = @checkout_timeout) ⇒ Object
Check-out a database connection from the pool, indicating that you want to use it. You should call #checkin when you no longer need this.
This is done by either returning and leasing existing connection, or by creating a new connection and leasing it.
If all connections are leased and the pool is at capacity (meaning the number of currently leased connections is greater than or equal to the size limit set), an ActiveRecord::ConnectionTimeoutError exception will be raised.
Returns: an AbstractAdapter object.
Raises:
-
ActiveRecord::ConnectionTimeoutError no connection can be obtained from the pool.
570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 570 def checkout(checkout_timeout = @checkout_timeout) return checkout_and_verify(acquire_connection(checkout_timeout)) unless @pinned_connection @pinned_connection.lock.synchronize do synchronize do # The pinned connection may have been cleaned up before we synchronized, so check if it is still present if @pinned_connection @pinned_connection.verify! # Any leased connection must be in @connections otherwise # some methods like #connected? won't behave correctly unless @connections.include?(@pinned_connection) @connections << @pinned_connection end @pinned_connection else checkout_and_verify(acquire_connection(checkout_timeout)) end end end end |
#clear_reloadable_connections(raise_on_acquisition_timeout = true) ⇒ Object
Clears the cache which maps classes and re-connects connections that require reloading.
Raises:
-
ActiveRecord::ExclusiveConnectionTimeoutError if unable to gain ownership of all connections in the pool within a timeout interval (default duration is
spec.db_config.checkout_timeout * 2
seconds).
528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 528 def clear_reloadable_connections(raise_on_acquisition_timeout = true) with_exclusively_acquired_all_connections(raise_on_acquisition_timeout) do synchronize do @connections.each do |conn| if conn.in_use? conn.steal! checkin conn end conn.disconnect! if conn.requires_reloading? end @connections.delete_if(&:requires_reloading?) @available.clear end end end |
#clear_reloadable_connections! ⇒ Object
Clears the cache which maps classes and re-connects connections that require reloading.
The pool first tries to gain ownership of all connections. If unable to do so within a timeout interval (default duration is spec.db_config.checkout_timeout * 2
seconds), then the pool forcefully clears the cache and reloads connections without any regard for other connection owning threads.
552 553 554 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 552 def clear_reloadable_connections! clear_reloadable_connections(false) end |
#connected? ⇒ Boolean
Returns true if a connection has already been opened.
450 451 452 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 450 def connected? synchronize { @connections.any?(&:connected?) } end |
#connection_descriptor ⇒ Object
:nodoc:
372 373 374 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 372 def connection_descriptor # :nodoc: pool_config.connection_descriptor end |
#connections ⇒ Object
Returns an array containing the connections currently in the pool. Access to the array does not require synchronization on the pool because the array is newly created and not retained by the pool.
However; this method bypasses the ConnectionPool’s thread-safe connection access pattern. A returned connection may be owned by another thread, unowned, or by happen-stance owned by the calling thread.
Calling methods on a connection without ownership is subject to the thread-safety guarantees of the underlying method. Many of the methods on connection adapter classes are inherently multi-thread unsafe.
465 466 467 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 465 def connections synchronize { @connections.dup } end |
#discard! ⇒ Object
Discards all connections in the pool (even if they’re currently leased!), along with the pool itself. Any further interaction with the pool (except #spec and #schema_cache) is undefined.
See AbstractAdapter#discard!
507 508 509 510 511 512 513 514 515 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 507 def discard! # :nodoc: synchronize do return if self.discarded? @connections.each do |conn| conn.discard! end @connections = @available = @leases = nil end end |
#discarded? ⇒ Boolean
:nodoc:
517 518 519 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 517 def discarded? # :nodoc: @connections.nil? end |
#disconnect(raise_on_acquisition_timeout = true) ⇒ Object
Disconnects all connections in the pool, and clears the pool.
Raises:
-
ActiveRecord::ExclusiveConnectionTimeoutError if unable to gain ownership of all connections in the pool within a timeout interval (default duration is
spec.db_config.checkout_timeout * 2
seconds).
475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 475 def disconnect(raise_on_acquisition_timeout = true) with_exclusively_acquired_all_connections(raise_on_acquisition_timeout) do synchronize do @connections.each do |conn| if conn.in_use? conn.steal! checkin conn end conn.disconnect! end @connections = [] @leases.clear @available.clear end end end |
#disconnect! ⇒ Object
Disconnects all connections in the pool, and clears the pool.
The pool first tries to gain ownership of all connections. If unable to do so within a timeout interval (default duration is spec.db_config.checkout_timeout * 2
seconds), then the pool is forcefully disconnected without any regard for other connection owning threads.
498 499 500 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 498 def disconnect! disconnect(false) end |
#flush(minimum_idle = @idle_timeout) ⇒ Object
Disconnect all connections that have been idle for at least minimum_idle
seconds. Connections currently checked out, or that were checked in less than minimum_idle
seconds ago, are unaffected.
671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 671 def flush(minimum_idle = @idle_timeout) return if minimum_idle.nil? idle_connections = synchronize do return if self.discarded? @connections.select do |conn| !conn.in_use? && conn.seconds_idle >= minimum_idle end.each do |conn| conn.lease @available.delete conn @connections.delete conn end end idle_connections.each do |conn| conn.disconnect! end end |
#flush! ⇒ Object
Disconnect all currently idle connections. Connections currently checked out are unaffected.
693 694 695 696 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 693 def flush! reap flush(-1) end |
#inspect ⇒ Object
:nodoc:
283 284 285 286 287 288 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 283 def inspect # :nodoc: name_field = " name=#{name_inspect}" if name_inspect shard_field = " shard=#{shard_inspect}" if shard_inspect "#<#{self.class.name} env_name=#{db_config.env_name.inspect}#{name_field} role=#{role.inspect}#{shard_field}>" end |
#internal_metadata ⇒ Object
:nodoc:
311 312 313 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 311 def # :nodoc: InternalMetadata.new(self) end |
#lease_connection ⇒ Object
Retrieve the connection associated with the current thread, or call #checkout to obtain one if necessary.
#lease_connection can be called any number of times; the connection is held in a cache keyed by a thread.
320 321 322 323 324 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 320 def lease_connection lease = connection_lease lease.sticky = true lease.connection ||= checkout end |
#migration_context ⇒ Object
:nodoc:
299 300 301 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 299 def migration_context # :nodoc: MigrationContext.new(migrations_paths, schema_migration, ) end |
#migrations_paths ⇒ Object
:nodoc:
303 304 305 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 303 def migrations_paths # :nodoc: db_config.migrations_paths || Migrator.migrations_paths end |
#new_connection ⇒ Object
:nodoc:
724 725 726 727 728 729 730 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 724 def new_connection # :nodoc: connection = db_config.new_connection connection.pool = self connection rescue ConnectionNotEstablished => ex raise ex.set_pool(self) end |
#num_waiting_in_queue ⇒ Object
:nodoc:
698 699 700 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 698 def num_waiting_in_queue # :nodoc: @available.num_waiting end |
#permanent_lease? ⇒ Boolean
:nodoc:
326 327 328 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 326 def permanent_lease? # :nodoc: connection_lease.sticky.nil? end |
#pin_connection!(lock_thread) ⇒ Object
:nodoc:
330 331 332 333 334 335 336 337 338 339 340 341 342 343 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 330 def pin_connection!(lock_thread) # :nodoc: @pinned_connection ||= (connection_lease&.connection || checkout) @pinned_connections_depth += 1 # Any leased connection must be in @connections otherwise # some methods like #connected? won't behave correctly unless @connections.include?(@pinned_connection) @connections << @pinned_connection end @pinned_connection.lock_thread = ActiveSupport::IsolatedExecutionState.context if lock_thread @pinned_connection.verify! # eagerly validate the connection @pinned_connection.begin_transaction joinable: false, _lazy: false end |
#pool_transaction_isolation_level ⇒ Object
732 733 734 735 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 732 def pool_transaction_isolation_level isolation_level_key = "activerecord_pool_transaction_isolation_level_#{db_config.name}" ActiveSupport::IsolatedExecutionState[isolation_level_key] end |
#pool_transaction_isolation_level=(isolation_level) ⇒ Object
737 738 739 740 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 737 def pool_transaction_isolation_level=(isolation_level) isolation_level_key = "activerecord_pool_transaction_isolation_level_#{db_config.name}" ActiveSupport::IsolatedExecutionState[isolation_level_key] = isolation_level end |
#reap ⇒ Object
Recover lost connections for the pool. A lost connection can occur if a programmer forgets to checkin a connection at the end of a thread or a thread dies unexpectedly.
648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 648 def reap stale_connections = synchronize do return if self.discarded? @connections.select do |conn| conn.in_use? && !conn.owner.alive? end.each do |conn| conn.steal! end end stale_connections.each do |conn| if conn.active? conn.reset! checkin conn else remove conn end end end |
#release_connection(existing_lease = nil) ⇒ Object
Signal that the thread is finished with the current connection. #release_connection releases the connection-thread association and returns the connection to the pool.
This method only works for connections that have been obtained through #lease_connection or #with_connection methods, connections obtained through #checkout will not be automatically released.
393 394 395 396 397 398 399 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 393 def release_connection(existing_lease = nil) if conn = connection_lease.release checkin conn return true end false end |
#remove(conn) ⇒ Object
Remove a connection from the connection pool. The connection will remain open and active but will no longer be managed by this pool.
616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 616 def remove(conn) needs_new_connection = false synchronize do remove_connection_from_thread_cache conn @connections.delete conn @available.delete conn # @available.any_waiting? => true means that prior to removing this # conn, the pool was at its max size (@connections.size == @size). # This would mean that any threads stuck waiting in the queue wouldn't # know they could checkout_new_connection, so let's do it for them. # Because condition-wait loop is encapsulated in the Queue class # (that in turn is oblivious to ConnectionPool implementation), threads # that are "stuck" there are helpless. They have no way of creating # new connections and are completely reliant on us feeding available # connections into the Queue. needs_new_connection = @available.any_waiting? end # This is intentionally done outside of the synchronized section as we # would like not to hold the main mutex while checking out new connections. # Thus there is some chance that needs_new_connection information is now # stale, we can live with that (bulk_make_new_connections will make # sure not to exceed the pool's @size limit). bulk_make_new_connections(1) if needs_new_connection end |
#schedule_query(future_result) ⇒ Object
:nodoc:
719 720 721 722 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 719 def schedule_query(future_result) # :nodoc: @async_executor.post { future_result.execute_or_skip } Thread.pass end |
#schema_cache ⇒ Object
290 291 292 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 290 def schema_cache @schema_cache ||= BoundSchemaReflection.new(schema_reflection, self) end |
#schema_migration ⇒ Object
:nodoc:
307 308 309 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 307 def schema_migration # :nodoc: SchemaMigration.new(self) end |
#schema_reflection=(schema_reflection) ⇒ Object
294 295 296 297 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 294 def schema_reflection=(schema_reflection) pool_config.schema_reflection = schema_reflection @schema_cache = nil end |
#stat ⇒ Object
Returns the connection pool’s usage statistic.
ActiveRecord::Base.connection_pool.stat # => { size: 15, connections: 1, busy: 1, dead: 0, idle: 0, waiting: 0, checkout_timeout: 5 }
705 706 707 708 709 710 711 712 713 714 715 716 717 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 705 def stat synchronize do { size: size, connections: @connections.size, busy: @connections.count { |c| c.in_use? && c.owner.alive? }, dead: @connections.count { |c| c.in_use? && !c.owner.alive? }, idle: @connections.count { |c| !c.in_use? }, waiting: num_waiting_in_queue, checkout_timeout: checkout_timeout } end end |
#unpin_connection! ⇒ Object
:nodoc:
345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 345 def unpin_connection! # :nodoc: raise "There isn't a pinned connection #{object_id}" unless @pinned_connection clean = true @pinned_connection.lock.synchronize do @pinned_connections_depth -= 1 connection = @pinned_connection @pinned_connection = nil if @pinned_connections_depth.zero? if connection.transaction_open? connection.rollback_transaction else # Something committed or rolled back the transaction clean = false connection.reset! end if @pinned_connection.nil? connection.steal! connection.lock_thread = nil checkin(connection) end end clean end |
#with_connection(prevent_permanent_checkout: false) ⇒ Object
Yields a connection from the connection pool to the block. If no connection is already checked out by the current thread, a connection will be checked out from the pool, yielded to the block, and then returned to the pool when the block is finished. If a connection has already been checked out on the current thread, such as via #lease_connection or #with_connection, that existing connection will be the one yielded and it will not be returned to the pool automatically at the end of the block; it is expected that such an existing connection will be properly returned to the pool by the code that checked it out.
410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 410 def with_connection(prevent_permanent_checkout: false) lease = connection_lease sticky_was = lease.sticky lease.sticky = false if prevent_permanent_checkout if lease.connection begin yield lease.connection ensure lease.sticky = sticky_was if prevent_permanent_checkout && !sticky_was end else begin yield lease.connection = checkout ensure lease.sticky = sticky_was if prevent_permanent_checkout && !sticky_was release_connection(lease) unless lease.sticky end end end |
#with_pool_transaction_isolation_level(isolation_level, transaction_open, &block) ⇒ Object
:nodoc:
431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 |
# File 'activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb', line 431 def with_pool_transaction_isolation_level(isolation_level, transaction_open, &block) # :nodoc: if !ActiveRecord.default_transaction_isolation_level.nil? begin if transaction_open && self.pool_transaction_isolation_level != ActiveRecord.default_transaction_isolation_level raise ActiveRecord::TransactionIsolationError, "cannot set default isolation level while transaction is open" end old_level = self.pool_transaction_isolation_level self.pool_transaction_isolation_level = isolation_level yield ensure self.pool_transaction_isolation_level = old_level end else yield end end |