activerecord-bogacs 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b0aec44c1b08bd47f913dcce2eba41e1d30b1fa0
-  data.tar.gz: a506eb318972490b316604732aded93e5079e5d7
+  metadata.gz: 3da20a4a7e44c77643b1cf11b949e5fb818d43ca
+  data.tar.gz: 4bd02da78f04b586079c01ef3d3429d13821337e
 SHA512:
-  metadata.gz: dc20088b6faeba8de52781af835d3cc078017bfcb7139b14e96d9f503fc3019340bbbe5fc0ae1ce8a000fb42a620a1fc3fda114b2dbe057f36d5e974ed892b28
-  data.tar.gz: 4600c5ed962dfb2682cc9f5911292442ac90951af19c3511d069b97175a5114f4c4f05de46bbfad25f5ed821c44388946b6336b84c4b636f08b498f57fae68b7
+  metadata.gz: bc86fe344a38859c20e2c41c4017a5d5e3d1c802a2879cc80376c8f9f286d7ec9496851217f98197869558edfb08aca4c37eab0c873a4b1538a6f2d1aadbd39b
+  data.tar.gz: 8de7842694c6ad26a9a904c0c8656dc5b1a6924771e3c8a106a53a917f82928a59bfec09123317c93813d89c9a009e1e99c392fa2549d0e6a23e71dc6c805a65

data/.travis.yml

@@ -5,7 +5,7 @@ jdk:
   - oraclejdk7
   - oraclejdk8
 rvm:
-  - jruby-1.7.22
+  - jruby-1.7.24
   #- 2.1.2
 before_install:
   - ((jruby -v | grep 1.8.7) && jruby --1.9 -S gem update --system 2.1.11) || true
@@ -29,35 +29,35 @@ matrix:
   #allow_failures:
     #- rvm: jruby-head
   exclude:
-    - rvm: jruby-1.7.22
+    - rvm: jruby-1.7.24
       env: JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=mysql AR_VERSION="~> 4.1.9" HIKARI_VERSION="2.3.12"
       jdk: oraclejdk7
-    - rvm: jruby-1.7.22
+    - rvm: jruby-1.7.24
       env: JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=postgresql AR_VERSION="~> 4.1.9" HIKARI_VERSION="2.3.2-java6"
       jdk: oraclejdk8
-    - rvm: jruby-1.7.22
+    - rvm: jruby-1.7.24
       env: JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=mysql AR_VERSION="~> 4.1.13" HIKARI_VERSION="2.0.1-java6"
       jdk: oraclejdk8
-    - rvm: jruby-1.7.22
+    - rvm: jruby-1.7.24
       env: JRUBY_OPTS="--1.8 $JRUBY_OPTS" AR_ADAPTER=mysql AR_VERSION="~> 3.2.18" HIKARI_VERSION="2.2.5-java6"
       jdk: oraclejdk8
   include:
-    - rvm: jruby-9.0.1.0
+    - rvm: jruby-9.0.5.0
       env: JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=mysql AR_VERSION="~> 4.1.13" HIKARI_VERSION="2.2.5-java6"
       jdk: oraclejdk7
-    - rvm: jruby-9.0.1.0
+    - rvm: jruby-9.1.2.0
       env: JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=mysql AR_VERSION="~> 3.2.18" HIKARI_VERSION="2.3.9"
       jdk: oraclejdk8
     # AR 4.2
     - rvm: jruby-1.7.22
       env: JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=mysql AR_VERSION="~> 4.1.13" HIKARI_VERSION="2.2.5-java6"
       jdk: oraclejdk7
-    - rvm: jruby-9.0.1.0
+    - rvm: jruby-9.1.2.0
       env: JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=mysql AR_VERSION="~> 4.2.4" HIKARI_VERSION="2.3.12"
       jdk: oraclejdk8
     - rvm: jruby-1.7.22
       env: JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=postgresql AR_VERSION="~> 4.2.4" HIKARI_VERSION="2.2.5-java6"
       jdk: oraclejdk8
-    - rvm: jruby-9.0.1.0
+    - rvm: jruby-9.0.5.0
       env: JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=postgresql AR_VERSION="~> 4.1.13" HIKARI_VERSION="2.3.12"
-      jdk: oraclejdk7
+      jdk: oraclejdk7

data/Gemfile

@@ -21,7 +21,7 @@ if RUBY_VERSION.index('1.8') == 0
   gem 'atomic', '1.1.16' # concurrent-ruby gem only for Ruby version >= 1.9.3
   gem 'thread_safe', '~> 0.3'
 else
