active_record_host_pool 1.2.5 → 2.0.0

data/lib/active_record_host_pool/pool_proxy_6_1.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-require 'delegate'
-require 'active_record'
-require 'active_record_host_pool/connection_adapter_mixin'
-require 'mutex_m'
-
-# 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
-    include Mutex_m
-
-    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 = _unproxied_connection(*args)
-      _connection_proxy_for(real_connection, @config[:database])
-    rescue Mysql2::Error, ActiveRecord::NoDatabaseError
-      _connection_pools.delete(_pool_key)
-      Kernel.raise
-    end
-
-    def _unproxied_connection(*args)
-      _connection_pool.connection(*args)
-    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
-
-      synchronize do
-        p.disconnect!
-        p.automatic_reconnect = true
-        _clear_connection_proxy_cache
-      end
-    end
-
-    def automatic_reconnect=(value)
-      p = _connection_pool(false)
-      return unless p
-
-      p.automatic_reconnect = value
-    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

@@ -1,156 +0,0 @@
-# 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 = _unproxied_connection(*args)
-      _connection_proxy_for(real_connection, @config[:database])
-    rescue Mysql2::Error, ActiveRecord::NoDatabaseError
-      _connection_pools.delete(_pool_key)
-      Kernel.raise
-    end
-
-    def _unproxied_connection(*args)
-      _connection_pool.connection(*args)
-    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
-      _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/test/database.yml

@@ -1,108 +0,0 @@
-<% mysql = URI(ENV['MYSQL_URL'] || 'mysql://root@127.0.0.1:3306') %>
-# 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.
-#
-# Below, "test_pool_1..." and "test_pool_2..." have identical host, username, socket, and replica status but the port information differs.
-# Here the yml configurations are reformatted 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          |
-# |----------+----------------+----------------|
-#
-# Note: The configuration items must be explicitly defined or 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
-
-test_pool_1_db_a:
-  adapter: mysql2
-  encoding: utf8
-  database: arhp_test_db_a
-  username: <%= mysql.user %>
-  password: <%= mysql.password %>
-  host: <%= mysql.host %>
-  reconnect: true
-
-# Mimic configurations as read by active_record_shards/ar_flexmaster
-test_pool_1_db_a_replica:
-  adapter: mysql2
-  encoding: utf8
-  database: arhp_test_db_a_replica
-  username: <%= mysql.user %>
-  password: <%= mysql.password %>
-  host: <%= mysql.host %>
-  reconnect: true
-  slave: true
-
-test_pool_1_db_b:
-  adapter: mysql2
-  encoding: utf8
-  database: arhp_test_db_b
-  username: <%= mysql.user %>
-  password: <%= mysql.password %>
-  host: <%= mysql.host %>
-  reconnect: true
-
-test_pool_1_db_not_there:
-  adapter: mysql2
-  encoding: utf8
-  database: arhp_test_db_not_there
-  username: <%= mysql.user %>
-  password: <%= mysql.password %>
-  host: <%= mysql.host %>
-  reconnect: true
-
-test_pool_2_db_d:
-  adapter: mysql2
-  encoding: utf8
-  database: arhp_test_db_d
-  username: <%= mysql.user %>
-  password: <%= mysql.password %>
-  host: <%= mysql.host %>
-  port: <%= mysql.port %>
-  reconnect: true
-
-test_pool_2_db_e:
-  adapter: mysql2
-  encoding: utf8
-  database: arhp_test_db_e
-  username: <%= mysql.user %>
-  password: <%= mysql.password %>
-  host: <%= mysql.host %>
-  port: <%= mysql.port %>
-  reconnect: true
-
-test_pool_3_db_e:
-  adapter: mysql2
-  encoding: utf8
-  database: arhp_test_db_e
-  username: john-doe
-  password:
-  host: <%= mysql.host %>
-  port: <%= mysql.port %>
-  reconnect: true
-
-# test_pool_1_db_c needs to be the last database defined in the file
-# otherwise the test_models_with_matching_hosts_and_non_matching_databases_issue_exists_without_arhp_patch
-# test fails
-test_pool_1_db_c:
-  adapter: mysql2
-  encoding: utf8
-  database: arhp_test_db_c
-  username: <%= mysql.user %>
-  password: <%= mysql.password %>
-  host: <%= mysql.host %>
-  reconnect: true

