active_record_host_pool 1.0.2 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5eb359cbe2626874bf6836ee5b5b1826ccf02fef7b474f81f5eec273435232d0
-  data.tar.gz: 40383e9f54da681dd340b7dba75aac65613a34fd083862bf96a905f766c9f7ea
+  metadata.gz: 2dc3e41230c1cc7b208056d7f6fe99abe717e190b55cdca3ff5df9f1513fcad1
+  data.tar.gz: 92f1982d46da0644184083a78d72ad878d54ff70413f347fcb67bc3890cfaeca
 SHA512:
-  metadata.gz: 84d8eaafd2a6ebd88a42e89c8a52113b1ae3654123bf6d6735256e4787563862024af288b9755c254d445151c43d35502f52608e468beed6daad309225fb4480
-  data.tar.gz: 9a6493969b78849cea22220f562371e25a8215015ee747c5bf8ca533dfca4db21a637336c127c7abc50e6eee7d31843dd75b14fcbe7f329e461e2a24dc0fbd35
+  metadata.gz: b3e4c62f5aee3ae968622ca9a7fef59fd9974c4153c244c312715036f6753a0ec58ba3083247bb9a4b9479db3a3c55a8182c85ae320d273ad90a1084ea745b46
+  data.tar.gz: 1fcec2e7e23272e50894a19bd4fc195e0360089d3a5e44f98fc6a589723f3a6bb8dae2276dbeeec31f05f87f89641308909412b28f73f929bc2358605fe30937

data/Readme.md

@@ -5,6 +5,42 @@
 This gem allows for one ActiveRecord connection to be used to connect to multiple databases on a server.
 It accomplishes this by calling select_db() as necessary to switch databases between database calls.
 
+## How Connections Are Pooled
+
+ARHP creates separate connection pools based on the pool key.
+
+The pool key is defined as:
+
+`host / port / socket / username / replica`
+
+Therefore two databases with identical host, port, socket, username, and replica status will share a connection pool.
+If any part (host, port, etc.) of the pool key differ, two databases will _not_ share a connection pool.
+
+`replica` in the pool key is a boolean indicating if the database is a replica/reader (true) or writer database (false).
+
+Below, `test_pool_1` and `test_pool_2` have identical host, username, socket, and replica status but the port information differs.
+Here the database configurations are formatted as a table to give a visual example:
+
+|          |  test_pool_1   |  test_pool_2   |
+|----------|----------------|----------------|
+| host     | 127.0.0.1      | 127.0.0.1      |
+| port     |                | 3306           |
+| socket   |                |                |
+| username | root           | root           |
+| replica  | false          | false          |
+
+The configuration items must be explicitly defined or they will be blank in the pool key.
+Configurations with matching _implicit_ items but differing _explicit_ items will create separate pools.
+e.g. `test_pool_1` will default to port 3306 but because it is not explicitly defined it will not share a pool with `test_pool_2`
+
+ARHP will therefore create the following pool keys:
+
+```
+test_pool_1 => 127.0.0.1///root/false
+test_pool_2 => 127.0.0.1/3306//root/false
+```
+
+
 ## Support
 
 For now, the only backend known to work is MySQL, with the mysql2 gem.

data/lib/active_record_host_pool/clear_query_cache_patch.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+if ActiveRecord.version >= Gem::Version.new('6.0')
+  module ActiveRecordHostPool
+    # ActiveRecord 6.0 introduced multiple database support. With that, an update
+    # has been made in https://github.com/rails/rails/pull/35089 to ensure that
+    # all query caches are cleared across connection handlers and pools. If you
+    # write on one connection, the other connection will have the update that
+    # occurred.
+    #
+    # This broke ARHP which implements its own pool, allowing you to access
+    # multiple databases with the same connection (e.g. 1 connection for 100
+    # shards on the same server).
+    #
+    # This patch maintains the reference to the database during the cache clearing
+    # to ensure that the database doesn't get swapped out mid-way into an
+    # operation.
+    #
+    # This is a private Rails API and may change in future releases as they're
+    # actively working on sharding in Rails 6 and above.
+    module ClearQueryCachePatch
+      def clear_query_caches_for_current_thread
+        host_pool_current_database_was = connection.unproxied._host_pool_current_database
+        super
+      ensure
+        # restore in case clearing the cache changed the database
+        connection.unproxied._host_pool_current_database = host_pool_current_database_was
+      end
+
+      def clear_on_handler(handler)
+        handler.all_connection_pools.each do |pool|
+          db_was = pool.connection.unproxied._host_pool_current_database
+          pool.connection.clear_query_cache if pool.active_connection?
+        ensure
+          pool.connection.unproxied._host_pool_current_database = db_was
+        end
+      end
+    end
+  end
+
+  ActiveRecord::Base.singleton_class.prepend ActiveRecordHostPool::ClearQueryCachePatch
+end

data/lib/active_record_host_pool/connection_adapter_mixin.rb

@@ -10,7 +10,7 @@ module ActiveRecordHostPool
 
         def _host_pool_current_database=(database)
           @_host_pool_current_database = database
-          @config[:database] = _host_pool_current_database if ActiveRecord::VERSION::MAJOR >= 5
+          @config[:database] = _host_pool_current_database
         end
 
         alias_method :execute_without_switching, :execute
@@ -83,13 +83,24 @@ module ActiveRecordHostPool
       super(_host_pool_current_database.to_s + "/" + sql, *args)
     end
   end
+
+  module PoolConfigPatch
+    def pool
+      ActiveSupport::ForkTracker.check!
+
+      @pool || synchronize { @pool ||= ActiveRecordHostPool::PoolProxy.new(self) }
+    end
+  end
 end
 
-# rubocop:disable Lint/DuplicateMethods
 module ActiveRecord
   module ConnectionAdapters
     class ConnectionHandler
       case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
+      when '6.1'
+
+        :noop
+
       when '5.1', '5.2', '6.0'
 
         def establish_connection(spec)
@@ -99,15 +110,6 @@ module ActiveRecord
           owner_to_pool[spec.name] = ActiveRecordHostPool::PoolProxy.new(spec)
         end
 
-      when '4.2'
-
-        def establish_connection(owner, spec)
-          @class_to_pool.clear
-          raise "Anonymous class is not allowed." unless owner.name
-
-          owner_to_pool[owner.name] = ActiveRecordHostPool::PoolProxy.new(spec)
-        end
-
       else
 
         raise "Unsupported version of Rails (v#{ActiveRecord::VERSION::STRING})"
@@ -115,6 +117,11 @@ module ActiveRecord
     end
   end
 end
-# rubocop:enable Lint/DuplicateMethods
 
 ActiveRecord::ConnectionAdapters::Mysql2Adapter.include(ActiveRecordHostPool::DatabaseSwitch)
+
+# In Rails 6.1 Connection Pools are no longer instantiated in #establish_connection but in a
+# new pool method.
+if "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}" == '6.1'
+  ActiveRecord::ConnectionAdapters::PoolConfig.prepend(ActiveRecordHostPool::PoolConfigPatch)
+end

data/lib/active_record_host_pool/pool_proxy.rb

@@ -1,158 +1,7 @@
 # frozen_string_literal: true
 
-require 'delegate'
-require 'active_record'
-require 'active_record_host_pool/connection_adapter_mixin'
-
-# this module sits in between ConnectionHandler and a bunch of different ConnectionPools (one per host).
-# when a connection is requested, it goes like:
-# ActiveRecordClass -> ConnectionHandler#connection
-# ConnectionHandler#connection -> (find or create PoolProxy)
-# PoolProxy -> shared list of Pools
-# Pool actually gives back a connection, then PoolProxy turns this
-# into a ConnectionProxy that can inform (on execute) which db we should be on.
-
-module ActiveRecordHostPool
-  class PoolProxy < Delegator
-    def initialize(spec)
-      super(spec)
-      @spec = spec
-      @config = spec.config
-    end
-
-    def __getobj__
-      _connection_pool
-    end
-
-    def __setobj__(spec)
-      @spec = spec
-      @config = spec.config
-      @_pool_key = nil
-    end
-
-    def spec
-      @spec
-    end
-
-    def connection(*args)
-      real_connection = _connection_pool.connection(*args)
-      _connection_proxy_for(real_connection, @config[:database])
-    rescue Exception => e
-      if rescuable_errors.any? { |r| e.is_a?(r) }
-        _connection_pools.delete(_pool_key)
-      end
-      Kernel.raise(e)
-    end
-
-    # by the time we are patched into ActiveRecord, the current thread has already established
-    # a connection.  thus we need to patch both connection and checkout/checkin
-    def checkout(*args, &block)
-      cx = _connection_pool.checkout(*args, &block)
-      _connection_proxy_for(cx, @config[:database])
-    end
-
-    def checkin(cx)
-      cx = cx.unproxied
-      _connection_pool.checkin(cx)
-    end
-
-    def with_connection
-      cx = checkout
-      yield cx
-    ensure
-      checkin cx
-    end
-
-    def disconnect!
-      p = _connection_pool(false)
-      return unless p
-
-      p.disconnect!
-      p.automatic_reconnect = true if p.respond_to?(:automatic_reconnect=)
-      _clear_connection_proxy_cache
-    end
-
-    def automatic_reconnect=(value)
-      p = _connection_pool(false)
-      return unless p
-
-      p.automatic_reconnect = value if p.respond_to?(:automatic_reconnect=)
-    end
-
-    def clear_reloadable_connections!
-      _connection_pool.clear_reloadable_connections!
-      _clear_connection_proxy_cache
-    end
-
-    def release_connection(*args)
-      p = _connection_pool(false)
-      return unless p
-
-      p.release_connection(*args)
-    end
-
-    def flush!
-      p = _connection_pool(false)
-      return unless p
-
-      p.flush!
-    end
-
-    def discard!
-      p = _connection_pool(false)
-      return unless p
-
-      p.discard!
-
-      # All connections in the pool (even if they're currently
-      # leased!) have just been discarded, along with the pool itself.
-      # Any further interaction with the pool (except #spec and #schema_cache)
-      # is undefined.
-      # Remove the connection for the given key so a new one can be created in its place
-      _connection_pools.delete(_pool_key)
-    end
-
-    private
-
-    def rescuable_errors
-      @rescuable_errors ||= begin
-        e = [Mysql2::Error]
-        if ActiveRecord.const_defined?("NoDatabaseError")
-          e << ActiveRecord::NoDatabaseError
-        end
-        e
-      end
-    end
-
-    def _connection_pools
-      @@_connection_pools ||= {}
-    end
-
-    def _pool_key
-      @_pool_key ||= "#{@config[:host]}/#{@config[:port]}/#{@config[:socket]}/#{@config[:username]}/#{@config[:slave] && 'slave'}"
-    end
-
-    def _connection_pool(auto_create = true)
-      pool = _connection_pools[_pool_key]
-      if pool.nil? && auto_create
-        pool = _connection_pools[_pool_key] = ActiveRecord::ConnectionAdapters::ConnectionPool.new(@spec)
-      end
-      pool
-    end
-
-    def _connection_proxy_for(connection, database)
-      @connection_proxy_cache ||= {}
-      key = [connection, database]
-
-      @connection_proxy_cache[key] ||= begin
-        cx = ActiveRecordHostPool::ConnectionProxy.new(connection, database)
-        cx.execute('select 1')
-        cx
-      end
-    end
-
-    def _clear_connection_proxy_cache
-      @connection_proxy_cache = {}
-    end
-  end
+if "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}" == '6.1'
+  require 'active_record_host_pool/pool_proxy_6_1'
+else
+  require 'active_record_host_pool/pool_proxy_legacy'
 end

