activerecord 6.1.7 → 7.1.5

data/lib/active_record/connection_adapters/abstract/connection_handler.rb

@@ -0,0 +1,367 @@
+# frozen_string_literal: true
+
+require "thread"
+require "concurrent/map"
+
+module ActiveRecord
+  module ConnectionAdapters
+    # = Active Record Connection Handler
+    #
+    # ConnectionHandler is a collection of ConnectionPool objects. It is used
+    # for keeping separate connection pools that connect to different databases.
+    #
+    # For example, suppose that you have 5 models, with the following hierarchy:
+    #
+    #   class Author < ActiveRecord::Base
+    #   end
+    #
+    #   class BankAccount < ActiveRecord::Base
+    #   end
+    #
+    #   class Book < ActiveRecord::Base
+    #     establish_connection :library_db
+    #   end
+    #
+    #   class ScaryBook < Book
+    #   end
+    #
+    #   class GoodBook < Book
+    #   end
+    #
+    # And a database.yml that looked like this:
+    #
+    #   development:
+    #     database: my_application
+    #     host: localhost
+    #
+    #   library_db:
+    #     database: library
+    #     host: some.library.org
+    #
+    # Your primary database in the development environment is "my_application"
+    # but the Book model connects to a separate database called "library_db"
+    # (this can even be a database on a different machine).
+    #
+    # Book, ScaryBook, and GoodBook will all use the same connection pool to
+    # "library_db" while Author, BankAccount, and any other models you create
+    # will use the default connection pool to "my_application".
+    #
+    # The various connection pools are managed by a single instance of
+    # ConnectionHandler accessible via ActiveRecord::Base.connection_handler.
+    # All Active Record models use this handler to determine the connection pool that they
+    # should use.
+    #
+    # The ConnectionHandler class is not coupled with the Active models, as it has no knowledge
+    # about the model. The model needs to pass a connection specification name to the handler,
+    # in order to look up the correct connection pool.
+    class ConnectionHandler
+      FINALIZER = lambda { |_| ActiveSupport::ForkTracker.check! }
+      private_constant :FINALIZER
+
+      class StringConnectionName # :nodoc:
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def primary_class?
+          false
+        end
+
+        def current_preventing_writes
+          false
+        end
+      end
+
+      def initialize
+        # These caches are keyed by pool_config.connection_name (PoolConfig#connection_name).
+        @connection_name_to_pool_manager = Concurrent::Map.new(initial_capacity: 2)
+
+        # Backup finalizer: if the forked child skipped Kernel#fork the early discard has not occurred
+        ObjectSpace.define_finalizer self, FINALIZER
+      end
+
+      def prevent_writes # :nodoc:
+        ActiveSupport::IsolatedExecutionState[:active_record_prevent_writes]
+      end
+
+      def prevent_writes=(prevent_writes) # :nodoc:
+        ActiveSupport::IsolatedExecutionState[:active_record_prevent_writes] = prevent_writes
+      end
+
+      def connection_pool_names # :nodoc:
+        connection_name_to_pool_manager.keys
+      end
+
+      def all_connection_pools
+        ActiveRecord.deprecator.warn(<<-MSG.squish)
+          The `all_connection_pools` method is deprecated in favor of `connection_pool_list`.
+          Call `connection_pool_list(:all)` to get the same behavior as `all_connection_pools`.
+        MSG
+        connection_name_to_pool_manager.values.flat_map { |m| m.pool_configs.map(&:pool) }
+      end
+
+      # Returns the pools for a connection handler and  given role. If +:all+ is passed,
+      # all pools belonging to the connection handler will be returned.
+      def connection_pool_list(role = nil)
+        if role.nil?
+          deprecation_for_pool_handling(__method__)
+          role = ActiveRecord::Base.current_role
+          connection_name_to_pool_manager.values.flat_map { |m| m.pool_configs(role).map(&:pool) }
+        elsif role == :all
+          connection_name_to_pool_manager.values.flat_map { |m| m.pool_configs.map(&:pool) }
+        else
+          connection_name_to_pool_manager.values.flat_map { |m| m.pool_configs(role).map(&:pool) }
+        end
+      end
+      alias :connection_pools :connection_pool_list
+
+      def each_connection_pool(role = nil, &block) # :nodoc:
+        role = nil if role == :all
+        return enum_for(__method__, role) unless block_given?
+
+        connection_name_to_pool_manager.each_value do |manager|
+          manager.each_pool_config(role) do |pool_config|
+            yield pool_config.pool
+          end
+        end
+      end
+
+      def establish_connection(config, owner_name: Base, role: Base.current_role, shard: Base.current_shard, clobber: false)
+        owner_name = determine_owner_name(owner_name, config)
+
+        pool_config = resolve_pool_config(config, owner_name, role, shard)
+        db_config = pool_config.db_config
+
+        pool_manager = set_pool_manager(pool_config.connection_name)
+
+        # If there is an existing pool with the same values as the pool_config
+        # don't remove the connection. Connections should only be removed if we are
+        # establishing a connection on a class that is already connected to a different
+        # configuration.
+        existing_pool_config = pool_manager.get_pool_config(role, shard)
+
+        if !clobber && existing_pool_config && existing_pool_config.db_config == db_config
+          # Update the pool_config's connection class if it differs. This is used
+          # for ensuring that ActiveRecord::Base and the primary_abstract_class use
+          # the same pool. Without this granular swapping will not work correctly.
+          if owner_name.primary_class? && (existing_pool_config.connection_class != owner_name)
+            existing_pool_config.connection_class = owner_name
+          end
+
+          existing_pool_config.pool
+        else
+          disconnect_pool_from_pool_manager(pool_manager, role, shard)
+          pool_manager.set_pool_config(role, shard, pool_config)
+
+          payload = {
+            connection_name: pool_config.connection_name,
+            role: role,
+            shard: shard,
+            config: db_config.configuration_hash
+          }
+
+          ActiveSupport::Notifications.instrumenter.instrument("!connection.active_record", payload) do
+            pool_config.pool
+          end
+        end
+      end
+
+      # Returns true if there are any active connections among the connection
+      # pools that the ConnectionHandler is managing.
+      def active_connections?(role = nil)
+        if role.nil?
+          deprecation_for_pool_handling(__method__)
+          role = ActiveRecord::Base.current_role
+        end
+
+        each_connection_pool(role).any?(&:active_connection?)
+      end
+
+      # Returns any connections in use by the current thread back to the pool,
+      # and also returns connections to the pool cached by threads that are no
+      # longer alive.
+      def clear_active_connections!(role = nil)
+        if role.nil?
+          deprecation_for_pool_handling(__method__)
+          role = ActiveRecord::Base.current_role
+        end
+
+        each_connection_pool(role).each(&:release_connection)
+      end
+
+      # Clears the cache which maps classes.
+      #
+      # See ConnectionPool#clear_reloadable_connections! for details.
+      def clear_reloadable_connections!(role = nil)
+        if role.nil?
+          deprecation_for_pool_handling(__method__)
+          role = ActiveRecord::Base.current_role
+        end
+
+        each_connection_pool(role).each(&:clear_reloadable_connections!)
+      end
+
+      def clear_all_connections!(role = nil)
+        if role.nil?
+          deprecation_for_pool_handling(__method__)
+          role = ActiveRecord::Base.current_role
+        end
+
+        each_connection_pool(role).each(&:disconnect!)
+      end
+
+      # Disconnects all currently idle connections.
+      #
+      # See ConnectionPool#flush! for details.
+      def flush_idle_connections!(role = nil)
+        if role.nil?
+          deprecation_for_pool_handling(__method__)
+          role = ActiveRecord::Base.current_role
+        end
+
+        each_connection_pool(role).each(&:flush!)
+      end
+
+      # Locate the connection of the nearest super class. This can be an
+      # active or defined connection: 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 retrieve_connection(connection_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard) # :nodoc:
+        pool = retrieve_connection_pool(connection_name, role: role, shard: shard)
+
+        unless pool
+          if shard != ActiveRecord::Base.default_shard
+            message = "No connection pool for '#{connection_name}' found for the '#{shard}' shard."
+          elsif role != ActiveRecord::Base.default_role
+            message = "No connection pool for '#{connection_name}' found for the '#{role}' role."
+          else
+            message = "No connection pool for '#{connection_name}' found."
+          end
+
+          raise ConnectionNotEstablished, message
+        end
+
+        pool.connection
+      end
+
+      # Returns true if a connection that's accessible to this class has
+      # already been opened.
+      def connected?(connection_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard)
+        pool = retrieve_connection_pool(connection_name, role: role, shard: shard)
+        pool && pool.connected?
+      end
+
+      def remove_connection_pool(connection_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard)
+        if pool_manager = get_pool_manager(connection_name)
+          disconnect_pool_from_pool_manager(pool_manager, role, shard)
+        end
+      end
+
+      # Retrieving the connection pool happens a lot, so we cache it in @connection_name_to_pool_manager.
+      # This makes retrieving the connection pool O(1) once the process is warm.
+      # When a connection is established or removed, we invalidate the cache.
+      def retrieve_connection_pool(connection_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard)
+        pool_config = get_pool_manager(connection_name)&.get_pool_config(role, shard)
+        pool_config&.pool
+      end
+
+      private
+        attr_reader :connection_name_to_pool_manager
+
+        # Returns the pool manager for a connection name / identifier.
+        def get_pool_manager(connection_name)
+          connection_name_to_pool_manager[connection_name]
+        end
+
+        # Get the existing pool manager or initialize and assign a new one.
+        def set_pool_manager(connection_name)
+          connection_name_to_pool_manager[connection_name] ||= PoolManager.new
+        end
+
+        def pool_managers
+          connection_name_to_pool_manager.values
+        end
+
+        def deprecation_for_pool_handling(method)
+          roles = []
+          pool_managers.each do |pool_manager|
+            roles << pool_manager.role_names
+          end
+
+          if roles.flatten.uniq.count > 1
+            ActiveRecord.deprecator.warn(<<-MSG.squish)
+              `#{method}` currently only applies to connection pools in the current
+              role (`#{ActiveRecord::Base.current_role}`). In Rails 7.2, this method
+              will apply to all known pools, regardless of role. To affect only those
+              connections belonging to a specific role, pass the role name as an
+              argument. To switch to the new behavior, pass `:all` as the role name.
+            MSG
+          end
+        end
+
+        def disconnect_pool_from_pool_manager(pool_manager, role, shard)
+          pool_config = pool_manager.remove_pool_config(role, shard)
+
+          if pool_config
+            pool_config.disconnect!
+            pool_config.db_config
+          end
+        end
+
+        # Returns an instance of PoolConfig for a given adapter.
+        # Accepts a hash one layer deep that contains all connection information.
+        #
+        # == Example
+        #
+        #   config = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
+        #   pool_config = Base.configurations.resolve_pool_config(:production)
+        #   pool_config.db_config.configuration_hash
+        #   # => { host: "localhost", database: "foo", adapter: "sqlite3" }
+        #
+        def resolve_pool_config(config, connection_name, role, shard)
+          db_config = Base.configurations.resolve(config)
+
+          raise(AdapterNotSpecified, "database configuration does not specify adapter") unless db_config.adapter
+
+          # Require the adapter itself and give useful feedback about
+          #   1. Missing adapter gems and
+          #   2. Adapter gems' missing dependencies.
+          path_to_adapter = "active_record/connection_adapters/#{db_config.adapter}_adapter"
+          begin
+            require path_to_adapter
+          rescue LoadError => e
+            # We couldn't require the adapter itself. Raise an exception that
+            # points out config typos and missing gems.
+            if e.path == path_to_adapter
+              # We can assume that a non-builtin adapter was specified, so it's
+              # either misspelled or missing from Gemfile.
+              raise LoadError, "Could not load the '#{db_config.adapter}' Active Record adapter. Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary adapter gem to your Gemfile.", e.backtrace
+
+              # Bubbled up from the adapter require. Prefix the exception message
+              # with some guidance about how to address it and reraise.
+            else
+              raise LoadError, "Error loading the '#{db_config.adapter}' Active Record adapter. Missing a gem it depends on? #{e.message}", e.backtrace
+            end
+          end
+
+          unless ActiveRecord::Base.respond_to?(db_config.adapter_method)
+            raise AdapterNotFound, "database configuration specifies nonexistent #{db_config.adapter} adapter"
+          end
+
+          ConnectionAdapters::PoolConfig.new(connection_name, db_config, role, shard)
+        end
+
+        def determine_owner_name(owner_name, config)
+          if owner_name.is_a?(String) || owner_name.is_a?(Symbol)
+            StringConnectionName.new(owner_name.to_s)
+          elsif config.is_a?(Symbol)
+            StringConnectionName.new(config.to_s)
+          else
+            owner_name
+          end
+        end
+    end
+  end
+end

