activerecord-bogacs 0.5.1 → 0.7.1

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
@@ -34,26 +37,32 @@ module ActiveRecord
       # @private
       def checkout_timeout; end
 
+      # @override
+      # def connection_cache_key(owner_thread = Thread.current)
+      #   owner_thread
+      # end
+
       # Retrieve the connection associated with the current thread, or call
       # #checkout to obtain one if necessary.
       #
       # #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 = connection_cache_key(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 = connection_cache_key(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(connection_cache_key(owner_thread))
         checkin conn if conn
       end
 
@@ -61,41 +70,68 @@ module ActiveRecord
       # exists checkout a connection, yield it to the block, and checkin the
       # connection when finished.
       def with_connection
-        connection_id = current_connection_id
-        fresh_connection = true unless active_connection?
-        yield connection
+        connection_id = connection_cache_key
+        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 discarded?
+          @connected.make_false
+
+          connections.each do |conn|
+            conn.discard!
+          end
+          @thread_cached_conns = nil
+        end
+      end
+
+      def discarded? # :nodoc:
+        @thread_cached_conns.nil?
+      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 +143,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 +151,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| connection_cache_key(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 +167,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 +181,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 +197,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 +228,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 = connection_cache_key(owner) unless owner.nil?
 
         thread_id ||=
-          if @reserved_connections[conn_id = current_connection_id] == conn
+          if @thread_cached_conns[conn_id = connection_cache_key].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,19 +1,33 @@
+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
+      # @override (previously named current_connection_id)
+      # @private connection_cache_key for AR (5.2) compatibility
+      def connection_cache_key(owner_thread = Thread.current)
+        owner_thread.object_id
       end
 
       # @note Method not part of the pre 4.0 API (does no exist).
@@ -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/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/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'
@@ -13,17 +14,11 @@ require 'active_record/bogacs/pool_support'
 #
 module ActiveRecord
   module Bogacs
-    class ShareablePool < ConnectionAdapters::ConnectionPool # NOTE: maybe do not override?!
-      include PoolSupport
+    class ShareablePool < DefaultPool
 
-      if ActiveRecord::Bogacs::ThreadSafe.load_cheap_lockable(false)
-        include ThreadSafe::CheapLockable
-      else
-        alias_method :cheap_synchronize, :synchronize
-      end
+      include ::Concurrent::ThreadSafe::Util::CheapLockable
 
-      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
@@ -32,38 +27,35 @@ module ActiveRecord
 
       # @override
       def initialize(spec)
-        super(spec) # ConnectionPool#initialize
+        super(spec)
         shared_size = spec.config[:shared_pool]
         shared_size = shared_size ? shared_size.to_f : DEFAULT_SHARED_POOL
         # size 0.0 - 1.0 assumes percentage of the pool size
         shared_size = ( @size * shared_size ).round if shared_size <= 1.0
         @shared_size = shared_size.to_i
-        @shared_connections = ThreadSafe::Map.new # :initial_capacity => @shared_size, :concurrency_level => 20
+        @shared_connections = ThreadSafe::Map.new # initial_capacity: @shared_size
       end
 
       # @override
       def connection
-        Thread.current[shared_connection_key] || begin # super - simplified :
-          super # @reserved_connections.compute_if_absent(current_connection_id) { checkout }
-        end
+        current_thread[shared_connection_key] || super
       end
 
       # @override
       def active_connection?
-        if shared_conn = Thread.current[shared_connection_key]
-          return shared_conn.in_use?
-        end
-        super_active_connection? current_connection_id
+        return true if current_thread[shared_connection_key]
+        has_active_connection? # super
       end
 
       # @override called from ConnectionManagement middle-ware (when finished)
-      def release_connection(with_id = current_connection_id)
-        if reserved_conn = @reserved_connections[with_id]
+      def release_connection(owner_thread = Thread.current)
+        conn_id = connection_cache_key(owner_thread)
+        if reserved_conn = @thread_cached_conns.delete(conn_id)
           if shared_count = @shared_connections[reserved_conn]
             cheap_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)
+                release_shared_connection(reserved_conn, owner_thread)
               #else return false
               end
             end
@@ -75,18 +67,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
@@ -105,14 +97,14 @@ module ActiveRecord
 
       # Custom API :
 
-      def release_shared_connection(connection)
+      def release_shared_connection(connection, owner_thread = Thread.current)
         shared_conn_key = shared_connection_key
-        if connection == Thread.current[shared_conn_key]
-          Thread.current[shared_conn_key] = nil
+        if connection == owner_thread[shared_conn_key]
+          owner_thread[shared_conn_key] = nil
         end
 
         @shared_connections.delete(connection)
-        checkin connection
+        shared_checkin connection # synchronized
       end
 
       def with_shared_connection
@@ -125,9 +117,8 @@ module ActiveRecord
 
         start = Time.now if DEBUG
         begin
-          connection_id = current_connection_id
           # if there's a 'regular' connection on the thread use it as super
-          if super_active_connection?(connection_id) # for current thread
+          if has_active_connection? # for current thread
             connection = self.connection # do not mark as shared
             DEBUG && debug("with_shared_conn 10 got active = #{connection.to_s}")
           # otherwise if we have a shared connection - use that one :
@@ -135,7 +126,8 @@ module ActiveRecord
             emulated_checkout(connection); shared = true
             DEBUG && debug("with_shared_conn 20 got shared = #{connection.to_s}")
           else
-            cheap_synchronize do
+            shared = true
+            synchronize do
               # check shared again as/if threads end up sync-ing up here :
               if connection = get_shared_connection
                 emulated_checkout(connection)
@@ -148,7 +140,6 @@ module ActiveRecord
                 DEBUG && debug("with_shared_conn 30 acq shared = #{connection.to_s}")
               end
             end
-            shared = true
           end
 
           Thread.current[shared_conn_key] = connection if shared
@@ -156,23 +147,17 @@ module ActiveRecord
           DEBUG && debug("with_shared_conn obtaining a connection took #{(Time.now - start) * 1000}ms")
           yield connection
         ensure
-          Thread.current[shared_conn_key] = nil # if shared
-          rem_shared_connection(connection) if shared
+          Thread.current[shared_conn_key] = nil if shared
+          rem_shared_connection(connection) if shared && connection
         end
       end
 
       private
 
-      def super_active_connection?(connection_id = current_connection_id)
-        (@reserved_connections.get(connection_id) || ( return false )).in_use?
+      def has_active_connection? # super.active_connection?
+        @thread_cached_conns.fetch(connection_cache_key(current_thread), nil)
       end
 
-      def super_active_connection?(connection_id = current_connection_id)
-        synchronize do
-          (@reserved_connections[connection_id] || ( return false )).in_use?
-        end
-      end if ActiveRecord::VERSION::MAJOR < 4
-
       def acquire_connection_no_wait?
         synchronize do
           @connections.size < @size || @available.send(:can_remove_no_wait?)
@@ -247,12 +232,22 @@ module ActiveRecord
 
       def emulated_checkin(connection)
         # NOTE: not sure we'd like to run `run_callbacks :checkin {}` here ...
-        connection.expire
+        connection.expire if connection.owner.equal? Thread.current
       end
 
       def emulated_checkout(connection)
         # NOTE: not sure we'd like to run `run_callbacks :checkout {}` here ...
-        connection.lease; # connection.verify! auto-reconnect should do this
+        connection.lease unless connection.in_use? # connection.verify! auto-reconnect should do this
+      end
+
+      def shared_checkin(conn)
+        #conn.lock.synchronize do
+        synchronize do
+          _run_checkin_callbacks(conn) if conn.owner.equal? Thread.current
+
+          @available.add conn
+        end
+        #end
       end
 
       def shared_connection_key
@@ -269,7 +264,7 @@ module ActiveRecord
           when 'true' then ActiveRecord::Base.logger
           else File.expand_path(debug)
           end
-          require 'logger'; Logger.new log_dev
+          log_dev.respond_to?(:debug) ? log_dev : (require 'logger'; Logger.new log_dev)
         else nil
         end
       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