activerecord-bogacs 0.5.0 → 0.7.0

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'
@@ -12,13 +7,9 @@ require 'active_record/bogacs/thread_safe'
 module ActiveRecord
   module Bogacs
 
-    # Every +frequency+ seconds, the _validator_ will perform connection validation
+    # Every *frequency* seconds, the _validator_ will perform connection validation
     # on a pool it operates.
     #
-    # @note Do not use a reaper with the validator as reaping (stale connection detection
-    # and removal) is part of the validation process and will only likely slow things down
-    # as all pool connection updates needs to be synchronized.
-    #
     # Configure the frequency by setting `:validate_frequency` in your AR configuration.
     #
     # We recommend not setting values too low as that would drain the pool's performance
@@ -26,11 +17,15 @@ module ActiveRecord
     # checkout - the validator is intended to detect long idle pooled connections "ahead
     # of time" instead of upon retrieval.
     #
+    # @note Do not use a reaper with the validator!
+    # Reaping (stale connection detection and removal) is part of the validation
+    # process and will only slow things down as all pool connection updates needs
+    # to be synchronized.
     class Validator
 
       attr_reader :pool, :frequency, :timeout
 
-      # Validator.new(self, spec.config[:validate_frequency]).run
+      # `Validator.new(pool, spec.config[:validate_frequency]).run`
       # @private
       def initialize(pool, frequency = 60, timeout = nil)
         @pool = pool; PoolAdaptor.adapt! pool
@@ -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.0'
+    VERSION = '0.7.0'
   end
-end
+end

data/lib/active_record/bogacs.rb

@@ -1,57 +1,10 @@
-require 'active_record/bogacs/version'
-
-require 'active_record'
-require 'active_record/version'
-require 'active_record/connection_adapters/abstract/connection_pool'
-
-module ActiveRecord
-  module Bogacs
-    autoload :DefaultPool, 'active_record/bogacs/default_pool'
-    autoload :FalsePool, 'active_record/bogacs/false_pool'
-    autoload :ShareablePool, 'active_record/bogacs/shareable_pool'
-    autoload :Reaper, 'active_record/bogacs/reaper'
-    autoload :Validator, 'active_record/bogacs/validator'
-  end
-  autoload :SharedConnection, 'active_record/shared_connection'
-end
-
-# NOTE: needs explicit configuration - before connection gets established e.g.
-#
-#   klass = ActiveRecord::Bogacs::FalsePool
-#   ActiveRecord::ConnectionAdapters::ConnectionHandler.connection_pool_class = klass
-#
-module ActiveRecord
-  module ConnectionAdapters
-    # @private there's no other way to change the pool class to use but to patch :(
-    ConnectionHandler.class_eval do
-
-      @@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
 
-        def establish_connection(owner, spec)
-          @class_to_pool.clear
-          owner_to_pool[owner.name] = connection_pool_class.new(spec)
-        end
-
-      elsif ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 2
-
-        def establish_connection(name, spec)
-          @class_to_pool[name] =
-            ( @connection_pools[spec] ||= connection_pool_class.new(spec) )
-        end
-
-      else # 2.3/3.0/3.1
-
-        def establish_connection(name, spec)
-          @connection_pools[name] = connection_pool_class.new(spec)
-        end
-
-      end
+require 'active_record/bogacs/version'
+require 'active_record/bogacs/autoload'
 
-    end
-  end
+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

@@ -0,0 +1,75 @@
+require 'active_record'
+require 'active_record/version'
+require 'active_record/connection_adapters/abstract/connection_pool'
+
+# NOTE: needs explicit configuration - before connection gets established e.g.
+#
+#   klass = ActiveRecord::Bogacs::FalsePool
+#   ActiveRecord::ConnectionAdapters::ConnectionHandler.connection_pool_class = klass
+#
+module ActiveRecord
+  module ConnectionAdapters
+    # @private there's no other way to change the pool class to use but to patch :(
+    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 > 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
+          owner_to_pool[owner.name] = connection_pool_class.new(spec)
+        end
+
+      elsif ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 2
+
+        def establish_connection(name, spec)
+          @class_to_pool[name] =
+            ( @connection_pools[spec] ||= connection_pool_class.new(spec) )
+        end
+
+      else # 2.3/3.0/3.1
+
+        def establish_connection(name, spec)
+          @connection_pools[name] = connection_pool_class.new(spec)
+        end
+
+      end
+
+    end
+  end
+end

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

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

@@ -4,7 +4,8 @@ module ActiveRecord
   module Bogacs
     class ShareablePool
 
-      class ConnectionSharingTest < TestBase
+      # TODO: ShareablePool is pretty much broken since 0.7 :
+      class ConnectionSharingTest #< TestBase
         include TestHelper
 
         def setup
@@ -170,7 +171,7 @@ module ActiveRecord
                 assert shared_connection?(conn)
                 conn
               end
-              
+
               assert_equal 5, shared_conns.uniq.size
 
               # still one left for normal connections :

data/test/active_record/bogacs/shareable_pool_helper.rb

@@ -70,7 +70,7 @@ module ActiveRecord
         end
 
         def self.shutdown
-          ActiveRecord::Base.connection_pool.disconnect!
+            ActiveRecord::Base.connection_pool.discard!
           ConnectionAdapters::ConnectionHandler.connection_pool_class = ConnectionAdapters::ConnectionPool
         end