active_replicas 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 173a69eb3b3d994aceb621ee0ab906ce00ffa351
-  data.tar.gz: 7a4b43fae106392d6ae07e572bcb4ab99bd7b0bb
+  metadata.gz: e56f8bd047e2f96b83a8246b4cdbcd428dd4e095
+  data.tar.gz: e02a7e2680c7bc60aa47c2cd75a25ca704f3a5c5
 SHA512:
-  metadata.gz: 4fa4f73e1a7edfcab0650b91627672de911677e90d516df5d095fdb7edb374fc896325557659b3b065398b8f9590a02f67e1d5b5986f19ddf884215c9cd5cf9f
-  data.tar.gz: 2e3592d77e410716166849b648a9295ac22430911a2363f81c658c032982009ae6662b6ffc6031a050821181810f4ae4270607473f9fafc7762f3e419b758036
+  metadata.gz: f430544ad26fd4f894addafb5961ea1cfc5aabf99fc565a206556bf70d302efe7afc4b4ae4447345c95c4ec1793d95d109400aa1995b7e72bfe4c1c644d2276e
+  data.tar.gz: 755fc9c0a43f3860d4c8f2f5b7ef984740f401a51b10dc50c29f0da1bf964648df7d813457272529ab9da73177ce4e2a94db7e64b9e03d622fa305b0e8c57f66

data/gemfiles/rails_4.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    active_replicas (0.3.2)
+    active_replicas (0.4.0)
       concurrent-ruby (~> 1.0)
 
 GEM

data/lib/active_replicas/proxying_connection_pool.rb

@@ -1,5 +1,6 @@
-require 'monitor'
+require 'active_support/core_ext/module/delegation'
 require 'active_support/hash_with_indifferent_access'
+require 'monitor'
 
 module ActiveReplicas
   # Manages connection pools to the primary and replica databases. Returns
@@ -7,35 +8,23 @@ module ActiveReplicas
   #
   # Also hanldes the internal state of switching back and forth from replica
   # to primary connections based on heuristics or overrides.
+  #
+  # NOTE: This proxy instance should be provisioned per-thread and it is *not*
+  #   thread-safe!
   class ProxyingConnectionPool
-    attr_reader :primary_pool, :replica_pools
+    attr_reader :handler
 
-    def initialize(proxy_configuration)
-      @primary_pool = ProxyingConnectionPool.connection_pool_for_spec proxy_configuration[:primary]
-
-      @replica_pools = (proxy_configuration[:replicas] || {}).map do |name, config_spec|
-        [ name, ProxyingConnectionPool.connection_pool_for_spec(config_spec) ]
-      end.to_h
+    # handler - `ProcessLocalConnectionHandler` which created this pool.
+    def initialize(handler)
+      @handler = handler
 
       # Calls to `with_primary` will increment and decrement this.
       @primary_depth = 0
       # Current connection pool.
       @current_pool = nil
-
-      extend MonitorMixin
     end
 
-    # Returns an instance of `ActiveRecord::ConnectionAdapters::ConnectionPool`
-    # configured with the given specification.
-    def self.connection_pool_for_spec(config_spec)
-      @@resolver ||= ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new({})
-
-      # Turns a hash configuration into a `ConnectionSpecification` that can
-      # be passed to a `ConnectionPool`.
-      spec = @@resolver.spec ActiveSupport::HashWithIndifferentAccess.new(config_spec)
-
-      ActiveRecord::ConnectionAdapters::ConnectionPool.new spec
-    end
+    delegate :primary_pool, :replica_pools, to: :handler
 
     # ConnectionPool interface methods
     # ================================
@@ -47,23 +36,19 @@ module ActiveReplicas
       return unless conn
 
       ProxyingConnection.new connection: conn,
-                             is_primary: pool == @primary_pool,
+                             is_primary: pool == primary_pool,
                              proxy:      self
     end
 
     def active_connection?
-      synchronize do
-        all_pools.any? { |pool| pool.active_connection? }
-      end
+      all_pools.any?(&:active_connection?)
     end
 
     def release_connection
-      synchronize do
-        each_pool &:release_connection
+      all_pools.each(&:release_connection)
 
-        @primary_depth = 0
-        @current_pool = nil
-      end
+      @primary_depth = 0
+      @current_pool = nil
     end
 
     def with_connection(&block)