-  gem 'concurrent-ruby', '1.0.0.pre4', :require => nil
+  gem 'concurrent-ruby', '~> 1.0.0', :require => nil
 end
 
 platform :jruby do

data/lib/active_record/bogacs.rb

@@ -9,6 +9,8 @@ module ActiveRecord
     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

data/lib/active_record/bogacs/default_pool.rb

@@ -51,7 +51,7 @@ module ActiveRecord
       # stdlib's doesn't support waiting with a timeout.
       # @private
       class Queue
-        def initialize(lock = Monitor.new)
+        def initialize(lock)
           @lock = lock
           @cond = @lock.new_cond
           @num_waiting = 0
@@ -177,36 +177,13 @@ module ActiveRecord
         end
       end
 
-      # Every +frequency+ seconds, the reaper will call +reap+ on +pool+.
-      # A reaper instantiated with a nil frequency will never reap the
-      # connection pool.
-      #
-      # Configure the frequency by setting "reaping_frequency" in your
-      # database yaml file.
-      class Reaper
-        attr_reader :pool, :frequency
-
-        def initialize(pool, frequency)
-          @pool = pool
-          @frequency = frequency
-        end
-
-        def run
-          return unless frequency
-          Thread.new(frequency, pool) { |t, p|
-            while true
-              sleep t
-              p.reap
-            end
-          }
-        end
-      end
-
       include PoolSupport
       include MonitorMixin # TODO consider avoiding ?!
 
+      require 'active_record/bogacs/reaper.rb'
+
       attr_accessor :automatic_reconnect, :checkout_timeout
-      attr_reader :spec, :connections, :size, :reaper
+      attr_reader :spec, :connections, :size, :reaper, :validator
       attr_reader :initial_size
 
       # Creates a new ConnectionPool object. +spec+ is a ConnectionSpecification
@@ -248,6 +225,14 @@ module ActiveRecord
         initial_size = (@size * initial_size).to_i if initial_size <= 1.0
         # NOTE: warn on onitial_size > size !
         prefill_initial_connections if ( @initial_size = initial_size.to_i ) > 0
+
+        if frequency = spec.config[:validate_frequency]
+          require 'active_record/bogacs/validator' unless self.class.const_defined?(:Validator)
+          @validator = Validator.new self, frequency, spec.config[:validate_timeout]
+          if @validator.run && @reaping
+            logger && logger.info("pool: validator configured alongside with reaper")
+          end
+        end
       end
 
       # Retrieve the connection associated with the current thread, or call
@@ -438,6 +423,16 @@ module ActiveRecord
       end
       # NOTE: active? and reset! are >= AR 2.3
 
+      def reaper?; (@reaper ||= nil) && @reaper.frequency end
+      def reaping?; reaper? && @reaper.running? end
+
+      def validator?; (@validator ||= nil) && @validator.frequency end
+      def validating?; validator? && @validator.running? end
+
+      #@@logger = nil
+      def logger; ::ActiveRecord::Base.logger end
+      #def logger=(logger); @@logger = logger end
+
       private
 
       # Acquire a connection by one of 1) immediately removing one
@@ -490,10 +485,6 @@ module ActiveRecord
         conns
       end
 
-      #@@logger = nil
-      def logger; ::ActiveRecord::Base.logger end
-      #def logger=(logger); @@logger = logger end
-
     end
 
   end

data/lib/active_record/bogacs/false_pool.rb

@@ -18,7 +18,7 @@ module ActiveRecord
 
         @spec = spec
         @size = nil
-        #@automatic_reconnect = true
+        @automatic_reconnect = nil
 
         @reserved_connections = ThreadSafe::Map.new #:initial_capacity => @size
       end
@@ -105,10 +105,7 @@ module ActiveRecord
       def verify_active_connections!
         synchronize do
           clear_stale_cached_connections!
-          connections = @reserved_connections.values
-          connections.each do |connection|
-            connection.verify!
-          end
+          @reserved_connections.values.each(&:verify!)
         end
       end if ActiveRecord::VERSION::MAJOR < 4
 
@@ -232,18 +229,19 @@ module ActiveRecord
       #  conn
       #end
 
+      TIMEOUT_ERROR = /timeout|timed.?out/i
+
       def timeout_error?(error)
         full_error = error.inspect
