activerecord-bogacs 0.5.0 → 0.7.0

data/lib/active_record/bogacs/false_pool.rb

@@ -1,3 +1,8 @@
+require 'active_record/version'
+
+require 'concurrent/atomic/atomic_boolean'
+
+require 'active_record/connection_adapters/adapter_compat'
 require 'active_record/bogacs/pool_support'
 require 'active_record/bogacs/thread_safe'
 
@@ -14,17 +19,17 @@ module ActiveRecord
       attr_reader :size, :spec
 
       def initialize(spec)
-        @connected = nil
+        super()
 
         @spec = spec
         @size = nil
         @automatic_reconnect = nil
+        @lock_thread = false
 
-        @reserved_connections = ThreadSafe::Map.new #:initial_capacity => @size
-      end
+        @thread_cached_conns = ThreadSafe::Map.new
 
-      # @private replacement for attr_reader :connections
-      def connections; @reserved_connections.values end
+        @connected = ::Concurrent::AtomicBoolean.new
+      end
 
       # @private attr_reader :reaper
       def reaper; end
@@ -38,20 +43,21 @@ module ActiveRecord
       # #connection can be called any number of times; the connection is
       # held in a hash keyed by the thread id.
       def connection
-        @reserved_connections[current_connection_id] ||= checkout
+        connection_id = current_connection_id(current_thread)
+        @thread_cached_conns[connection_id] ||= checkout
       end
 
       # Is there an open connection that is being used for the current thread?
       def active_connection?
-        conn = @reserved_connections[current_connection_id]
-        conn ? conn.in_use? : false
+        connection_id = current_connection_id(current_thread)
+        @thread_cached_conns[connection_id]
       end
 
       # Signal that the thread is finished with the current connection.
       # #release_connection releases the connection-thread association
       # and returns the connection to the pool.
-      def release_connection(with_id = current_connection_id)
-        conn = @reserved_connections.delete(with_id)
+      def release_connection(owner_thread = Thread.current)
+        conn = @thread_cached_conns.delete(current_connection_id(owner_thread))
         checkin conn if conn
       end
 
@@ -60,40 +66,63 @@ module ActiveRecord
       # connection when finished.
       def with_connection
         connection_id = current_connection_id
-        fresh_connection = true unless active_connection?
-        yield connection
+        unless conn = @thread_cached_conns[connection_id]
+          conn = connection
+          fresh_connection = true
+        end
+        yield conn
       ensure
-        release_connection(connection_id) if fresh_connection
+        release_connection if fresh_connection
       end
 
       # Returns true if a connection has already been opened.
-      def connected?; @connected end
+      def connected?; @connected.true? end
+
+      # @private replacement for attr_reader :connections
+      def connections; @thread_cached_conns.values end
 
       # Disconnects all connections in the pool, and clears the pool.
       def disconnect!
         synchronize do
-          @connected = false
-
-          connections = @reserved_connections.values
-          @reserved_connections.clear
+          @connected.make_false
 
+          connections = @thread_cached_conns.values
+          @thread_cached_conns.clear
           connections.each do |conn|
-            checkin conn
+            if conn.in_use?
+              conn.steal!
+              checkin conn
+            end
             conn.disconnect!
           end
         end
       end
 
+      def discard! # :nodoc:
+        synchronize do
+          return if @thread_cached_conns.nil? # already discarded
+          @connected.make_false
+
+          connections.each do |conn|
+            conn.discard!
+          end
+          @thread_cached_conns = nil
+        end
+      end
+
       # Clears the cache which maps classes.
       def clear_reloadable_connections!
         synchronize do
-          @connected = false
+          @connected.make_false
 
-          connections = @reserved_connections.values
-          @reserved_connections.clear
+          connections = @thread_cached_conns.values
+          @thread_cached_conns.clear
 
           connections.each do |conn|
-            checkin conn
+            if conn.in_use?
+              conn.steal!
+              checkin conn
+            end
             conn.disconnect! if conn.requires_reloading?
           end
         end
@@ -105,7 +134,7 @@ module ActiveRecord
       def verify_active_connections!
         synchronize do
           clear_stale_cached_connections!
-          @reserved_connections.values.each(&:verify!)
+          @thread_cached_conns.values.each(&:verify!)
         end
       end if ActiveRecord::VERSION::MAJOR < 4
 
