activerecord 7.0.8.7 → 7.2.2.1

data/lib/active_record/coders/yaml_column.rb

@@ -4,37 +4,83 @@ require "yaml"
 
 module ActiveRecord
   module Coders # :nodoc:
-    class YAMLColumn # :nodoc:
-      attr_accessor :object_class
-
-      def initialize(attr_name, object_class = Object)
-        @attr_name = attr_name
-        @object_class = object_class
-        check_arity_of_constructor
-      end
+    class YAMLColumn < ColumnSerializer # :nodoc:
+      class SafeCoder
+        def initialize(permitted_classes: [], unsafe_load: nil)
+          @permitted_classes = permitted_classes
+          @unsafe_load = unsafe_load
+        end
 
-      def dump(obj)
-        return if obj.nil?
+        if Gem::Version.new(Psych::VERSION) >= Gem::Version.new("5.1")
+          def dump(object)
+            if @unsafe_load.nil? ? ActiveRecord.use_yaml_unsafe_load : @unsafe_load
+              ::YAML.dump(object)
+            else
+              ::YAML.safe_dump(
+                object,
+                permitted_classes: @permitted_classes + ActiveRecord.yaml_column_permitted_classes,
+                aliases: true,
+              )
+            end
+          end
+        else
+          def dump(object)
+            YAML.dump(object)
+          end
+        end
 
-        assert_valid_value(obj, action: "dump")
-        YAML.dump obj
+        if YAML.respond_to?(:unsafe_load)
+          def load(payload)
+            if @unsafe_load.nil? ? ActiveRecord.use_yaml_unsafe_load : @unsafe_load
+              YAML.unsafe_load(payload)
+            else
+              YAML.safe_load(
+                payload,
+                permitted_classes: @permitted_classes + ActiveRecord.yaml_column_permitted_classes,
+                aliases: true,
+              )
+            end
+          end
+        else
+          def load(payload)
+            if @unsafe_load.nil? ? ActiveRecord.use_yaml_unsafe_load : @unsafe_load
+              YAML.load(payload)
+            else
+              YAML.safe_load(
+                payload,
+                permitted_classes: @permitted_classes + ActiveRecord.yaml_column_permitted_classes,
+                aliases: true,
+              )
+            end
+          end
+        end
       end
 
-      def load(yaml)
-        return object_class.new if object_class != Object && yaml.nil?
-        return yaml unless yaml.is_a?(String) && yaml.start_with?("---")
-        obj = yaml_load(yaml)
-
-        assert_valid_value(obj, action: "load")
-        obj ||= object_class.new if object_class != Object
+      def initialize(attr_name, object_class = Object, permitted_classes: [], unsafe_load: nil)
+        super(
+          attr_name,
+          SafeCoder.new(permitted_classes: permitted_classes || [], unsafe_load: unsafe_load),
+          object_class,
+        )
+        check_arity_of_constructor
+      end
 
-        obj
+      def init_with(coder) # :nodoc:
+        unless coder["coder"]
+          permitted_classes = coder["permitted_classes"] || []
+          unsafe_load = coder["unsafe_load"] || false
+          coder["coder"] = SafeCoder.new(permitted_classes: permitted_classes, unsafe_load: unsafe_load)
+        end
+        super(coder)
       end
 
-      def assert_valid_value(obj, action:)
-        unless obj.nil? || obj.is_a?(object_class)
-          raise SerializationTypeMismatch,
-            "can't #{action} `#{@attr_name}`: was supposed to be a #{object_class}, but was a #{obj.class}. -- #{obj.inspect}"
+      def coder
+        # This is to retain forward compatibility when loading records serialized with Marshal
+        # from a previous version of Rails.
+        @coder ||= begin
+          permitted_classes = defined?(@permitted_classes) ? @permitted_classes : []
+          unsafe_load = defined?(@unsafe_load) && @unsafe_load.nil?
+          SafeCoder.new(permitted_classes: permitted_classes, unsafe_load: unsafe_load)
         end
       end
 
@@ -44,24 +90,6 @@ module ActiveRecord
         rescue ArgumentError
           raise ArgumentError, "Cannot serialize #{object_class}. Classes passed to `serialize` must have a 0 argument constructor."
         end
-
-        if YAML.respond_to?(:unsafe_load)
-          def yaml_load(payload)
-            if ActiveRecord.use_yaml_unsafe_load
-              YAML.unsafe_load(payload)
-            else
-              YAML.safe_load(payload, permitted_classes: ActiveRecord.yaml_column_permitted_classes, aliases: true)
-            end
-          end
-        else
-          def yaml_load(payload)
-            if ActiveRecord.use_yaml_unsafe_load
-              YAML.load(payload)
-            else
-              YAML.safe_load(payload, permitted_classes: ActiveRecord.yaml_column_permitted_classes, aliases: true)
-            end
-          end
-        end
     end
   end
 end

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