-        # sample on JRuby + Tomcat JDBC :
+        # Tomcat JDBC :
         # ActiveRecord::JDBCError(<The driver encountered an unknown error:
         #   org.apache.tomcat.jdbc.pool.PoolExhaustedException:
         #   [main] Timeout: Pool empty. Unable to fetch a connection in 2 seconds,
         #   none available[size:10; busy:10; idle:0; lastwait:2500].>
         # )
-        return true if full_error =~ /timeout/i
         # C3P0 :
         # java.sql.SQLException: An attempt by a client to checkout a Connection has timed out.
-        return true if full_error =~ /timed.?out/i
+        return true if full_error =~ TIMEOUT_ERROR
         # NOTE: not sure what to do on MRI and friends (C-pools not tested)
         false
       end

data/lib/active_record/bogacs/pool_support.rb

@@ -50,6 +50,10 @@ module ActiveRecord
               conn.expire
             end
           end
+        rescue => e
+          remove conn
+          conn.disconnect! rescue nil
+          raise e
         end
 
         def _run_checkout_callbacks(conn)
@@ -62,6 +66,10 @@ module ActiveRecord
               conn.verify!
             end
           end
+        rescue => e
+          remove conn
+          conn.disconnect! rescue nil
+          raise e
         end
 
       else

data/lib/active_record/bogacs/reaper.rb

@@ -0,0 +1,86 @@
+require 'thread'
+
+module ActiveRecord
+  module Bogacs
+
+    # Every +frequency+ seconds, the reaper will "reap" a pool it belongs to.
+    # Reaping means detecting stale cached connections in the pool - those that
+    # were checked-out by a thread but never checked back in after the thread
+    # finished/died.
+    #
+    # @note This version is fail safe - raised errors won't stop the reaping process.
+    # Instead the thread will be restarted and reaping continues at the next tick.
+    #
+    # Configure the frequency by setting `:reaping_frequency` in your database yaml file.
+    #
+    class Reaper
+
+      attr_reader :pool, :frequency
+      attr_accessor :retry_error
+
+      # Reaper.new(self, spec.config[:reaping_frequency]).run
+      # @private
+      def initialize(pool, frequency)
+        @pool = pool;
+        if frequency
+          frequency = frequency.to_f
+          @frequency = frequency > 0.0 ? frequency : false
+        else
+          @frequency = nil
+        end
+        @retry_error = 1.5; @running = nil
+      end
+
+      def run
+        return unless frequency
+        @running = true; start
+      end
+
+      def start(delay = nil)
+        Thread.new { exec(delay) }
+      end
+
+      def running?; @running end
+
+      private
+
+      def exec(delay = nil)
+        sleep delay if delay
+        while true
+          begin
+            sleep frequency
+            pool.reap
+          rescue => e
+            log = logger
+            if retry_delay = @retry_error
+              log && log.warn("[reaper] reaping failed: #{e.inspect} restarting after #{retry_delay}s")
+              start retry_delay
+            else
+              log && log.warn("[reaper] reaping failed: #{e.inspect} stopping reaper")
+              @running = false
+            end
+            break
+          end
+        end
+      end
+
+      def set_thread_name(name)
+        if ( thread = Thread.current ).respond_to?(:name)
+          thread.name = name; return
+        end
+        if defined? JRUBY_VERSION
+          thread = JRuby.reference(thread).getNativeThread
+          thread.setName("#{name} #{thread.getName}")
+        else
+          thread[:name] = name
+        end
+      end
+
+      def logger
+        @logger ||= ( pool.respond_to?(:logger) ? pool.logger : nil ) rescue nil
+      end
+
+    end
+
+  end
+end

data/lib/active_record/bogacs/validator.rb