@@ -113,12 +142,12 @@ module ActiveRecord
       # are no longer alive.
       # @private AR 3.2 compatibility
       def clear_stale_cached_connections!
-        keys = Thread.list.find_all { |t| t.alive? }.map(&:object_id)
-        keys = @reserved_connections.keys - keys
+        keys = Thread.list.find_all { |t| t.alive? }.map { |t| current_connection_id(t) }
+        keys = @thread_cached_conns.keys - keys
         keys.each do |key|
-          if conn = @reserved_connections[key]
-            checkin conn, false # no release
-            @reserved_connections.delete(key)
+          if conn = @thread_cached_conns[key]
+            checkin conn, true # no release
+            @thread_cached_conns.delete(key)
           end
         end
       end if ActiveRecord::VERSION::MAJOR < 4
@@ -126,38 +155,26 @@ module ActiveRecord
       # Check-out a database connection from the pool, indicating that you want
       # to use it. You should call #checkin when you no longer need this.
       #
-      # This is done by either returning and leasing existing connection, or by
-      # creating a new connection and leasing it.
-      #
-      # If all connections are leased and the pool is at capacity (meaning the
-      # number of currently leased connections is greater than or equal to the
-      # size limit set), an ActiveRecord::ConnectionTimeoutError exception will be raised.
-      #
-      # Returns: an AbstractAdapter object.
-      #
-      # Raises:
-      # - ConnectionTimeoutError: no connection can be obtained from the pool.
+      # @return [ActiveRecord::ConnectionAdapters::AbstractAdapter]
+      # @raise [ActiveRecord::ConnectionTimeoutError] no connection can be obtained from the pool
       def checkout
-        #synchronize do
-          conn = checkout_new_connection # acquire_connection
+        conn = checkout_new_connection # acquire_connection
+        synchronize do
           conn.lease
           _run_checkout_callbacks(conn) # checkout_and_verify(conn)
-          conn
-        #end
+        end
+        conn
       end
 
       # Check-in a database connection back into the pool, indicating that you
       # no longer need this connection.
       #
-      # +conn+: an AbstractAdapter object, which was obtained by earlier by
-      # calling +checkout+ on this pool.
-      def checkin(conn, do_release = true)
-        release(conn) if do_release
-        #synchronize do
-          _run_checkin_callbacks(conn)
-          #release conn
-          #@available.add conn
-        #end
+      # @param conn [ActiveRecord::ConnectionAdapters::AbstractAdapter] connection
+      # object, which was obtained earlier by calling #checkout on this pool
+      # @see #checkout
+      def checkin(conn, released = nil)
+        release(conn) unless released
+        _run_checkin_callbacks(conn)
       end
 
       # Remove a connection from the connection pool.  The connection will
@@ -171,15 +188,24 @@ module ActiveRecord
         # we do not really manage the connection pool - nothing to do ...
       end
 
+      def flush(minimum_idle = nil)
+        # we do not really manage the connection pool
+      end
+
+      def flush!
+        reap
+        flush(-1)
+      end
+
+      def stat
+        {
+          connections: connections.size
+        }
+      end
+
       private
 
-      # Acquire a connection by one of 1) immediately removing one
-      # from the queue of available connections, 2) creating a new
-      # connection if the pool is not at capacity, 3) waiting on the
-      # queue for a connection to become available.
-      #
-      # Raises:
-      # - ConnectionTimeoutError if a connection could not be acquired
+      # @raise [ActiveRecord::ConnectionTimeoutError]
       def acquire_connection
         # underlying pool will poll and block if "empty" (all checked-out)
         #if conn = @available.poll
@@ -193,34 +219,30 @@ module ActiveRecord
         checkout_new_connection
       end
 
-      def release(conn, owner = nil)
-        thread_id = owner.object_id unless owner.nil?
+      def release(conn, owner = conn.owner)
+        thread_id = current_connection_id(owner) unless owner.nil?
 
         thread_id ||=
-          if @reserved_connections[conn_id = current_connection_id] == conn
+          if @thread_cached_conns[conn_id = current_connection_id].equal?(conn)
             conn_id
           else
-            connections = @reserved_connections
-            connections.keys.find { |k| connections[k] == conn }
+            connections = @thread_cached_conns
+            connections.keys.find { |k| connections[k].equal?(conn) }
           end
 
