activerecord-bogacs 0.5.1 → 0.7.1

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

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
@@ -116,7 +110,7 @@ module ActiveRecord
             logger && logger.info("[validator] connection ##{conn.object_id} failed to validate: #{e.inspect}")
           end
 
-          # TODO support last_use - only validate if certain amount since use passed
+          # TODO support seconds_idle - only validate if certain amount since use passed
 
           logger && logger.debug("[validator] found non-active connection ##{conn.object_id} - removing from pool")
           pool.remove_without_owner conn # not active - remove
@@ -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.5.1'
+    VERSION = '0.7.1'
   end
 end

data/lib/active_record/bogacs.rb

@@ -1,6 +1,10 @@
-require 'active_record'
 
 require 'active_record/bogacs/version'
 require 'active_record/bogacs/autoload'
 
-require 'active_record/connection_adapters/pool_class.rb'
+if defined?(Rails::Railtie)
+  require 'active_record/bogacs/railtie'
+else
+  require 'active_record'
+  require 'active_record/connection_adapters/pool_class'
+end

data/lib/active_record/connection_adapters/adapter_compat.rb

@@ -1,4 +1,5 @@
 require 'active_record/connection_adapters/abstract_adapter'
+require 'concurrent/utility/monotonic_time.rb'
 
 module ActiveRecord
   module ConnectionAdapters
@@ -8,38 +9,59 @@ module ActiveRecord
 
       if method_defined? :owner # >= 4.2
 
-        attr_reader :last_use
+        if ActiveRecord::VERSION::STRING > '5.2'
 
-        if ActiveRecord::VERSION::MAJOR > 4
+          # THIS IS OUR COMPATIBILITY BASE-LINE
 
-          # @private added @last_use
+        elsif ActiveRecord::VERSION::MAJOR > 4
+
+          # this method must only be called while holding connection pool's mutex
           def lease
             if in_use?
-              msg = 'Cannot lease connection, '
+              msg = "Cannot lease connection, ".dup
               if @owner == Thread.current
-                msg += 'it is already leased by the current thread.'
+                msg << "it is already leased by the current thread."
               else
-                msg += "it is already in use by a different thread: #{@owner}. Current thread: #{Thread.current}."
+                msg << "it is already in use by a different thread: #{@owner}. " \
+                       "Current thread: #{Thread.current}."
               end
               raise ActiveRecordError, msg
             end
 
-            @owner = Thread.current; @last_use = Time.now
+            @owner = Thread.current
           end
 
-        else
-
-          # @private removed synchronization + added @last_use
-          def lease
+          # this method must only be called while holding connection pool's mutex
+          # @private AR 5.2
+          def expire
             if in_use?
-              if @owner == Thread.current
-                # NOTE: could do a warning if 4.2.x cases do not end up here ...
+              if @owner != Thread.current
+                raise ActiveRecordError, "Cannot expire connection, " \
+                  "it is owned by a different thread: #{@owner}. " \
+                  "Current thread: #{Thread.current}."
               end
+
+              @idle_since = ::Concurrent.monotonic_time
+              @owner = nil
             else
-              @owner = Thread.current; @last_use = Time.now
+              raise ActiveRecordError, "Cannot expire connection, it is not currently leased."
+            end
+          end
+
+        else
+
+          # @private removed synchronization
+          def lease
+            unless in_use?
+              @owner = Thread.current
             end
           end
 
+          # @private added @idle_since
+          def expire
+            @owner = nil; @idle_since = ::Concurrent.monotonic_time
+          end
+
         end
 
       else
@@ -69,7 +91,7 @@ module ActiveRecord
           end
 
           def expire
-            @in_use = false; @owner = nil
+            @in_use = false; @owner = nil; @idle_since = ::Concurrent.monotonic_time
           end
 
         else
@@ -83,13 +105,37 @@ module ActiveRecord
           end
 
           def expire
-            @owner = nil
+            @owner = nil; @idle_since = ::Concurrent.monotonic_time
           end
 
         end
 
       end
 
+      # this method must only be called while holding connection pool's mutex (and a desire for segfaults)
+      def steal! # :nodoc:
+        if in_use?
+          if @owner != Thread.current
+            pool.send :release, self, @owner # release exists in both default/false pool
+
+            @owner = Thread.current
+          end
+        else
+          raise ActiveRecordError, "Cannot steal connection, it is not currently leased."
+        end
+      end
+
+      def discard!
+        # no-op
+      end unless method_defined? :discard! # >= 5.2
+
+      # Seconds since this connection was returned to the pool
+      def seconds_idle # :nodoc:
+        return 0 if in_use?
+        time = ::Concurrent.monotonic_time
+        time - ( @idle_since || time )
+      end unless method_defined? :seconds_idle # >= 5.2
+
     end
   end
-end
+end

data/lib/active_record/connection_adapters/pool_class.rb

@@ -10,14 +10,45 @@ require 'active_record/connection_adapters/abstract/connection_pool'
 module ActiveRecord
   module ConnectionAdapters
     # @private there's no other way to change the pool class to use but to patch :(