@@ -0,0 +1,182 @@
+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 'active_record/connection_adapters/adapter_compat'
+require 'active_record/bogacs/thread_safe'
+
+module ActiveRecord
+  module Bogacs
+
+    # 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
+    # under heavy concurrent connection retrieval. Connections are also validated upon
+    # checkout - the validator is intended to detect long idle pooled connections "ahead
+    # of time" instead of upon retrieval.
+    #
+    class Validator
+
+      attr_reader :pool, :frequency, :timeout
+
+      # Validator.new(self, spec.config[:validate_frequency]).run
+      # @private
+      def initialize(pool, frequency = 60, timeout = nil)
+        @pool = pool; PoolAdaptor.adapt! pool
+        if frequency # validate every 60s by default
+          frequency = frequency.to_f
+          @frequency = frequency > 0.0 ? frequency : false
+        else
+          @frequency = nil
+        end
+        if timeout
+          timeout = timeout.to_f
+          @timeout = timeout > 0.0 ? timeout : 0
+        else
+          @timeout = @frequency
+        end
+        @running = nil
+      end
+
+      def run
+        return unless frequency
+        @running = true; start
+      end
+
+      TimerTask = ::Concurrent::TimerTask
+      private_constant :TimerTask rescue nil
+
+      def start
+        TimerTask.new(:execution_interval => frequency, :timeout_interval => timeout) do
+          validate_connections
+        end
+      end
+
+      def running?; @running end
+
+      def validate
+        start = Time.now
+        conns = connections
+        logger && logger.debug("[validator] found #{conns.size} candidates to validate")
+        invalid = 0
+        conns.each { |connection| invalid += 1 if validate_connection(connection) == false }
+        logger && logger.info("[validator] validated pool in #{Time.now - start}s (removed #{invalid} connections from pool)")
+        invalid
+      end
+
+      private
+
+      def connections
+        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)
+                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
+            else
+              conn # conn not in-use - candidate for validation
+            end
+          end
+        end
+        connections.compact
+      end
+
+      def validate_connection(conn)
+        return nil if conn.in_use?
+        pool.synchronize do # make sure it won't get checked-out while validating
+          return nil if conn.in_use?
+          # NOTE: active? is assumed to behave e.g. connection_alive_timeout used
+          # on AR-JDBC active? might return false as the JDBC connection is lazy
+          # ... but that is just fine!
+          begin
+            return true if conn.active? # validate the connection - ping the DB
+          rescue => e
+            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
+
+          logger && logger.debug("[validator] found non-active connection ##{conn.object_id} - removing from pool")
+          pool.remove_without_owner conn # not active - remove
+          conn.disconnect! rescue nil
+          return false
+        end
+      end
+
+      #def synchronize(&block); pool.synchronize(&block) end
+
+      def logger
+        @logger ||= ( pool.respond_to?(:logger) ? pool.logger : nil ) rescue nil
+      end
+
+      module PoolAdaptor
+
+        def self.adapt!(pool)
+          unless pool.class.include?(PoolAdaptor)
+            pool.class.send :include, PoolAdaptor
+          end
+
+          return if pool.respond_to?(:thread_cached_conns)
+
+          if pool.instance_variable_get :@reserved_connections
+            class << pool
+              attr_reader :reserved_connections
+              alias_method :thread_cached_conns, :reserved_connections
+            end
+          elsif pool.instance_variable_get :@thread_cached_conns
+            class << pool
+              attr_reader :thread_cached_conns
+            end
+          else
+            raise NotImplementedError, "could not adapt pool: #{pool}"
+          end
+        end
+
+        def cached_conn_owner_id(conn)
+          thread_cached_conns.keys.each do |owner_id|
+            if thread_cached_conns[ owner_id ] == conn
+              return owner_id
+            end
+          end
+          nil
+        end
+
+        def remove_without_owner(conn)
+          remove conn # release(conn, nil) owner.object_id should do fine
+          release_without_owner conn
+        end
+
+        def release_without_owner(conn)
+          if owner_id = cached_conn_owner_id(conn)
+            thread_cached_conns.delete owner_id; return true
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/active_record/bogacs/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Bogacs
-    VERSION = '0.4.1'
+    VERSION = '0.5.0'
   end
 end

data/lib/active_record/connection_adapters/adapter_compat.rb

@@ -6,7 +6,43 @@ module ActiveRecord
 
       attr_accessor :pool unless method_defined? :pool
 
-      unless method_defined? :owner
+      if method_defined? :owner # >= 4.2
+
+        attr_reader :last_use
+
+        if ActiveRecord::VERSION::MAJOR > 4
+
+          # @private added @last_use
+          def lease
+            if in_use?
+              msg = 'Cannot lease connection, '
+              if @owner == Thread.current
+                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}."
+              end
+              raise ActiveRecordError, msg
+            end
+
+            @owner = Thread.current; @last_use = Time.now
+          end
+
+        else
+
+          # @private removed synchronization + added @last_use
+          def lease
+            if in_use?
+              if @owner == Thread.current
+                # NOTE: could do a warning if 4.2.x cases do not end up here ...
+              end
+            else
+              @owner = Thread.current; @last_use = Time.now
+            end
+          end
+
+        end
+
+      else
 
         attr_reader :owner
 

data/test/active_record/bogacs/default_pool_test.rb

@@ -29,6 +29,35 @@ module ActiveRecord
         assert_equal 0, @pool.connections.size
       end
 