-        @reserved_connections.delete thread_id if thread_id
+        @thread_cached_conns.delete_pair(thread_id, conn) if thread_id
       end
 
       def checkout_new_connection
-        # NOTE: automatic reconnect seems to make no sense for us!
-        #raise ConnectionNotEstablished unless @automatic_reconnect
-
+        # NOTE: automatic reconnect makes no sense for us!
         begin
           conn = new_connection
-        rescue ConnectionTimeoutError => e
-          raise e
         rescue => e
-          raise ConnectionTimeoutError, e.message if timeout_error?(e)
+          raise ConnectionTimeoutError, e.message if timeout_error?(e) && !e.is_a?(ConnectionTimeoutError)
           raise e
         end
+        @connected.make_true
         conn.pool = self
-        synchronize { @connected = true } if @connected != true
         conn
       end
 

data/lib/active_record/bogacs/pool_support.rb

@@ -1,21 +1,34 @@
-#require 'thread_safe'
+require 'active_record/connection_adapters/abstract/query_cache'
 
 module ActiveRecord
   module Bogacs
     module PoolSupport
 
-      #def self.included(base)
-        #base.send :include, ThreadSafe::Synchronized
-      #end
+      def self.included(base)
+        base.send :include, ActiveRecord::ConnectionAdapters::QueryCache::ConnectionPoolConfiguration
+      end if ActiveRecord::ConnectionAdapters::QueryCache.const_defined? :ConnectionPoolConfiguration
+
+      attr_accessor :schema_cache
+
+      def lock_thread=(lock_thread)
+        if lock_thread
+          @lock_thread = Thread.current
+        else
+          @lock_thread = nil
+        end
+      end if ActiveRecord::VERSION::MAJOR > 4
 
       def new_connection
-        Base.send(spec.adapter_method, spec.config)
+        conn = Base.send(spec.adapter_method, spec.config)
+        conn.schema_cache = schema_cache.dup if schema_cache && conn.respond_to?(:schema_cache=)
+        conn
       end
 
-      def current_connection_id
-        # NOTE: possible fiber work-around on JRuby ?!
-        Base.connection_id ||= Thread.current.object_id
+      # @private
+      def current_connection_id(owner_thread = Thread.current)
+        owner_thread.object_id
       end
+      alias_method :connection_cache_key, :current_connection_id # for AR (5.2) compatibility
 
       # @note Method not part of the pre 4.0 API (does no exist).
       def remove(conn)
@@ -38,6 +51,10 @@ module ActiveRecord
 
       private
 
+      def current_thread
+        @lock_thread || Thread.current
+      end
+
       if ActiveRecord::VERSION::STRING > '4.2'
 
         def _run_checkin_callbacks(conn)
@@ -90,4 +107,4 @@ module ActiveRecord
 
     end
   end
-end
+end

data/lib/active_record/bogacs/railtie.rb

@@ -0,0 +1,17 @@
+module ActiveRecord
+  module Bogacs
+    class Railtie < Rails::Railtie
+
+      initializer 'active_record.bogacs', :before => 'active_record.initialize_database' do |_|
+        ActiveSupport.on_load :active_record do
+          require 'active_record/bogacs'
+
+          # support for auto-configuring FalsePool (when config[:pool] set to false) :
+          require 'active_record/bogacs/connection_handler'
+          ActiveRecord::Base.default_connection_handler = ConnectionHandler.new
+        end
+      end
+
+    end
+  end
+end

data/lib/active_record/bogacs/reaper.rb

@@ -3,22 +3,20 @@ require 'thread'
 module ActiveRecord
   module Bogacs
 
-    # Every +frequency+ seconds, the reaper will "reap" a pool it belongs to.
+    # Every *frequency* seconds, the reaper will "reap" a pool it belongs to.
     # Reaping means detecting stale cached connections in the pool - those that
     # were checked-out by a thread but never checked back in after the thread
     # finished/died.
     #
-    # @note This version is fail safe - raised errors won't stop the reaping process.
-    # Instead the thread will be restarted and reaping continues at the next tick.
-    #
-    # Configure the frequency by setting `:reaping_frequency` in your database yaml file.
+    # Configure the frequency by setting `:reaping_frequency` in your database.yml.
     #