data/lib/active_record/connection_adapters/abstract/connection_pool/queue.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "thread"
+require "monitor"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionPool
+      # = Active Record Connection Pool \Queue
+      #
+      # Threadsafe, fair, LIFO queue.  Meant to be used by ConnectionPool
+      # with which it shares a Monitor.
+      class Queue
+        def initialize(lock = Monitor.new)
+          @lock = lock
+          @cond = @lock.new_cond
+          @num_waiting = 0
+          @queue = []
+        end
+
+        # Test if any threads are currently waiting on the queue.
+        def any_waiting?
+          synchronize do
+            @num_waiting > 0
+          end
+        end
+
+        # Returns the number of threads currently waiting on this
+        # queue.
+        def num_waiting
+          synchronize do
+            @num_waiting
+          end
+        end
+
+        # Add +element+ to the queue.  Never blocks.
+        def add(element)
+          synchronize do
+            @queue.push element
+            @cond.signal
+          end
+        end
+
+        # If +element+ is in the queue, remove and return it, or +nil+.
+        def delete(element)
+          synchronize do
+            @queue.delete(element)
+          end
+        end
+
+        # Remove all elements from the queue.
+        def clear
+          synchronize do
+            @queue.clear
+          end
+        end
+
+        # Remove the head of the queue.
+        #
+        # If +timeout+ is not given, remove and return the head of the
+        # queue if the number of available elements is strictly
+        # greater than the number of threads currently waiting (that
+        # is, don't jump ahead in line).  Otherwise, return +nil+.
+        #
+        # If +timeout+ is given, block if there is no element
+        # available, waiting up to +timeout+ seconds for an element to
+        # become available.
+        #
+        # Raises:
+        # - ActiveRecord::ConnectionTimeoutError if +timeout+ is given and no element
+        # becomes available within +timeout+ seconds,
+        def poll(timeout = nil)
+          synchronize { internal_poll(timeout) }
+        end
+
+        private
+          def internal_poll(timeout)
+            no_wait_poll || (timeout && wait_poll(timeout))
+          end
+
+          def synchronize(&block)
+            @lock.synchronize(&block)
+          end
+
+          # Test if the queue currently contains any elements.
+          def any?
+            !@queue.empty?
+          end
+
+          # A thread can remove an element from the queue without
+          # waiting if and only if the number of currently available
+          # connections is strictly greater than the number of waiting
+          # threads.
+          def can_remove_no_wait?
+            @queue.size > @num_waiting
+          end
+
+          # Removes and returns the head of the queue if possible, or +nil+.
+          def remove
+            @queue.pop
+          end
+
+          # Remove and return the head of the queue if the number of
+          # available elements is strictly greater than the number of
+          # threads currently waiting.  Otherwise, return +nil+.
+          def no_wait_poll
+            remove if can_remove_no_wait?
+          end
+
+          # Waits on the queue up to +timeout+ seconds, then removes and
+          # returns the head of the queue.
+          def wait_poll(timeout)
+            @num_waiting += 1
+
+            t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            elapsed = 0
+            loop do
+              ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+                @cond.wait(timeout - elapsed)
+              end
+
+              return remove if any?
+
+              elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+              if elapsed >= timeout
+                msg = "could not obtain a connection from the pool within %0.3f seconds (waited %0.3f seconds); all pooled connections were in use" %
+                  [timeout, elapsed]
+                raise ConnectionTimeoutError, msg
+              end
+            end
+          ensure
+            @num_waiting -= 1
+          end
+      end
+
+      # Adds the ability to turn a basic fair FIFO queue into one
+      # biased to some thread.
+      module BiasableQueue # :nodoc:
+        class BiasedConditionVariable # :nodoc:
+          # semantics of condition variables guarantee that +broadcast+, +broadcast_on_biased+,
+          # +signal+ and +wait+ methods are only called while holding a lock
+          def initialize(lock, other_cond, preferred_thread)
+            @real_cond = lock.new_cond
+            @other_cond = other_cond
+            @preferred_thread = preferred_thread
+            @num_waiting_on_real_cond = 0
+          end
+
+          def broadcast
+            broadcast_on_biased
+            @other_cond.broadcast
+          end
+
+          def broadcast_on_biased
+            @num_waiting_on_real_cond = 0
+            @real_cond.broadcast
+          end
+
+          def signal
+            if @num_waiting_on_real_cond > 0
+              @num_waiting_on_real_cond -= 1
+              @real_cond
+            else
+              @other_cond
+            end.signal
+          end
+
+          def wait(timeout)
+            if Thread.current == @preferred_thread
+              @num_waiting_on_real_cond += 1
+              @real_cond
+            else
+              @other_cond
+            end.wait(timeout)
+          end
+        end
+
+        def with_a_bias_for(thread)
+          previous_cond = nil
+          new_cond      = nil
+          synchronize do
+            previous_cond = @cond
+            @cond = new_cond = BiasedConditionVariable.new(@lock, @cond, thread)
+          end
+          yield
+        ensure
+          synchronize do
+            @cond = previous_cond if previous_cond
+            new_cond.broadcast_on_biased if new_cond # wake up any remaining sleepers
+          end
+        end
+      end
+
+      # Connections must be leased while holding the main pool mutex. This is
+      # an internal subclass that also +.leases+ returned connections while
+      # still in queue's critical section (queue synchronizes with the same
+      # <tt>@lock</tt> as the main pool) so that a returned connection is already
+      # leased and there is no need to re-enter synchronized block.
+      class ConnectionLeasingQueue < Queue # :nodoc:
+        include BiasableQueue
+
+        private
+          def internal_poll(timeout)
+            conn = super
+            conn.lease if conn
+            conn
+          end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/abstract/connection_pool/reaper.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "thread"
+require "weakref"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionPool
+      # = Active Record Connection Pool \Reaper
+      #
+      # Every +frequency+ seconds, the reaper will call +reap+ and +flush+ on
+      # +pool+. A reaper instantiated with a zero frequency will never reap
+      # the connection pool.
+      #
+      # Configure the frequency by setting +reaping_frequency+ in your database
+      # YAML file (default 60 seconds).
+      class Reaper
+        attr_reader :pool, :frequency
+
+        def initialize(pool, frequency)
+          @pool      = pool
+          @frequency = frequency
+        end
+
+        @mutex = Mutex.new
+        @pools = {}
+        @threads = {}
+
+        class << self
+          def register_pool(pool, frequency) # :nodoc:
+            @mutex.synchronize do
+              unless @threads[frequency]&.alive?
+                @threads[frequency] = spawn_thread(frequency)
+              end
+              @pools[frequency] ||= []
+              @pools[frequency] << WeakRef.new(pool)
+            end
+          end
+
+          private
+            def spawn_thread(frequency)
+              Thread.new(frequency) do |t|
+                # Advise multi-threaded app servers to ignore this thread for
+                # the purposes of fork safety warnings
+                Thread.current.thread_variable_set(:fork_safe, true)
+                running = true
+                while running
+                  sleep t
+                  @mutex.synchronize do
+                    @pools[frequency].select! do |pool|
+                      pool.weakref_alive? && !pool.discarded?
+                    end
+
+                    @pools[frequency].each do |p|
+                      p.reap
+                      p.flush
+                    rescue WeakRef::RefError
+                    end
+
+                    if @pools[frequency].empty?
+                      @pools.delete(frequency)
+                      @threads.delete(frequency)
+                      running = false
+                    end
+                  end
+                end
+              end
+            end
+        end
+
+        def run
+          return unless frequency && frequency > 0
+          self.class.register_pool(pool, frequency)
+        end
+      end
+    end
+  end
+end