+      def test_connection_removed_connection_on_checkout_failure
+        connection = nil
+
+        Thread.new {
+          pool.with_connection do |conn|
+            connection = conn
+          end
+        }.join
+
+        assert connection
+        assert_equal 1, pool.connections.size
+
+        bad_connection = connection
+        def bad_connection.verify!
+          raise ThreadError, 'corrupted-connection'
+        end
+
+        begin
+          connection = pool.connection
+        rescue ThreadError
+        else; warn 'verify! error not raised'
+        end
+        assert_equal 0, pool.connections.size # gets removed from pool
+
+        connection = pool.connection
+        assert bad_connection != connection, 'bad connection returned on checkout'
+
+      end if ActiveRecord::VERSION::STRING > '4.2'
+
       def self.startup; puts "running with ActiveRecord: #{ActiveRecord::VERSION::STRING}" end
 
     end

data/test/active_record/bogacs/reaper_test.rb

@@ -0,0 +1,86 @@
+require File.expand_path('../../test_helper', File.dirname(__FILE__))
+require 'stringio'
+
+module ActiveRecord
+  module Bogacs
+    class ReaperTest < Test::Unit::TestCase
+
+      def self.startup
+        super; require 'active_record/bogacs/reaper'
+        Reaper.const_set :Thread, AbortiveThread
+      end
+
+      def config; AR_CONFIG end
+
+      def setup
+        super
+        ActiveRecord::Base.establish_connection config.merge :reaping_frequency => 0.25
+        @pool = DefaultPool.new ActiveRecord::Base.connection_pool.spec
+      end
+
+      def teardown; @pool.disconnect! if (@pool ||= nil) end
+
+      def test_null_reaper
+        ActiveRecord::Base.establish_connection config.merge :reaping_frequency => false
+        pool = DefaultPool.new ActiveRecord::Base.connection_pool.spec
+
+        assert ! pool.reaper?
+        sleep 0.1
+        assert ! pool.reaping?
+      end
+
+      def test_parse_frequency
+        ActiveRecord::Base.establish_connection config.merge :reaping_frequency => '0'
+        pool = DefaultPool.new ActiveRecord::Base.connection_pool.spec
+
+        assert ! pool.reaper?
+        sleep 0.1
+        assert ! pool.reaping?
+
+        assert ! Reaper.new(pool, '').frequency
+        assert_equal 5, Reaper.new(pool, '5').frequency
+        assert_equal 5.5, Reaper.new(pool, '5.5').frequency
+      end
+
+      def test_reaper?
+        assert @pool.reaper?
+        sleep 0.1
+        assert @pool.reaping?
+      end
+
+      def test_reap_error_restart
+        logger = Logger.new str = StringIO.new
+        @pool.reaper.instance_variable_set :@logger, logger
+        def @pool.reap; raise RuntimeError, 'test_reap_error' end
+
+        assert @pool.reaper?
+        sleep 0.3
+        assert_true @pool.reaping?
+        assert_match /WARN.*reaping failed:.* test_reap_error.* restarting after/, str.string
+      end
+
+      def test_reap_error_stop
+        logger = Logger.new str = StringIO.new
+        @pool.reaper.instance_variable_set :@logger, logger
+        @pool.reaper.retry_error = false
+        def @pool.reap; raise 'test_reap_error2' end
+
+        assert @pool.reaper?
+        sleep 0.3
+        assert_false @pool.reaping?
+        assert_match /WARN.*reaping failed:.* test_reap_error2.* stopping/, str.string
+      end
+
+      private
+
+      class AbortiveThread < Thread
+
+        def self.new(*args, &block)
+          super.tap { |thread| thread.abort_on_exception = true }
+        end
+
+      end
+
+    end
+  end
+end

data/test/active_record/bogacs/validator_test.rb