@@ -71,21 +56,15 @@ module ActiveReplicas
     end
 
     def connected?
-      synchronize do
-        current_pool.connected?
-      end
+      current_pool.connected?
     end
 
     def disconnect!
-      synchronize do
-        each_pool &:disconnect!
-      end
+      all_pools.each(&:disconnect!)
     end
 
     def clear_reloadable_connections!
-      synchronize do
-        each_pool &:clear_reloadable_connections!
-      end
+      all_pools.each(&:clear_reloadable_connections!)
     end
 
     def current_pool
@@ -100,17 +79,17 @@ module ActiveReplicas
     # ==============================================
 
     def automatic_reconnect=(new_value)
-      each_pool do |pool|
+      all_pools.each do |pool|
         pool.automatic_reconnect = new_value
       end
     end
 
     def connections
-      @primary_pool.connections
+      primary_pool.connections
     end
 
     def spec
-      @primary_pool.spec
+      primary_pool.spec
     end
 
     # Additional methods
@@ -120,7 +99,7 @@ module ActiveReplicas
       previous_pool = @current_pool
 
       @primary_depth += 1
-      @current_pool = @primary_pool
+      @current_pool = primary_pool
 
       yield connection
     ensure
@@ -136,31 +115,27 @@ module ActiveReplicas
     #
     # NOTE: If this is not already in a `with_primary` block then calling this
     #   will irreversably place the proxying pool in the primary state until
-    #   `clear_active_connections!` is called! If you want to *temporarily*
+    #   `release_connection!` is called! If you want to *temporarily*
     #   use the primary then explicitly do so using `with_primary`.
     def primary_connection
       if @primary_depth == 0
         @primary_depth += 1
-        @current_pool = @primary_pool
+        @current_pool = primary_pool
       end
 
       connection
     end
 
-    # Returns an `Enumerable` over all the pools, primary and replicas, owned
+    # Returns an `Enumerable` over all the pools, primary and replicas, used
     # by this proxying pool.
     def all_pools
-      [ @primary_pool ] + @replica_pools.values
-    end
-
-    def each_pool(&block)
-      all_pools.each &block
+      [primary_pool] + replica_pools.values
     end
 
     def pool_which_owns_connection(object_id)
-      return @primary_pool if @primary_pool.connections.any? { |c| c.object_id == object_id }
+      return primary_pool if primary_pool.connections.any? { |c| c.object_id == object_id }
 
-      @replica_pools.values.each do |pool|
+      replica_pools.values.each do |pool|
         return pool if pool.connections.any? { |c| c.object_id == object_id }
       end
 
@@ -168,20 +143,20 @@ module ActiveReplicas
     end
 
     def primary_pool?(pool)
-      pool == @primary_pool
+      pool == primary_pool
     end
 
     def replica_pool?(pool)
-      @replica_pools.values.include? pool
+      replica_pools.values.include? pool
     end
 
     private
 
     def next_pool
-      replicas = @replica_pools.values
+      replicas = replica_pools.values
 
       if replicas.empty?
-        @primary_pool
+        primary_pool
       else
         replicas.sample
       end

data/lib/active_replicas/rails4/connection_handler.rb

@@ -1,9 +1,15 @@
+require 'active_support/core_ext/module/delegation'
 require 'concurrent/map'
 
+require 'active_replicas/rails4/process_local_connection_handler'
+
 module ActiveReplicas
   module Rails4
     # Wraps around Rails' `ActiveRecord::ConnectionAdapters::ConnectionHandler`
     # to provide proxy wrappers around requested connections.
+    #
+    # This is the process-safe handler; it creates instances of
+    # `ThreadLocalConnectionHandler` to provide proxy wrappers for each thread.
     class ConnectionHandler
       attr_accessor :proxy_configuration
 
@@ -12,72 +18,28 @@ module ActiveReplicas
         # @delegate          = delegate
         # @overrides         = Set.new(overrides || [])
 
