activerecord-bogacs 0.6.0 → 0.7.0

data/lib/active_record/bogacs/false_pool.rb

@@ -1,5 +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'
 
@@ -16,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
@@ -40,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
 
@@ -62,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
@@ -107,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
 
@@ -115,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
@@ -131,12 +158,12 @@ module ActiveRecord
       # @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
@@ -145,13 +172,9 @@ module ActiveRecord
       # @param conn [ActiveRecord::ConnectionAdapters::AbstractAdapter] connection
       # object, which was obtained earlier by calling #checkout on this pool
       # @see #checkout
-      def checkin(conn, do_release = true)
-        release(conn) if do_release
-        #synchronize do
-          _run_checkin_callbacks(conn)
-          #release conn
-          #@available.add conn
-        #end
+      def checkin(conn, released = nil)
+        release(conn) unless released
+        _run_checkin_callbacks(conn)
       end
 
       # Remove a connection from the connection pool.  The connection will
@@ -165,6 +188,21 @@ 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
 
       # @raise [ActiveRecord::ConnectionTimeoutError]
@@ -181,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,20 +1,34 @@
+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)
@@ -37,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)
@@ -89,4 +107,4 @@ module ActiveRecord
 
     end
   end
-end
+end

data/lib/active_record/bogacs/shareable_pool.rb

@@ -1,7 +1,8 @@
 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'
@@ -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,98 +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
-
-
-      def self.load_monotonic_clock(required = true)
-        return const_get :MONOTONIC_CLOCK if const_defined? :MONOTONIC_CLOCK
-
-        begin
-          require 'concurrent/utility/monotonic_time.rb'
-        rescue LoadError => e
-          return nil unless required
-          warn "activerecord-bogacs needs gem 'concurrent-ruby', '~> 1.0'" +
-               " please install or add it to your Gemfile"
-          raise e
-        end
-
-        if defined? ::Concurrent.monotonic_time
-          const_set :MONOTONIC_CLOCK, ::Concurrent.const_get(:GLOBAL_MONOTONIC_CLOCK)
-        end
-      end
-
-      # @note Only works when {@link #load_monotonic_time} succeeds.
-      #def self.monotonic_time
-      #  MONOTONIC_CLOCK.get_time # java.lang.System.nanoTime() / 1_000_000_000.0
-      #end
-
     end
   end
-end
+end

data/lib/active_record/bogacs/validator.rb

@@ -1,10 +1,5 @@
-begin
-  require 'concurrent/executors'
-  require 'concurrent/timer_task'
-rescue LoadError => e
-  warn "activerecord-bogacs' validator feature needs gem 'concurrent-ruby', please install or add it to your Gemfile"
-  raise e
-end
+require 'concurrent/executors'
+require 'concurrent/timer_task'
 
 require 'active_record/connection_adapters/adapter_compat'
 require 'active_record/bogacs/thread_safe'
@@ -81,20 +76,19 @@ module ActiveRecord
         connections = pool.connections.dup
         connections.map! do |conn|
           if conn
-            owner = conn.owner
-            if conn.in_use? # we'll do a pool.sync-ed check ...
-              if owner && ! owner.alive? # stale-conn (reaping)
+            if owner = conn.owner
+              if owner.alive?
+                nil # owner.alive? ... do not touch
+              else # stale-conn (reaping)
                 pool.remove conn # remove is synchronized
                 conn.disconnect! rescue nil
                 nil
-              elsif ! owner # NOTE: this is likely a nasty bug
-                logger && logger.warn("[validator] found in-use connection ##{conn.object_id} without owner - removing from pool")
-                pool.remove_without_owner conn # synchronized
-                conn.disconnect! rescue nil
-                nil
-              else
-                nil # owner.alive? ... do not touch
               end
+            elsif conn.in_use? # no owner? (likely a nasty bug)
+              logger && logger.warn("[validator] found in-use connection ##{conn.object_id} without owner - removing from pool")
+              pool.remove_without_owner conn # synchronized
+              conn.disconnect! rescue nil
+              nil
             else
               conn # conn not in-use - candidate for validation
             end
@@ -170,7 +164,8 @@ module ActiveRecord
 
         def release_without_owner(conn)
           if owner_id = cached_conn_owner_id(conn)
-            thread_cached_conns.delete owner_id; return true
+            thread_cached_conns.delete owner_id
+            return true
           end
         end
 
@@ -179,4 +174,4 @@ module ActiveRecord
     end
 
   end
-end
+end

data/lib/active_record/bogacs/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Bogacs
-    VERSION = '0.6.0'
+    VERSION = '0.7.0'
   end
 end