@@ -0,0 +1,248 @@
+require File.expand_path('../../test_helper', File.dirname(__FILE__))
+require 'stringio'
+
+module ActiveRecord
+  module Bogacs
+    class ValidatorTest < Test::Unit::TestCase
+
+      def self.startup
+        ConnectionAdapters::ConnectionHandler.connection_pool_class = DefaultPool
+      end
+
+      def self.shutdown
+        ConnectionAdapters::ConnectionHandler.connection_pool_class = nil
+      end
+
+      def config; AR_CONFIG end
+
+      def teardown; @pool.disconnect! if (@pool ||= nil) end
+
+      def test_null_validator
+        pool = new_pool :validate_frequency => nil
+
+        assert ! pool.validator?
+        sleep 0.05
+        assert ! pool.validating?
+      end
+
+      def test_parse_frequency
+        pool = new_pool :validate_frequency => '0'
+
+        assert ! pool.validator?
+        sleep 0.05
+        assert ! pool.validating?
+
+        assert ! Validator.new(pool, '').frequency
+        assert_equal 50, Validator.new(pool, '50').frequency
+        assert_equal 5.5, Validator.new(pool, '5.5').frequency
+      end
+
+      def test_validator?
+        assert pool.validator?
+        sleep 0.1
+        assert pool.validating?
+      end
+
+      require 'concurrent/atomic/atomic_fixnum.rb'
+      AtomicFixnum = ::Concurrent::AtomicFixnum
+
+      require 'concurrent/atomic/semaphore.rb'
+      Semaphore = ::Concurrent::Semaphore
+
+      def test_selects_non_used_connections
+        assert_equal [], validator.send(:connections)
+
+        count = AtomicFixnum.new
+        semaphore = Semaphore.new(2); semaphore.drain_permits
+        Thread.new {
+          pool.with_connection { |conn| assert conn; count.increment; semaphore.acquire }
+        }
+        Thread.new {
+          pool.with_connection { |conn| assert conn; count.increment; semaphore.acquire }
+        }
+        while count.value < 2; sleep 0.01 end
+
+        released_conn = nil
+        Thread.new {
+          pool.with_connection { |conn| assert released_conn = conn }
+        }.join
+
+
+        assert_equal 3, pool.connections.size
+        assert_equal 1, validator.send(:connections).size
+        assert_equal [ released_conn ], validator.send(:connections)
+
+        semaphore.release 2
+      end
+
+      def test_auto_removes_stale_connection_from_pool_when_collecting_connections_to_validate
+        conn = connection
+
+        assert_equal [], validator.send(:connections)
+
+        count = AtomicFixnum.new
+        semaphore = Semaphore.new(2); semaphore.drain_permits
+        Thread.new {
+          pool.with_connection { |conn| assert conn; count.increment; semaphore.acquire }
+        }
+        stale_conn = nil
+        Thread.new {
+          assert stale_conn = pool.connection; count.increment; semaphore.acquire
+        }
+        while count.value < 2; sleep 0.01 end
+
+        returned_conn = nil
+        Thread.new {
+          pool.with_connection { |conn| assert returned_conn = conn }
+        }.join
+
+        assert_equal 4, pool.connections.size
+        validate_candidates = validator.send(:connections)
+        assert_equal [ returned_conn ], validate_candidates
+        assert_equal 4, pool.connections.size
+
+        semaphore.release(2); sleep 0.05
+
+        validate_candidates = validator.send(:connections)
+        assert_equal 2, validate_candidates.size
+        assert validate_candidates.include?(returned_conn)
+        assert ! validate_candidates.include?(stale_conn)
+        assert_equal 3, pool.connections.size
+        assert ! pool.connections.map(&:object_id).include?(stale_conn.object_id)
+     end
+
+      def test_validate_connection
+        conn = connection; pool.remove conn
+        conn.expire; assert ! conn.in_use?
+        # lazy on AR-JDBC :
+        conn.tables; assert conn.active?
+
+        def conn.active_called?; @_active_called ||= false end
+        def conn.active?; @_active_called = true; super end
+
+        result = validator.send :validate_connection, conn
+        assert_true result
+
+        assert conn.active_called?
+      end
+
+      def test_validate_connection_non_valid
+        conn = connection; pool.remove conn
+        conn.expire; assert ! conn.in_use?
+
+        def conn.active?; false end
+
+        result = validator.send :validate_connection, conn
+        assert_false result
+     end
+
+      def test_validate_connection_in_use
+        conn = connection
+        assert  conn.in_use?
+        def conn.active?; raise 'active? should not be called for a used connection' end
+
+        result = validator.send :validate_connection, conn
+        assert_nil result
+      end
+
+      def test_validate_connection_removes_invalid_connection_from_pool
+        conn = connection
+        puts pool.connections.map(&:object_id).inspect
+        Thread.new { pool.with_connection { |conn| assert conn } }.join
+        puts pool.connections.map(&:object_id).inspect
+        assert_equal 2, pool.connections.size
+
+        conn.expire; assert ! conn.in_use?
+
+        def conn.active?; false end
+
+        result = validator.send :validate_connection, conn
+        assert_false result
+
+        assert_equal 1, pool.connections.size
+        assert ! pool.connections.include?(conn)
+      end
+
+      def test_validate_connection_considers_raising_connection_invalid
+        conn = connection; threads = []
+        threads << Thread.new { pool.with_connection { |conn| assert conn; thread_work(conn) } }
+        threads << Thread.new { pool.with_connection { |conn| assert conn; thread_work(conn) } }
+        threads.each(&:join)
+        assert_equal 3, pool.connections.size
+
+        conn.expire; assert ! conn.in_use?
+        assert pool.connections.include?(conn)
+
+        def conn.active?; raise 'a failing active? check' end
+        def conn.disconnect!; raise 'failing disconnect!' end
+
+        result = validator.send :validate_connection, conn
+        assert_false result
+
+        assert_equal 2, pool.connections.size
+        assert ! pool.connections.include?(conn)
+      end
+
+
+      def test_validate_returns_invalid_connection_count
+        conn = connection; threads = []; invalid_conns = []
+        threads << Thread.new { pool.with_connection { |conn| thread_work(conn, 0.05) } }
+        threads << Thread.new { pool.with_connection { |conn| thread_work(conn, 0.05); conn.expire; invalid_conns << conn } }
+        threads << Thread.new { pool.with_connection { |conn| thread_work(conn, 0.05) } }
+        threads << Thread.new { pool.with_connection { |conn| thread_work(conn, 0.05); conn.expire; invalid_conns << conn } }
+        threads.each(&:join)
+        assert_equal 5, pool.connections.size
+
+        invalid_conns.each { |conn| def conn.active?; false end }
+
+        result = validator.validate
+        assert_equal 2, result
+        assert_equal 3, pool.connections.size
+
+        conn.expire
+        result = validator.validate
+        assert_equal 0, result
+        assert_equal 3, pool.connections.size
+      end
+
+      private
+
+      def connection
+        pool; ActiveRecord::Base.connection
+      end
+
+      def validator; pool.validator end
+
+      def pool
+        # self.startup: connection_pool_class = DefaultPool
+        @pool ||= (establish_connection; Base.connection_pool)
+      end
+
+      DEFAULT_OPTS = { :size => 5, :validate_frequency => 1 }
+
+      def establish_connection(opts = DEFAULT_OPTS)
+        ActiveRecord::Base.establish_connection config.merge opts
+      end
+
+      def new_pool(opts = DEFAULT_OPTS)
+        establish_connection config.merge opts
+        DefaultPool.new Base.connection_pool.spec
+      end
+
+      def thread_work(conn, sleep = 0.1)
+        Thread.current.abort_on_exception = true
+        conn.tables; sleep(sleep) if sleep
+      end
+
+      class TimerTaskStub
+
+        # :execution_interval => frequency, :timeout_interval => timeout
+        def self.new(opts, &block)
+          raise 'noop'
+        end
+
+      end
+
+    end
+  end
+end

data/test/active_record/connection_pool_test_methods.rb

@@ -20,7 +20,8 @@ module ActiveRecord
         connection.close
         assert ! connection.in_use?
 
-        assert pool.connection.in_use?
+        assert_equal connection, pool.connection
+        # assert pool.connection.in_use?
       end
 
       def test_released_connection_moves_between_threads

data/test/test_helper.rb

@@ -35,9 +35,9 @@ ActiveRecord::Base.logger = Logger.new(STDOUT)
 #  ActiveRecord::ConnectionAdapters::ConnectionHandler.connection_pool_class = pool_class
 #end
 
-config = { :'adapter' => ENV['AR_ADAPTER'] || 'sqlite3' }
-config[:'username'] = ENV['AR_USERNAME'] if ENV['AR_USERNAME']
-config[:'password'] = ENV['AR_PASSWORD'] if ENV['AR_PASSWORD']
+config = { :adapter => ENV['AR_ADAPTER'] || 'sqlite3' }
+config[:username] = ENV['AR_USERNAME'] if ENV['AR_USERNAME']
+config[:password] = ENV['AR_PASSWORD'] if ENV['AR_PASSWORD']
 if url = ENV['AR_URL'] || ENV['JDBC_URL']
   config[:'url'] = url
 else
@@ -51,7 +51,7 @@ config[:'connect_timeout'] = connect_timeout
 prepared_statements = ENV['AR_PREPARED_STATEMENTS'] # || true
 config[:'prepared_statements'] = prepared_statements if prepared_statements
 #jdbc_properties = { 'logUnclosedConnections' => true, 'loginTimeout' => 5 }