-        # Each process will get its own map of connection keys to database
-        # connection instances.
-        @process_to_connection_pool = Concurrent::Map.new
-      end
-
-      def connection_pool_list
-        [ @process_to_connection_pool[Process.pid] ].compact
-      end
-
-      def establish_connection(owner, spec)
-        prefix = '[ActiveReplicas::Rails4::ConnectionHandler#establish_connection]'
-        ActiveRecord::Base.logger&.warn "#{prefix} Ignoring spec for #{owner.inspect}: #{spec.inspect}"
-        ActiveRecord::Base.logger&.info "#{prefix} Called from:\n" + Kernel.caller.first(5).map {|t| "  #{t}" }.join("\n")
-
-        proxying_connection_pool
+        # Each process will get its own thread-safe handler.
+        @process_to_handler = Concurrent::Map.new
       end
 
-      def active_connections?
-        proxying_connection_pool.active_connection?
-      end
-
-      def clear_active_connections!
-        proxying_connection_pool.release_connection
-      end
-
-      def clear_reloadable_connections!
-        proxying_connection_pool.clear_reloadable_connections!
-      end
+      delegate :active_connections?, :clear_active_connections!,
+          :clear_all_connections!, :clear_reloadable_connections!,
+          :connected?, :connection_pool_list, :establish_connection,
+          :remove_connection, :retrieve_connection, :retrieve_connection_pool,
+        to: :retrieve_handler
 
       def clear_all_connections!
-        proxying_connection_pool.disconnect!
-      end
-
-      # Cribbed from:
-      #   https://github.com/rails/rails/blob/4-2-stable/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb#L568
-      def retrieve_connection(klass)
-        pool = retrieve_connection_pool klass
-        raise ConnectionNotEstablished, "No connection pool for #{klass}" unless pool
-        conn = pool.connection
-        raise ConnectionNotEstablished, "No connection for #{klass} in connection pool" unless conn
-        conn
-      end
-
-      def connected?(klass)
-        pool = retrieve_connection_pool klass
-        pool && pool.connected?
-      end
-
-      def remove_connection(owner_klass)
-        remove_proxying_connection_pool
-      end
-
-      def retrieve_connection_pool(klass)
-        proxying_connection_pool
-      end
-
-      def remove_proxying_connection_pool
-        if proxying_pool = @process_to_connection_pool.delete(Process.pid)
-          proxying_pool.automatic_reconnect = false
-          proxying_pool.disconnect!
-          proxying_pool.primary_pool.spec.config
+        # We also want to clear the process's connection handler in case our
+        # configuration has been changed.
+        if handler = @process_to_handler.delete(Process.pid)
+          handler.clear_all_connections!
         end
       end
 
-      def proxying_connection_pool
-        @process_to_connection_pool[Process.pid] ||= ProxyingConnectionPool.new(@proxy_configuration)
+      # Returns a `ProcessLocalConnectionHandler` which is local to the
+      # current process.
+      def retrieve_handler
+        @process_to_handler[Process.pid] ||= ProcessLocalConnectionHandler.new(@proxy_configuration)
       end
     end
   end

data/lib/active_replicas/rails4/helpers.rb

@@ -0,0 +1,21 @@
+require 'active_record/connection_adapters/connection_specification'
+
+module ActiveReplicas
+  module Rails4
+    module Helpers
+      extend self
+
+      # Returns an instance of `ActiveRecord::ConnectionAdapters::ConnectionPool`
+      # configured with the given specification.
+      def self.connection_pool_for_spec(config_spec)
+        @@resolver ||= ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new({})
+
+        # Turns a hash configuration into a `ConnectionSpecification` that can
+        # be passed to a `ConnectionPool`.
+        spec = @@resolver.spec ActiveSupport::HashWithIndifferentAccess.new(config_spec)
+
+        ActiveRecord::ConnectionAdapters::ConnectionPool.new spec
+      end
+    end
+  end
+end

data/lib/active_replicas/rails4/process_local_connection_handler.rb