+    # @note This version is fail safe - raised errors won't stop the reaping process.
     class Reaper
 
       attr_reader :pool, :frequency
       attr_accessor :retry_error
 
-      # Reaper.new(self, spec.config[:reaping_frequency]).run
+      # `Reaper.new(pool, spec.config[:reaping_frequency]).run`
       # @private
       def initialize(pool, frequency)
         @pool = pool;

data/lib/active_record/bogacs/shareable_pool.rb

@@ -1,9 +1,10 @@
+require 'active_record/version'
 require 'active_record/connection_adapters/abstract/connection_pool'
 
-require 'thread'
+require 'concurrent/atomic/atomic_reference'
+require 'concurrent/thread_safe/util/cheap_lockable.rb'
 
 require 'active_record/bogacs/thread_safe'
-
 require 'active_record/bogacs/pool_support'
 
 # NOTE: needs explicit configuration - before connection gets established e.g.
@@ -16,14 +17,9 @@ module ActiveRecord
     class ShareablePool < ConnectionAdapters::ConnectionPool # NOTE: maybe do not override?!
       include PoolSupport
 
-      if ActiveRecord::Bogacs::ThreadSafe.load_cheap_lockable(false)
-        include ThreadSafe::CheapLockable
-      else
-        alias_method :cheap_synchronize, :synchronize
-      end
+      include ThreadSafe::Synchronized
 
-      ActiveRecord::Bogacs::ThreadSafe.load_atomic_reference
-      AtomicReference = ThreadSafe::AtomicReference
+      AtomicReference = ::Concurrent::AtomicReference
 
       DEFAULT_SHARED_POOL = 0.25 # only allow 25% of the pool size to be shared
       MAX_THREAD_SHARING = 5 # not really a strict limit but should hold
@@ -60,7 +56,7 @@ module ActiveRecord
       def release_connection(with_id = current_connection_id)
         if reserved_conn = @reserved_connections[with_id]
           if shared_count = @shared_connections[reserved_conn]
-            cheap_synchronize do # lock due #get_shared_connection ... not needed ?!
+            synchronize do # lock due #get_shared_connection ... not needed ?!
               # NOTE: the other option is to not care about shared here at all ...
               if shared_count.get == 0 # releasing a shared connection
                 release_shared_connection(reserved_conn)
@@ -75,18 +71,18 @@ module ActiveRecord
 
       # @override
       def disconnect!
-        cheap_synchronize { @shared_connections.clear; super }
+        synchronize { @shared_connections.clear; super }
       end
 
       # @override
       def clear_reloadable_connections!
-        cheap_synchronize { @shared_connections.clear; super }
+        synchronize { @shared_connections.clear; super }
       end
 
       # @override
       # @note called from #reap thus the pool should work with reaper
       def remove(conn)
-        cheap_synchronize { @shared_connections.delete(conn); super }
+        synchronize { @shared_connections.delete(conn); super }
       end
 
 #      # Return any checked-out connections back to the pool by threads that
@@ -135,7 +131,7 @@ module ActiveRecord
             emulated_checkout(connection); shared = true
             DEBUG && debug("with_shared_conn 20 got shared = #{connection.to_s}")
           else
-            cheap_synchronize do
+            synchronize do
               # check shared again as/if threads end up sync-ing up here :
               if connection = get_shared_connection
                 emulated_checkout(connection)
@@ -218,7 +214,7 @@ module ActiveRecord
         end
 
         # we did as much as could without a lock - now sync due possible release
-        cheap_synchronize do # TODO although this likely might be avoided ...
+        synchronize do # TODO although this likely might be avoided ...
           # should try again if possibly the same connection got released :
           unless least_count = @shared_connections[least_shared]
             DEBUG && debug(" get_shared_conn retry (connection got released)")
@@ -238,7 +234,7 @@ module ActiveRecord
       def rem_shared_connection(connection)
         if shared_count = @shared_connections[connection]
            # shared_count.update { |v| v - 1 } # NOTE: likely fine without lock!
-           cheap_synchronize do # give it back to the pool
+           synchronize do # give it back to the pool
              shared_count.update { |v| v - 1 } # might give it back if :
              release_shared_connection(connection) if shared_count.get == 0
            end

data/lib/active_record/bogacs/thread_safe/synchronized.rb