-    ConnectionHandler.class_eval do
+    class ConnectionHandler
 
       @@connection_pool_class = ConnectionAdapters::ConnectionPool
 
       def connection_pool_class; @@connection_pool_class end
       def self.connection_pool_class=(klass); @@connection_pool_class = klass end
 
-      if ActiveRecord::VERSION::MAJOR > 3 # 4.x
+      if ActiveRecord::VERSION::MAJOR > 4 && # 5.1 - 5.2
+        !(ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR == 0)
+
+        def establish_connection(config)
+          resolver = ConnectionSpecification::Resolver.new(Base.configurations)
+          spec = resolver.spec(config)
+
+          remove_connection(spec.name)
+
+          message_bus = ActiveSupport::Notifications.instrumenter
+          payload = {
+            connection_id: object_id
+          }
+          if spec
+            payload[:spec_name] = spec.name
+            payload[:config] = spec.config
+          end
+
+          message_bus.instrument("!connection.active_record", payload) do
+            owner_to_pool[spec.name] = connection_pool_class.new(spec) # changed
+          end
+
+          owner_to_pool[spec.name]
+        end
+
+      elsif ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR == 0
+
+        def establish_connection(spec)
+          owner_to_pool[spec.name] = connection_pool_class.new(spec)
+        end
+
+      elsif ActiveRecord::VERSION::MAJOR > 3 # 4.x
 
         def establish_connection(owner, spec)
           @class_to_pool.clear

data/lib/activerecord-bogacs.rb

@@ -0,0 +1 @@
+require 'active_record/bogacs' # auto-loading with gem '...' declarations

data/test/active_record/bogacs/false_pool_test.rb

@@ -100,6 +100,20 @@ module ActiveRecord
           assert ActiveRecord::Base.connection.exec_query('SELECT 42')
         end
 
+        # @override
+        def test_checkout_after_close
+          connection = pool.connection
+          assert connection.in_use?
+          assert_equal connection.object_id, pool.connection.object_id
+
+          connection.close # pool.checkin conn
+          assert ! connection.in_use?
+
+          # NOTE: we do not care for connection re-use - it's okay to instantiate a new one
+          #assert_equal connection.object_id, pool.connection.object_id
+          assert pool.connection.in_use?
+        end
+
         # @override
         def test_remove_connection
           conn = pool.checkout
@@ -115,12 +129,13 @@ module ActiveRecord
 
         # @override
         def test_full_pool_exception
+          ActiveRecord::Base.connection_pool.disconnect! # start clean - with no connections
           # ~ pool_size.times { pool.checkout }
           threads_ready = Queue.new; threads_block = Atomic.new(0); threads = []
           max_pool_size.times do |i|
             threads << Thread.new do
               begin
-                conn = ActiveRecord::Base.connection
+                conn = ActiveRecord::Base.connection.tap { |conn| conn.tables }
                 threads_block.update { |v| v + 1 }
                 threads_ready << i
                 while threads_block.value != -1 # await
@@ -135,8 +150,26 @@ module ActiveRecord
           end
           max_pool_size.times { threads_ready.pop } # awaits
 
-          assert_raise(ConnectionTimeoutError) do
-            ActiveRecord::Base.connection # ~ pool.checkout
+          assert_equal max_pool_size, ActiveRecord::Base.connection_pool.connections.size
+
+          threads.each { |thread| assert thread.alive? }
+
+          #puts "data_source.active: #{data_source.getActive} - #{data_source.getNumActive}"
+
+          begin
+            # NOTE: in AR 4.x and before AR::Base.connection was enough
+            # but due the lazy nature of connection init in AR-JDBC 5X we need to force a connection
+            ActiveRecord::Base.connection.tap { |conn| conn.tables } # ~ pool.checkout
+          rescue ActiveRecordError, java.util.NoSuchElementException => e
+            # DBCP: Java::JavaUtil::NoSuchElementException: Timeout waiting for idle object
+            if ActiveRecord::VERSION::STRING < '5.2'
+              assert_instance_of ConnectionTimeoutError, e
+            else
+              # TODO unfortunately we can not map a TimeoutError and will end up with a StatementInvalid
+              # from the tables call :
+              # assert_instance_of ConnectionTimeoutError, e
+              assert ActiveRecord::Base.connection_pool.send(:timeout_error?, e)
+            end
           end
 
         ensure
@@ -151,6 +184,7 @@ module ActiveRecord
           t1 = Thread.new do
             begin
               conn = ActiveRecord::Base.connection
+              conn.tables # force connection
               t1_ready.push(conn)
               t1_block.pop # await
             rescue => e
@@ -165,6 +199,7 @@ module ActiveRecord
             threads << Thread.new do
               begin
                 conn = ActiveRecord::Base.connection
+                conn.tables # force connection
                 threads_block.update { |v| v + 1 }
                 threads_ready << i
                 while threads_block.value != -1 # await
@@ -186,7 +221,7 @@ module ActiveRecord
 
           t2 = Thread.new do
             begin
-              ActiveRecord::Base.connection
+              ActiveRecord::Base.connection.tap { |conn| conn.tables }
             rescue => e
               puts "t2 thread failed: #{e.inspect}"
             end