@@ -0,0 +1,119 @@
+require 'monitor'
+
+require 'active_replicas/rails4/helpers'
+
+module ActiveReplicas
+  module Rails4
+    # Provisioned for each process by `ConnectionHandler`. Each process owns
+    # its own pools of connections to primary and replica databases.
+    # Proxying connection pools are then provisioned for each thread.
+    class ProcessLocalConnectionHandler
+      attr_reader :proxy_configuration
+      attr_reader :primary_pool, :replica_pools
+
+      def initialize(proxy_configuration)
+        @proxy_configuration = proxy_configuration
+
+        @primary_pool = Helpers.connection_pool_for_spec @proxy_configuration[:primary]
+
+        @replica_pools = (@proxy_configuration[:replicas] || {}).map do |name, config_spec|
+          [name, Helpers.connection_pool_for_spec(config_spec)]
+        end.to_h
+
+        # Each thread gets its own `ProxyingConnectionPool`.
+        @reserved_proxies = Concurrent::Map.new
+
+        extend MonitorMixin
+      end
+
+      # Returns a list of *all* the connection pools owned by this handler.
+      def connection_pool_list
+        [@primary_pool] + @replica_pools.values
+      end
+
+      def establish_connection(owner, spec)
+        prefix = '[ActiveReplicas::Rails4::ConnectionHandler#establish_connection]'
+        ActiveRecord::Base.logger&.warn "#{prefix} Ignoring spec for #{owner.inspect}: #{spec.inspect}"
+        ActiveRecord::Base.logger&.info "#{prefix} Called from:\n" + Kernel.caller.first(5).map {|t| "  #{t}" }.join("\n")
+
+        current_proxy
+      end
+
+      def active_connections?
+        connection_pool_list.any?(&:active_connection?)
+      end
+
+      def clear_active_connections!
+        synchronize do
+          connection_pool_list.each(&:release_connection)
+          clear_current_proxy
+        end
+      end
+
+      def clear_reloadable_connections!
+        synchronize do
+          connection_pool_list.each(&:clear_reloadable_connections!)
+          clear_proxies!
+        end
+      end
+
+      def clear_all_connections!
+        synchronize do
+          connection_pool_list.each(&:disconnect!)
+          clear_proxies!
+        end
+      end
+
+      # Cribbed from:
+      #   https://github.com/rails/rails/blob/4-2-stable/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb#L568
+      def retrieve_connection(klass)
+        pool = retrieve_connection_pool klass
+        raise ConnectionNotEstablished, "No connection pool for #{klass}" unless pool
+        conn = pool.connection
+        raise ConnectionNotEstablished, "No connection for #{klass} in connection pool" unless conn
+        conn
+      end
+
+      def connected?(klass)
+        pool = retrieve_connection_pool klass
+        pool && pool.connected?
+      end
+
+      def remove_connection(owner_klass)
+        if proxy = clear_current_proxy
+          proxy.automatic_reconnect = false
+          proxy.disconnect!
+          proxy.spec.config
+        end
+      end
+
+      def retrieve_connection_pool(klass)
+        current_proxy
+      end
+
+      # Semi-private implementation methdos
+      # ===================================
+
+      # Returns the `ThreadLocalConnectionHandler` for this thread.
+      def current_proxy
+        @reserved_proxies[current_thread_id] || synchronize do
+          @reserved_proxies[current_thread_id] ||= ProxyingConnectionPool.new(self)
+        end
+      end
+
+      # Remove the current reserved `ProxyingConnectionPool` from the pool.
+      def clear_current_proxy
+        @reserved_proxies.delete current_thread_id
+      end
+
+      # Clear all reserved `ProxyingConnectionPool` instances from the pool.
+      def clear_proxies!
+        @reserved_proxies.clear
+      end
+
+      def current_thread_id
+        Thread.current.object_id
+      end
+    end
+  end
+end

data/lib/active_replicas/version.rb

@@ -1,3 +1,3 @@
 module ActiveReplicas
-  VERSION = '0.3.2'
+  VERSION = '0.4.0'
 end

data/lib/active_replicas.rb

@@ -7,6 +7,7 @@ if defined? ActiveRecord
   version = ActiveRecord::VERSION::MAJOR
 
   if version == 4
+    require 'active_replicas/rails4/helpers'
     require 'active_replicas/rails4/connection_handler'
   else
     raise "Unsupported ActiveRecord version: #{version}"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_replicas
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Dirk Gadsden
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-03 00:00:00.000000000 Z
+date: 2016-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -127,6 +127,8 @@ files:
 - lib/active_replicas/proxying_connection.rb
 - lib/active_replicas/proxying_connection_pool.rb
 - lib/active_replicas/rails4/connection_handler.rb
+- lib/active_replicas/rails4/helpers.rb
+- lib/active_replicas/rails4/process_local_connection_handler.rb
 - lib/active_replicas/railtie.rb
 - lib/active_replicas/version.rb
 homepage: https://github.com/dirk/active_replicas