data/lib/active_record_host_pool/pool_proxy_6_1.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'delegate'
+require 'active_record'
+require 'active_record_host_pool/connection_adapter_mixin'
+
+# this module sits in between ConnectionHandler and a bunch of different ConnectionPools (one per host).
+# when a connection is requested, it goes like:
+# ActiveRecordClass -> ConnectionHandler#connection
+# ConnectionHandler#connection -> (find or create PoolProxy)
+# PoolProxy -> shared list of Pools
+# Pool actually gives back a connection, then PoolProxy turns this
+# into a ConnectionProxy that can inform (on execute) which db we should be on.
+
+module ActiveRecordHostPool
+  # Sits between ConnectionHandler and a bunch of different ConnectionPools (one per host).
+  class PoolProxy < Delegator
+    def initialize(pool_config)
+      super(pool_config)
+      @pool_config = pool_config
+      @config = pool_config.db_config.configuration_hash
+    end
+
+    def __getobj__
+      _connection_pool
+    end
+
+    def __setobj__(pool_config)
+      @pool_config = pool_config
+      @config = pool_config.db_config.configuration_hash
+      @_pool_key = nil
+    end
+
+    attr_reader :pool_config
+
+    def connection(*args)
+      real_connection = _connection_pool.connection(*args)
+      _connection_proxy_for(real_connection, @config[:database])
+    rescue Mysql2::Error, ActiveRecord::NoDatabaseError
+      _connection_pools.delete(_pool_key)
+      Kernel.raise
+    end
+
+    # by the time we are patched into ActiveRecord, the current thread has already established
+    # a connection.  thus we need to patch both connection and checkout/checkin
+    def checkout(*args, &block)
+      cx = _connection_pool.checkout(*args, &block)
+      _connection_proxy_for(cx, @config[:database])
+    end
+
+    def checkin(cx)
+      cx = cx.unproxied
+      _connection_pool.checkin(cx)
+    end
+
+    def with_connection
+      cx = checkout
+      yield cx
+    ensure
+      checkin cx
+    end
+
+    def disconnect!
+      p = _connection_pool(false)
+      return unless p
+
+      p.disconnect!
+      p.automatic_reconnect = true if p.respond_to?(:automatic_reconnect=)
+      _clear_connection_proxy_cache
+    end
+
+    def automatic_reconnect=(value)
+      p = _connection_pool(false)
+      return unless p
+
+      p.automatic_reconnect = value if p.respond_to?(:automatic_reconnect=)
+    end
+
+    def clear_reloadable_connections!
+      _connection_pool.clear_reloadable_connections!
+      _clear_connection_proxy_cache
+    end
+
+    def release_connection(*args)
+      p = _connection_pool(false)
+      return unless p
+
+      p.release_connection(*args)
+    end
+
+    def flush!
+      p = _connection_pool(false)
+      return unless p
+
+      p.flush!
+    end
+
+    def discard!
+      p = _connection_pool(false)
+      return unless p
+
+      p.discard!
+
+      # All connections in the pool (even if they're currently
+      # leased!) have just been discarded, along with the pool itself.
+      # Any further interaction with the pool (except #pool_config and #schema_cache)
+      # is undefined.
+      # Remove the connection for the given key so a new one can be created in its place
+      _connection_pools.delete(_pool_key)
+    end
+
+    private
+
+    def _connection_pools
+      @@_connection_pools ||= {}
+    end
+
+    def _pool_key
+      @_pool_key ||= "#{@config[:host]}/#{@config[:port]}/#{@config[:socket]}/" \
+                     "#{@config[:username]}/#{replica_configuration? && 'replica'}"
+    end
+
+    def _connection_pool(auto_create = true)
+      pool = _connection_pools[_pool_key]
+      if pool.nil? && auto_create
+        pool = _connection_pools[_pool_key] = ActiveRecord::ConnectionAdapters::ConnectionPool.new(@pool_config)
+      end
+      pool
+    end
+
+    def _connection_proxy_for(connection, database)
+      @connection_proxy_cache ||= {}
+      key = [connection, database]
+
+      @connection_proxy_cache[key] ||= begin
+        cx = ActiveRecordHostPool::ConnectionProxy.new(connection, database)
+        cx.execute('select 1')
+        cx
+      end
+    end
+
+    def _clear_connection_proxy_cache
+      @connection_proxy_cache = {}
+    end
+
+    def replica_configuration?
+      @config[:replica] || @config[:slave]
+    end
+  end
+end