@@ -214,64 +249,61 @@ module ActiveRecord
           threads && threads.each(&:join)
         end
 
-        protected
+        # @override
+        def test_pooled_connection_checkin_two
+          checkout_checkin_connections_loop 2, 3
 
-        def unwrap_connection(connection)
-          connection.jdbc_connection(true)
+          assert_equal 3, @connection_count
+          assert_equal 0, @timed_out
+          assert_equal 1, @pool.connections.size
         end
 
-      end
+        protected
 
-      class ConnectionPoolWrappingTomcatJdbcDataSourceTest < TestBase
-        include ConnectionPoolWrappingDataSourceTestMethods
+        def unwrap_connection(connection)
+          # NOTE: AR-JDBC 5X messed up jdbc_connection(true) - throws a NPE, work-around:
+          connection.tables # force underlying connection into an initialized state ^^^
 
-        def self.build_data_source(config)
-          build_tomcat_jdbc_data_source(config)
+          jdbc_connection = connection.jdbc_connection(true)
+          begin
+            jdbc_connection.delegate
+          rescue NoMethodError
+            jdbc_connection
+          end
         end
 
-        def self.jndi_name; 'jdbc/TestTomcatJdbcDB' end
-
-        def self.close_data_source
-          @@data_source.send(:close, true) if @@data_source
+        def change_pool_size(size)
+          # noop - @pool.instance_variable_set(:@size, size)
         end
 
-        def max_pool_size; @@data_source.max_active end
-
-        def teardown
-          self.class.close_data_source
+        def change_pool_checkout_timeout(timeout)
+          # noop - @pool.instance_variable_set(:@checkout_timeout, timeout)
         end
 
       end
 
-      class ConnectionPoolWrappingTomcatDbcpDataSourceTest < TestBase
+      class ConnectionPoolWrappingTomcatJdbcDataSourceTest < TestBase
         include ConnectionPoolWrappingDataSourceTestMethods
 
         def self.build_data_source(config)
-          build_tomcat_dbcp_data_source(config)
+          build_tomcat_jdbc_data_source(config)
         end
 
-        def self.jndi_name; 'jdbc/TestTomcatDbcpDB' end
+        def self.jndi_name; 'jdbc/TestTomcatJdbcDB' end
 
         def self.close_data_source
-          @@data_source.close if @@data_source
+          @@data_source.send(:close, true) if @@data_source
         end
 
         def max_pool_size; @@data_source.max_active end
 
         def teardown
-          self.class.establish_jndi_connection # for next test
-        end
-
-        protected
-
-        def unwrap_connection(connection)
-          connection = connection.jdbc_connection(true)
-          connection.delegate
+          self.class.close_data_source
         end
 
       end
 
-      class ConnectionPoolWrappingDbcpDataSourceTest < TestBase
+      class ConnectionPoolWrappingTomcatDbcpDataSourceTest < TestBase
         include ConnectionPoolWrappingDataSourceTestMethods
 
         def self.build_data_source(config)
@@ -292,50 +324,6 @@ module ActiveRecord
 
         protected
 
-        def unwrap_connection(connection)
-          connection = connection.jdbc_connection(true)
-          connection.delegate
-        end
-
-      end
-
-      class ConnectionPoolWrappingC3P0DataSourceTest < TestBase
-        include ConnectionPoolWrappingDataSourceTestMethods
-
-        def self.build_data_source(config)
-          build_c3p0_data_source(config)
-        end
-
-        def self.jndi_config
-          config = super
-          config[:connection_alive_sql] = 'SELECT 1' if old_c3p0?
-          config
-        end
-
-        def self.old_c3p0?
-          if c3p0_jar = $CLASSPATH.find { |jar| jar =~ /c3p0/ }
-            if match = File.basename(c3p0_jar).match(/c3p0\-(.*).jar/)
-              return true if match[1] <= '0.9.2.1'
-            end
-            return false
-          end
-          nil
-        end
-
-        def test_full_pool_blocks
-          return if self.class.old_c3p0?
-          super
-        end
-
-        def self.jndi_name; 'jdbc/TestC3P0DB' end
-
-        def max_pool_size; @@data_source.max_pool_size end
-
-        def teardown
-          # self.class.close_data_source # @@data_source = nil
-          self.class.establish_jndi_connection # for next test
-        end
-
       end
 
       class ConnectionPoolWrappingHikariDataSourceTest < TestBase
@@ -368,4 +356,4 @@ module ActiveRecord
 
     end
   end
-end
+end

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

@@ -123,7 +123,8 @@ module ActiveRecord
 
       end
 
-      class CustomAPITest < TestBase
+      # TODO: ShareablePool is pretty much broken since 0.7 :
+      class CustomAPITest #< TestBase
 
         def setup
           connection_pool.disconnect!

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

@@ -170,7 +170,7 @@ module ActiveRecord
                 assert shared_connection?(conn)
                 conn
               end
-              
+
               assert_equal 5, shared_conns.uniq.size
 
               # still one left for normal connections :
@@ -243,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