@@ -1,33 +1,29 @@
+require 'concurrent/thread_safe/util/cheap_lockable.rb'
+
 # @note Inpspired by thread_safe gem's Util::CheapLockable mixin.
 module ActiveRecord::Bogacs
   module ThreadSafe
-    engine = defined?(RUBY_ENGINE) && RUBY_ENGINE
-    if engine == 'rbx'
+    if defined? JRUBY_VERSION
       module Synchronized
-        # Making use of the Rubinius' ability to lock via object headers to avoid
-        # the overhead of the extra Mutex objects.
-        def synchronize
-          ::Rubinius.lock(self)
-          begin
-            yield
-          ensure
-            ::Rubinius.unlock(self)
+        if defined? ::JRuby::Util.synchronized # since JRuby 9.3
+          def synchronize
+            ::JRuby::Util.synchronized(self) { yield }
+          end
+        else
+          require 'jruby'
+          def synchronize
+            ::JRuby.reference0(self).synchronized { yield }
           end
         end
       end
-    elsif engine == 'jruby'
+    else
+      require 'concurrent/thread_safe/util/cheap_lockable.rb'
+
       module Synchronized
-        require 'jruby'
-        # Use Java's native synchronized (this) { wait(); notifyAll(); } to avoid
-        # the overhead of the extra Mutex objects
-        def synchronize
-          ::JRuby.reference0(self).synchronized { yield }
-        end
+        include ::Concurrent::ThreadSafe::Util::CheapLockable
+        alias_method :synchronize, :cheap_synchronize
+        public :synchronize
       end
-    else
-      require 'thread'; require 'monitor'
-      # on MRI fallback to built-in MonitorMixin
-      Synchronized = MonitorMixin
     end
   end
-end
+end

data/lib/active_record/bogacs/thread_safe.rb

@@ -2,75 +2,11 @@ module ActiveRecord
   module Bogacs
     module ThreadSafe
 
-      #def self.load_map
-        begin
-          require 'concurrent/map.rb'
-        rescue LoadError => e
-          begin
-            require 'thread_safe'
-          rescue
-            warn "activerecord-bogacs needs gem 'concurrent-ruby', '~> 1.0' (or the old 'thread_safe' gem) " <<
-                 "please install or add it to your Gemfile"
-            raise e
-          end
-        end
-      #end
-
-      #load_map # always pre-load thread_safe
-
-      if defined? ::Concurrent::Map
-        Map = ::Concurrent::Map
-      else
-        Map = ::ThreadSafe::Cache
-      end
+      require 'concurrent/map.rb'
+      Map = ::Concurrent::Map
 
       autoload :Synchronized, 'active_record/bogacs/thread_safe/synchronized'
 
-      def self.load_atomic_reference
-        return const_get :AtomicReference if const_defined? :AtomicReference
-
-        begin
-          require 'concurrent/atomic/atomic_reference.rb'
-        rescue LoadError => e
-          begin
-            require 'atomic'
-          rescue LoadError
-            warn "shareable pool needs gem 'concurrent-ruby', '>= 0.9.1' (or the old 'atomic' gem) " <<
-                 "please install or add it to your Gemfile"
-            raise e
-          end
-        end
-
-        if defined? ::Concurrent::AtomicReference
-          const_set :AtomicReference, ::Concurrent::AtomicReference
-        else
-          const_set :AtomicReference, ::Atomic
-        end
-      end
-
-      def self.load_cheap_lockable(required = true)
-        return const_get :CheapLockable if const_defined? :CheapLockable
-
-        begin
-          require 'concurrent/thread_safe/util/cheap_lockable.rb'
-        rescue LoadError => e
-          begin
-            require 'thread_safe'
-          rescue
-            return nil unless required
-            warn "activerecord-bogacs needs gem 'concurrent-ruby', '~> 1.0' (or the old 'thread_safe' gem) " <<
-                 "please install or add it to your Gemfile"
-            raise e
-          end
-        end
-
-        if defined? ::Concurrent::ThreadSafe::Util::CheapLockable
-          const_set :CheapLockable, ::Concurrent::ThreadSafe::Util::CheapLockable
-        else
-          const_set :CheapLockable, ::ThreadSafe::Util::CheapLockable
-        end
-      end
-
     end
   end
-end
+end