@@ -5,6 +5,8 @@ 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.
     #
@@ -53,10 +55,7 @@ module ActiveRecord
     # 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 StringConnectionOwner # :nodoc:
+      class StringConnectionName # :nodoc:
         attr_reader :name
 
         def initialize(name)
@@ -73,11 +72,8 @@ module ActiveRecord
       end
 
       def initialize
-        # These caches are keyed by pool_config.connection_specification_name (PoolConfig#connection_specification_name).
-        @owner_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
+        # These caches are keyed by pool_config.connection_name (PoolConfig#connection_name).
+        @connection_name_to_pool_manager = Concurrent::Map.new(initial_capacity: 2)
       end
 
       def prevent_writes # :nodoc:
@@ -88,138 +84,167 @@ module ActiveRecord
         ActiveSupport::IsolatedExecutionState[:active_record_prevent_writes] = prevent_writes
       end
 
-      # Prevent writing to the database regardless of role.
-      #
-      # In some cases you may want to prevent writes to the database
-      # even if you are on a database that can write. +while_preventing_writes+
-      # will prevent writes to the database for the duration of the block.
-      #
-      # This method does not provide the same protection as a readonly
-      # user and is meant to be a safeguard against accidental writes.
-      #
-      # See +READ_QUERY+ for the queries that are blocked by this
-      # method.
-      def while_preventing_writes(enabled = true)
-        unless ActiveRecord.legacy_connection_handling
-          raise NotImplementedError, "`while_preventing_writes` is only available on the connection_handler with legacy_connection_handling"
-        end
-
-        original, self.prevent_writes = self.prevent_writes, enabled
-        yield
-      ensure
-        self.prevent_writes = original
-      end
-
       def connection_pool_names # :nodoc:
-        owner_to_pool_manager.keys
+        connection_name_to_pool_manager.keys
       end
 
-      def all_connection_pools
-        owner_to_pool_manager.values.flat_map { |m| m.pool_configs.map(&:pool) }
+      # 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? || 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?
 
-      def connection_pool_list(role = ActiveRecord::Base.current_role)
-        owner_to_pool_manager.values.flat_map { |m| m.pool_configs(role).map(&:pool) }
+        connection_name_to_pool_manager.each_value do |manager|
+          manager.each_pool_config(role) do |pool_config|
+            yield pool_config.pool
+          end
+        end
       end
-      alias :connection_pools :connection_pool_list
 
-      def establish_connection(config, owner_name: Base, role: ActiveRecord::Base.current_role, shard: Base.current_shard)
-        owner_name = StringConnectionOwner.new(config.to_s) if config.is_a?(Symbol)
+      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
 
-        # Protects the connection named `ActiveRecord::Base` from being removed
-        # if the user calls `establish_connection :primary`.
-        if owner_to_pool_manager.key?(pool_config.connection_specification_name)
-          remove_connection_pool(pool_config.connection_specification_name, role: role, shard: shard)
-        end
+        pool_manager = set_pool_manager(pool_config.connection_name)
 
-        message_bus = ActiveSupport::Notifications.instrumenter
-        payload = {}
-        if pool_config
-          payload[:spec_name] = pool_config.connection_specification_name
-          payload[:shard] = shard
-          payload[:config] = db_config.configuration_hash
-        end
+        # 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 ActiveRecord.legacy_connection_handling
-          owner_to_pool_manager[pool_config.connection_specification_name] ||= LegacyPoolManager.new
-        else
-          owner_to_pool_manager[pool_config.connection_specification_name] ||= PoolManager.new
-        end
-        pool_manager = get_pool_manager(pool_config.connection_specification_name)
-        pool_manager.set_pool_config(role, shard, pool_config)
+        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
 
-        message_bus.instrument("!connection.active_record", payload) do
-          pool_config.pool
+          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 = ActiveRecord::Base.current_role)
-        connection_pool_list(role).any?(&:active_connection?)
+      def active_connections?(role = nil)
+        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 = ActiveRecord::Base.current_role)
-        connection_pool_list(role).each(&:release_connection)
+      def clear_active_connections!(role = nil)
+        each_connection_pool(role).each do |pool|
+          pool.release_connection
+          pool.disable_query_cache!
+        end
       end
 
       # Clears the cache which maps classes.
       #
       # See ConnectionPool#clear_reloadable_connections! for details.