-#config['properties'] = jdbc_properties
+#config[:'properties'] = jdbc_properties
 
 checkout_timeout = ENV['AR_POOL_CHECKOUT_TIMEOUT'] || checkout_timeout
 config[:'checkout_timeout'] = checkout_timeout.to_f if checkout_timeout
@@ -404,6 +404,9 @@ module ActiveRecord
           if ar_jdbc_config[:password]
             hikari_config.addDataSourceProperty 'password', ar_jdbc_config[:password]
           end
+          ( ar_jdbc_config[:properties] || {} ).each do |name, val|
+            hikari_config.addDataSourceProperty name.to_s, val.to_s
+          end
         when /postgres/i
           hikari_config.setDataSourceClassName 'org.postgresql.ds.PGSimpleDataSource'
           hikari_config.addDataSourceProperty 'serverName', ar_jdbc_config[:host] || 'localhost'
@@ -415,12 +418,16 @@ module ActiveRecord
           if ar_jdbc_config[:password]
             hikari_config.addDataSourceProperty 'password', ar_jdbc_config[:password]
           end
+          ( ar_jdbc_config[:properties] || {} ).each do |name, val|
+            hikari_config.addDataSourceProperty name.to_s, val.to_s
+          end
         else
           hikari_config.setDriverClassName driver
           hikari_config.setJdbcUrl ar_jdbc_config[:url]
           hikari_config.setUsername ar_jdbc_config[:username] if ar_jdbc_config[:username]
           hikari_config.setPassword ar_jdbc_config[:password] if ar_jdbc_config[:password]
         end
+        hikari_config.setJdbcUrl ar_jdbc_config[:url] if ar_jdbc_config[:url]
 
         # TODO: we shall handle raw properties ?!
         #if ar_jdbc_config[:properties]

metadata

@@ -1,57 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-bogacs
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Karol Bucek
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-11-02 00:00:00.000000000 Z
+date: 2016-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: concurrent-ruby
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0.9'
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.9'
+  name: concurrent-ruby
   prerelease: false
   type: :development
-- !ruby/object:Gem::Dependency
-  name: rake
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.3'
+        version: '0.9'
+- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.3'
+  name: rake
   prerelease: false
   type: :development
-- !ruby/object:Gem::Dependency
-  name: test-unit
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '10.3'
+- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.5'
+  name: test-unit
   prerelease: false
   type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
 description: Improved ActiveRecord::ConnectionAdapters::ConnectionPool alternatives
 email:
 - self@kares.org
@@ -59,8 +59,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -70,17 +70,21 @@ files:
 - lib/active_record/bogacs/default_pool.rb
 - lib/active_record/bogacs/false_pool.rb
 - lib/active_record/bogacs/pool_support.rb
+- lib/active_record/bogacs/reaper.rb
 - lib/active_record/bogacs/shareable_pool.rb
 - lib/active_record/bogacs/thread_safe.rb
 - lib/active_record/bogacs/thread_safe/synchronized.rb
+- lib/active_record/bogacs/validator.rb
 - lib/active_record/bogacs/version.rb
 - lib/active_record/connection_adapters/adapter_compat.rb
 - lib/active_record/shared_connection.rb
 - test/active_record/bogacs/default_pool_test.rb
 - test/active_record/bogacs/false_pool_test.rb
+- test/active_record/bogacs/reaper_test.rb
 - test/active_record/bogacs/shareable_pool/connection_pool_test.rb
 - test/active_record/bogacs/shareable_pool/connection_sharing_test.rb
 - test/active_record/bogacs/shareable_pool_helper.rb
+- test/active_record/bogacs/validator_test.rb
 - test/active_record/builtin_pool_test.rb
 - test/active_record/connection_pool_test_methods.rb
 - test/test_helper.rb
@@ -94,12 +98,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
@@ -114,9 +118,11 @@ summary: 'Bogacs contains several pool implementations that can be used as a rep
 test_files:
 - test/active_record/bogacs/default_pool_test.rb
 - test/active_record/bogacs/false_pool_test.rb
+- test/active_record/bogacs/reaper_test.rb
 - test/active_record/bogacs/shareable_pool/connection_pool_test.rb
 - test/active_record/bogacs/shareable_pool/connection_sharing_test.rb
 - test/active_record/bogacs/shareable_pool_helper.rb
+- test/active_record/bogacs/validator_test.rb
 - test/active_record/builtin_pool_test.rb
 - test/active_record/connection_pool_test_methods.rb
 - test/test_helper.rb