data/test/helper.rb

@@ -1,198 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'minitest/autorun'
-require 'pry-byebug'
-
-require 'active_record_host_pool'
-require 'logger'
-require 'minitest/mock_expectations'
-require 'phenix'
-
-ENV['RAILS_ENV'] = 'test'
-ENV['LEGACY_CONNECTION_HANDLING'] = 'true' if ENV['LEGACY_CONNECTION_HANDLING'].nil?
-
-if ActiveRecord.version >= Gem::Version.new('6.1')
-  ActiveRecord::Base.legacy_connection_handling = (ENV['LEGACY_CONNECTION_HANDLING'] == 'true')
-end
-
-RAILS_6_1_WITH_NON_LEGACY_CONNECTION_HANDLING =
-  ActiveRecord.version >= Gem::Version.new('6.1') && !ActiveRecord::Base.legacy_connection_handling
-
-ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + '/test.log')
-
-Thread.abort_on_exception = true
-
-# BEGIN preventing_writes? patch
-## Rails 6.1 by default does not allow writing to replica databases which prevents
-## us from properly setting up the test databases. This patch is used in test/schema.rb
-## to allow us to write to the replicas but only during migrations
-module ActiveRecordHostPool
-  cattr_accessor :allowing_writes
-  module PreventWritesPatch
-    def preventing_writes?
-      return false if ActiveRecordHostPool.allowing_writes && replica?
-
-      super
-    end
-  end
-end
-
-if ActiveRecord.version >= Gem::Version.new('6.1')
-  ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend ActiveRecordHostPool::PreventWritesPatch
-end
-# END preventing_writes? patch
-
-Phenix.configure do |config|
-  config.skip_database = ->(name, conf) { name =~ /not_there/ || conf['username'] == 'john-doe' }
-end
-
-module ARHPTestSetup
-  private
-
-  def arhp_create_models
-    return if ARHPTestSetup.const_defined?('Pool1DbA')
-
-    if RAILS_6_1_WITH_NON_LEGACY_CONNECTION_HANDLING
-      eval <<-RUBY
-        class AbstractPool1DbC < ActiveRecord::Base
-          self.abstract_class = true
-          connects_to database: { writing: :test_pool_1_db_c }
-        end
-
-        # The placement of the Pool1DbC class is important so that its
-        # connection will not be the most recent connection established
-        # for test_pool_1.
-        class Pool1DbC < AbstractPool1DbC
-        end
-
-        class AbstractPool1DbA < ActiveRecord::Base
-          self.abstract_class = true
-          connects_to database: { writing: :test_pool_1_db_a, reading: :test_pool_1_db_a_replica }
-        end
-
-        class Pool1DbA < AbstractPool1DbA
-          self.table_name = "tests"
-        end
-
-        class AbstractPool1DbB < ActiveRecord::Base
-          self.abstract_class = true
-          connects_to database: { writing: :test_pool_1_db_b }
-        end
-
-        class Pool1DbB < AbstractPool1DbB
-          self.table_name = "tests"
-        end
-
-        class AbstractPool2DbD < ActiveRecord::Base
-          self.abstract_class = true
-          connects_to database: { writing: :test_pool_2_db_d }
-        end
-
-        class Pool2DbD < AbstractPool2DbD
-          self.table_name = "tests"
-        end
-
-        class AbstractPool2DbE < ActiveRecord::Base
-          self.abstract_class = true
-          connects_to database: { writing: :test_pool_2_db_e }
-        end
-
-        class Pool2DbE < AbstractPool2DbE
-          self.table_name = "tests"
-        end
-
-        class AbstractPool3DbE < ActiveRecord::Base
-          self.abstract_class = true
-          connects_to database: { writing: :test_pool_3_db_e }
-        end
-
-        class Pool3DbE < AbstractPool3DbE
-          self.table_name = "tests"
-        end
-
-        # Test ARHP with Rails 6.1+ horizontal sharding functionality
-        class AbstractShardedModel < ActiveRecord::Base
-          self.abstract_class = true
-          connects_to shards: {
-                        default: { writing: :test_pool_1_db_shard_a },
-                        shard_b: { writing: :test_pool_1_db_shard_b, reading: :test_pool_1_db_shard_b_replica },
-                        shard_c: { writing: :test_pool_1_db_shard_c, reading: :test_pool_1_db_shard_c_replica },
-                        shard_d: { writing: :test_pool_2_db_shard_d, reading: :test_pool_2_db_shard_d_replica }
-                      }
-        end
-
-        class ShardedModel < AbstractShardedModel
-          self.table_name = "tests"
-        end
-      RUBY
-    else
-      eval <<-RUBY
-        # The placement of the Pool1DbC class is important so that its
-        # connection will not be the most recent connection established
-        # for test_pool_1.
-        class Pool1DbC < ActiveRecord::Base
-          establish_connection(:test_pool_1_db_c)
-        end
-
-        class Pool1DbA < ActiveRecord::Base
-          self.table_name = "tests"
-          establish_connection(:test_pool_1_db_a)
-        end
-
-        class Pool1DbAReplica < ActiveRecord::Base
-          self.table_name = "tests"
-          establish_connection(:test_pool_1_db_a_replica)
-        end
-
-        class Pool1DbB < ActiveRecord::Base
-          self.table_name =  "tests"
-          establish_connection(:test_pool_1_db_b)
-        end
-
-        class Pool2DbD < ActiveRecord::Base
-          self.table_name = "tests"
-          establish_connection(:test_pool_2_db_d)
-        end
-
-        class Pool2DbE < ActiveRecord::Base
-          self.table_name = "tests"
-          establish_connection(:test_pool_2_db_e)
-        end
-
-        class Pool3DbE < ActiveRecord::Base
-          self.table_name = "tests"
-          establish_connection(:test_pool_3_db_e)
-        end
-      RUBY
-    end
-  end
-
-  def current_database(klass)
-    klass.connection.select_value('select DATABASE()')
-  end
-
-  # Remove a method from a given module that fixes something.
-  # Execute the passed in block.
-  # Re-add the method back to the module.
-  def without_module_patch(mod, method_name)
-    method_body = mod.instance_method(method_name)
-    mod.remove_method(method_name)
-    yield if block_given?
-  ensure
-    mod.define_method(method_name, method_body)
-  end
-
-  def simulate_rails_app_active_record_railties
-    if ActiveRecord.version >= Gem::Version.new('6.0') && !RAILS_6_1_WITH_NON_LEGACY_CONNECTION_HANDLING
-      # Necessary for testing ActiveRecord 6.0 which uses the connection
-      # handlers when clearing query caches across all handlers when
-      # an operation that dirties the cache is involved (e.g. create/insert,
-      # update, delete/destroy, truncate, etc.)
-      # In Rails 6.1 this is only present when legacy_connection_handling=true
-      ActiveRecord::Base.connection_handlers = {
-        ActiveRecord::Base.writing_role => ActiveRecord::Base.default_connection_handler
-      }
-    end
-  end
-end

data/test/schema.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-begin
-  ActiveRecordHostPool.allowing_writes = true
-
-  ActiveRecord::Schema.define(version: 1) do
-    create_table 'tests', force: true do |t|
-      t.string   'val'
-    end
-
-    # Add a table only the shard database will have. Conditional
-    # exists since Phenix loads the schema file for every database.
-    if ActiveRecord::Base.connection.current_database == 'arhp_test_db_c'
-      create_table 'pool1_db_cs' do |t|
-        t.string 'name'
-      end
-    end
-  end
-ensure
-  ActiveRecordHostPool.allowing_writes = false
-end