-      def clear_reloadable_connections!(role = ActiveRecord::Base.current_role)
-        connection_pool_list(role).each(&:clear_reloadable_connections!)
+      def clear_reloadable_connections!(role = nil)
+        each_connection_pool(role).each(&:clear_reloadable_connections!)
       end
 
-      def clear_all_connections!(role = ActiveRecord::Base.current_role)
-        connection_pool_list(role).each(&:disconnect!)
+      def clear_all_connections!(role = nil)
+        each_connection_pool(role).each(&:disconnect!)
       end
 
       # Disconnects all currently idle connections.
       #
       # See ConnectionPool#flush! for details.
-      def flush_idle_connections!(role = ActiveRecord::Base.current_role)
-        connection_pool_list(role).each(&:flush!)
+      def flush_idle_connections!(role = nil)
+        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(spec_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard) # :nodoc:
-        pool = retrieve_connection_pool(spec_name, role: role, shard: shard)
+      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, strict: true)
+        pool.lease_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
 
-        unless pool
+      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, strict: false)
+        pool = get_pool_manager(connection_name)&.get_pool_config(role, shard)&.pool
+
+        if strict && !pool
           if shard != ActiveRecord::Base.default_shard
-            message = "No connection pool for '#{spec_name}' found for the '#{shard}' shard."
-          elsif ActiveRecord::Base.connection_handler != ActiveRecord::Base.default_connection_handler
-            message = "No connection pool for '#{spec_name}' found for the '#{ActiveRecord::Base.current_role}' role."
+            message = "No connection pool for '#{connection_name}' found for the '#{shard}' shard."
           elsif role != ActiveRecord::Base.default_role
-            message = "No connection pool for '#{spec_name}' found for the '#{role}' role."
+            message = "No connection pool for '#{connection_name}' found for the '#{role}' role."
           else
-            message = "No connection pool for '#{spec_name}' found."
+            message = "No connection pool for '#{connection_name}' found."
           end
 
           raise ConnectionNotEstablished, message
         end
 
-        pool.connection
+        pool
       end
 
-      # Returns true if a connection that's accessible to this class has
-      # already been opened.
-      def connected?(spec_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard)
-        pool = retrieve_connection_pool(spec_name, role: role, shard: shard)
-        pool && pool.connected?
-      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 remove_connection_pool(owner, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard)
-        if pool_manager = get_pool_manager(owner)
+        def disconnect_pool_from_pool_manager(pool_manager, role, shard)
           pool_config = pool_manager.remove_pool_config(role, shard)
 
           if pool_config
@@ -227,23 +252,6 @@ module ActiveRecord
             pool_config.db_config
           end
         end
-      end
-
-      # Retrieving the connection pool happens a lot, so we cache it in @owner_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(owner, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard)
-        pool_config = get_pool_manager(owner)&.get_pool_config(role, shard)
-        pool_config&.pool
-      end
-
-      private
-        attr_reader :owner_to_pool_manager
-
-        # Returns the pool manager for an owner.
-        def get_pool_manager(owner)
-          owner_to_pool_manager[owner]
-        end
 
         # Returns an instance of PoolConfig for a given adapter.
         # Accepts a hash one layer deep that contains all connection information.
@@ -255,37 +263,21 @@ module ActiveRecord
         #   pool_config.db_config.configuration_hash
         #   # => { host: "localhost", database: "foo", adapter: "sqlite3" }
         #
-        def resolve_pool_config(config, owner_name, role, shard)
+        def resolve_pool_config(config, connection_name, role, shard)
           db_config = Base.configurations.resolve(config)
-
+          db_config.validate!
           raise(AdapterNotSpecified, "database configuration does not specify adapter") unless db_config.adapter
+          ConnectionAdapters::PoolConfig.new(connection_name, db_config, role, shard)
+        end
 
-          # 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"
+        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
-
-          ConnectionAdapters::PoolConfig.new(owner_name, db_config, role, shard)
         end
     end
   end

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

@@ -6,6 +6,8 @@ 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

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

@@ -6,12 +6,14 @@ 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).
+      # YAML file (default 60 seconds).
       class Reaper
         attr_reader :pool, :frequency
 
@@ -41,6 +43,7 @@ module ActiveRecord
                 # Advise multi-threaded app servers to ignore this thread for
                 # the purposes of fork safety warnings
                 Thread.current.thread_variable_set(:fork_safe, true)
+                Thread.current.name = "AR Pool Reaper"
                 running = true
                 while running
                   sleep t