activerecord-bogacs 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5010de8016e3c5896dc032a0fa6afc6ab5cbb1808f60e7c6f42b22b280910aeb
-  data.tar.gz: 3290de6d8265973c7efa237e18de7f96253580363b743785b069f34c5c92504a
+  metadata.gz: 8272c1dff28e707a092e34ec3e95a0bcf76f31c7b38074da474db9e5cf520edd
+  data.tar.gz: fe9a92843c1b94098e9de4e85d830f96357aa8b49a0e769001eb14d37a71d334
 SHA512:
-  metadata.gz: 559b6831696d5e7ca408c735bc1f61bcb5c3fcfad19b0806aff943a47c623ac322462e79c3cefc1aca745df5cdda19986651c405e2024eebb8fa3c4cf02d7296
-  data.tar.gz: 588ccb8e705390652de5162a26cee060ce8fe51887693069602a55cfecfb19175b23268a821a7c956d7494d6be542f486c6bda89a4814932e8ee4249965a97de
+  metadata.gz: a9ccd085265c8f744dd7d7ef95dd38918ef2b37c029d1ad19a09322d727fa7a080f895ab14bab005cd54887402090798750a3ad9c1f6f7d0b8456a205ae7cd08
+  data.tar.gz: 40031eed7a1628094fc21d105006e32e06ab48b0890fa0abeb8379c2d513527a01c520e124438bb7dd380448e66cb8b3a2947beaf1cd15f1f2d074645b0b97d8

data/lib/active_record/bogacs/default_pool.rb

@@ -248,7 +248,7 @@ module ActiveRecord
       #
       # @return [ActiveRecord::ConnectionAdapters::AbstractAdapter]
       def connection
-        connection_id = current_connection_id(current_thread)
+        connection_id = connection_cache_key(current_thread)
         conn = @thread_cached_conns.fetch(connection_id, nil)
         conn = ( @thread_cached_conns[connection_id] ||= checkout ) unless conn
         conn
@@ -258,7 +258,7 @@ module ActiveRecord
       #
       # @return [true, false]
       def active_connection?
-        connection_id = current_connection_id(current_thread)
+        connection_id = connection_cache_key(current_thread)
         @thread_cached_conns.fetch(connection_id, nil)
       end
 
@@ -266,7 +266,7 @@ module ActiveRecord
       # #release_connection releases the connection-thread association
       # and returns the connection to the pool.
       def release_connection(owner_thread = Thread.current)
-        conn = @thread_cached_conns.delete(current_connection_id(owner_thread))
+        conn = @thread_cached_conns.delete(connection_cache_key(owner_thread))
         checkin conn if conn
       end
 
@@ -276,7 +276,7 @@ module ActiveRecord
       #
       # @yield [ActiveRecord::ConnectionAdapters::AbstractAdapter]
       def with_connection
-        connection_id = current_connection_id
+        connection_id = connection_cache_key
         unless conn = @thread_cached_conns[connection_id]
           conn = connection
           fresh_connection = true
@@ -333,7 +333,7 @@ module ActiveRecord
       # See AbstractAdapter#discard!
       def discard! # :nodoc:
         synchronize do
-          return if @connections.nil? # already discarded
+          return if discarded?
           @connected.make_false
 
           @connections.each do |conn|
@@ -342,6 +342,11 @@ module ActiveRecord
           @connections = @available = @thread_cached_conns = nil
         end
       end
+
+      def discarded? # :nodoc:
+        @connections.nil?
+      end
+
       def clear_reloadable_connections!
         synchronize do
           @thread_cached_conns.clear
@@ -566,7 +571,7 @@ module ActiveRecord
       #--
       # if owner_thread param is omitted, this must be called in synchronize block
       def remove_connection_from_thread_cache(conn, owner_thread = conn.owner)
-        @thread_cached_conns.delete_pair(current_connection_id(owner_thread), conn)
+        @thread_cached_conns.delete_pair(connection_cache_key(owner_thread), conn)
       end
       alias_method :release, :remove_connection_from_thread_cache
 

data/lib/active_record/bogacs/false_pool.rb

@@ -37,19 +37,24 @@ 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
-        connection_id = current_connection_id(current_thread)
+        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?
-        connection_id = current_connection_id(current_thread)
+        connection_id = connection_cache_key(current_thread)
         @thread_cached_conns[connection_id]
       end
 
@@ -57,7 +62,7 @@ module ActiveRecord
       # #release_connection releases the connection-thread association
       # and returns the connection to the pool.
       def release_connection(owner_thread = Thread.current)
-        conn = @thread_cached_conns.delete(current_connection_id(owner_thread))
+        conn = @thread_cached_conns.delete(connection_cache_key(owner_thread))
         checkin conn if conn
       end
 
@@ -65,7 +70,7 @@ 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
+        connection_id = connection_cache_key
         unless conn = @thread_cached_conns[connection_id]
           conn = connection
           fresh_connection = true
@@ -100,7 +105,7 @@ module ActiveRecord
 
       def discard! # :nodoc:
         synchronize do
-          return if @thread_cached_conns.nil? # already discarded
+          return if discarded?
           @connected.make_false
 
           connections.each do |conn|
@@ -110,6 +115,10 @@ module ActiveRecord
         end
       end
 
+      def discarded? # :nodoc:
+        @thread_cached_conns.nil?
+      end
+
       # Clears the cache which maps classes.
       def clear_reloadable_connections!
         synchronize do