data/lib/active_record_host_pool/pool_proxy_legacy.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+# For versions of Rails < 6.1
+
+require 'delegate'
+require 'active_record'
+require 'active_record_host_pool/connection_adapter_mixin'
+
+# this module sits in between ConnectionHandler and a bunch of different ConnectionPools (one per host).
+# when a connection is requested, it goes like:
+# ActiveRecordClass -> ConnectionHandler#connection
+# ConnectionHandler#connection -> (find or create PoolProxy)
+# PoolProxy -> shared list of Pools
+# Pool actually gives back a connection, then PoolProxy turns this
+# into a ConnectionProxy that can inform (on execute) which db we should be on.
+
+module ActiveRecordHostPool
+  # Sits between ConnectionHandler and a bunch of different ConnectionPools (one per host).
+  class PoolProxy < Delegator
+    def initialize(spec)
+      super(spec)
+      @spec = spec
+      @config = spec.config
+    end
+
+    def __getobj__
+      _connection_pool
+    end
+
+    def __setobj__(spec)
+      @spec = spec
+      @config = spec.config
+      @_pool_key = nil
+    end
+
+    attr_reader :spec
+
+    def connection(*args)
+      real_connection = _connection_pool.connection(*args)
+      _connection_proxy_for(real_connection, @config[:database])
+    rescue Mysql2::Error, ActiveRecord::NoDatabaseError
+      _connection_pools.delete(_pool_key)
+      Kernel.raise
+    end
+
+    # by the time we are patched into ActiveRecord, the current thread has already established
+    # a connection.  thus we need to patch both connection and checkout/checkin
+    def checkout(*args, &block)
+      cx = _connection_pool.checkout(*args, &block)
+      _connection_proxy_for(cx, @config[:database])
+    end
+
+    def checkin(cx)
+      cx = cx.unproxied
+      _connection_pool.checkin(cx)
+    end
+
+    def with_connection
+      cx = checkout
+      yield cx
+    ensure
+      checkin cx
+    end
+
+    def disconnect!
+      p = _connection_pool(false)
+      return unless p
+
+      p.disconnect!
+      p.automatic_reconnect = true if p.respond_to?(:automatic_reconnect=)
+      _clear_connection_proxy_cache
+    end
+
+    def automatic_reconnect=(value)
+      p = _connection_pool(false)
+      return unless p
+
+      p.automatic_reconnect = value if p.respond_to?(:automatic_reconnect=)
+    end
+
+    def clear_reloadable_connections!
+      _connection_pool.clear_reloadable_connections!
+      _clear_connection_proxy_cache
+    end
+
+    def release_connection(*args)
+      p = _connection_pool(false)
+      return unless p
+
+      p.release_connection(*args)
+    end
+
+    def flush!
+      p = _connection_pool(false)
+      return unless p
+
+      p.flush!
+    end
+
+    def discard!
+      p = _connection_pool(false)
+      return unless p
+
+      p.discard!
+
+      # All connections in the pool (even if they're currently
+      # leased!) have just been discarded, along with the pool itself.
+      # Any further interaction with the pool (except #spec and #schema_cache)
+      # is undefined.
+      # Remove the connection for the given key so a new one can be created in its place
+      _connection_pools.delete(_pool_key)
+    end
+
+    private
+
+    def _connection_pools
+      @@_connection_pools ||= {}
+    end
+
+    def _pool_key
+      @_pool_key ||= "#{@config[:host]}/#{@config[:port]}/#{@config[:socket]}/" \
+                     "#{@config[:username]}/#{replica_configuration? && 'replica'}"
+    end
+
+    def _connection_pool(auto_create = true)
+      pool = _connection_pools[_pool_key]
+      if pool.nil? && auto_create
+        pool = _connection_pools[_pool_key] = ActiveRecord::ConnectionAdapters::ConnectionPool.new(@spec)
+      end
+      pool
+    end
+
+    def _connection_proxy_for(connection, database)
+      @connection_proxy_cache ||= {}
+      key = [connection, database]
+
+      @connection_proxy_cache[key] ||= begin
+        cx = ActiveRecordHostPool::ConnectionProxy.new(connection, database)
+        cx.execute('select 1')
+        cx
+      end
+    end
+
+    def _clear_connection_proxy_cache
+      @connection_proxy_cache = {}
+    end
+
+    def replica_configuration?
+      @config[:replica] || @config[:slave]
+    end
+  end
+end

data/lib/active_record_host_pool/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordHostPool
-  VERSION = "1.0.2"
+  VERSION = "1.1.1"
 end