@@ -142,7 +151,7 @@ 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 { |t| current_connection_id(t) }
+        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 = @thread_cached_conns[key]
@@ -220,10 +229,10 @@ module ActiveRecord
       end
 
       def release(conn, owner = conn.owner)
-        thread_id = current_connection_id(owner) unless owner.nil?
+        thread_id = connection_cache_key(owner) unless owner.nil?
 
         thread_id ||=
-          if @thread_cached_conns[conn_id = current_connection_id].equal?(conn)
+          if @thread_cached_conns[conn_id = connection_cache_key].equal?(conn)
             conn_id
           else
             connections = @thread_cached_conns

data/lib/active_record/bogacs/pool_support.rb

@@ -24,11 +24,11 @@ module ActiveRecord
         conn
       end
 
-      # @private
-      def current_connection_id(owner_thread = Thread.current)
+      # @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
-      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)

data/lib/active_record/bogacs/shareable_pool.rb

@@ -14,10 +14,9 @@ require 'active_record/bogacs/pool_support'
 #
 module ActiveRecord
   module Bogacs
-    class ShareablePool < ConnectionAdapters::ConnectionPool # NOTE: maybe do not override?!
-      include PoolSupport
+    class ShareablePool < DefaultPool
 
-      include ThreadSafe::Synchronized
+      include ::Concurrent::ThreadSafe::Util::CheapLockable
 
       AtomicReference = ::Concurrent::AtomicReference
 
@@ -28,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]
-            synchronize do # lock due #get_shared_connection ... not needed ?!
+            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
@@ -101,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
@@ -121,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 :
@@ -131,6 +126,7 @@ module ActiveRecord
             emulated_checkout(connection); shared = true
             DEBUG && debug("with_shared_conn 20 got shared = #{connection.to_s}")
           else
+            shared = true
             synchronize do
               # check shared again as/if threads end up sync-ing up here :
               if connection = get_shared_connection
@@ -144,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
@@ -152,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?)
@@ -214,7 +203,7 @@ module ActiveRecord
         end
 
         # we did as much as could without a lock - now sync due possible release
-        synchronize do # TODO although this likely might be avoided ...
+        cheap_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)")
@@ -234,7 +223,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!
-           synchronize do # give it back to the pool
+           cheap_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
@@ -243,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
@@ -265,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/version.rb

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

data/test/active_record/bogacs/shareable_pool/connection_pool_test.rb

@@ -4,8 +4,7 @@ module ActiveRecord
   module Bogacs
     class ShareablePool
 
-      # TODO: ShareablePool is pretty much broken since 0.7 :
-      class ConnectionPoolTest #< TestBase
+      class ConnectionPoolTest < TestBase
 
         include ConnectionAdapters::ConnectionPoolTestMethods
 
@@ -25,8 +24,7 @@ module ActiveRecord
 
       end
 
-      # TODO: ShareablePool is pretty much broken since 0.7 :
-      class PoolAPITest #< TestBase
+      class PoolAPITest < TestBase
 
         def setup; ActiveRecord::Base.connection end
         # def teardown; ActiveRecord::Base.connection_pool.reap end

data/test/active_record/bogacs/shareable_pool/connection_sharing_test.rb

@@ -4,8 +4,7 @@ module ActiveRecord
   module Bogacs
     class ShareablePool
 
-      # TODO: ShareablePool is pretty much broken since 0.7 :
-      class ConnectionSharingTest #< TestBase
+      class ConnectionSharingTest < TestBase
         include TestHelper
 
         def setup
@@ -244,7 +243,7 @@ module ActiveRecord
                 sleep(0.005)
 
                 with_shared_connection do |conn2|
-                  assert conn1 == conn2
+                  assert conn1.equal?(conn2)
 
                   # we can not do any-more here without a timeout :
                   failed = nil

data/test/active_record/bogacs/shareable_pool_helper.rb

@@ -24,7 +24,7 @@ module ActiveRecord
         alias_method :connections, :initialized_connections
 
         def reserved_connections
-          ActiveRecord::Base.connection_pool.reserved_connections
+          connection_pool.instance_variable_get :@thread_cached_conns
         end
 
         def available_connections
@@ -70,7 +70,7 @@ module ActiveRecord
         end
 
         def self.shutdown
-            ActiveRecord::Base.connection_pool.discard!
+          ActiveRecord::Base.connection_pool.disconnect!
           ConnectionAdapters::ConnectionHandler.connection_pool_class = ConnectionAdapters::ConnectionPool
         end
 

data/test/test_helper.rb

@@ -55,7 +55,7 @@ config[:'prepared_statements'] = prepared_statements if prepared_statements
 #jdbc_properties = { 'logUnclosedConnections' => true, 'loginTimeout' => 5 }
 #config[:'properties'] = jdbc_properties
 config[:'properties'] ||= {}
-config[:'properties']['useSSL'] ||= 'false' if config[:adapter].starts_with?('mysql')
+config[:'properties']['useSSL'] ||= 'false' if config[:adapter].start_with?('mysql')
 
 checkout_timeout = ENV['AR_POOL_CHECKOUT_TIMEOUT'] || checkout_timeout
 config[:'checkout_timeout'] = checkout_timeout.to_f if checkout_timeout

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-bogacs
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Karol Bucek
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-14 00:00:00.000000000 Z
+date: 2022-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement