activerecord-bogacs 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1f7c9f5688cb27fb4c84bea3a516d1d2d014fb1c
-  data.tar.gz: 17a6269479cb432bda7d027c0d89586c6cecaa19
+  metadata.gz: b0aec44c1b08bd47f913dcce2eba41e1d30b1fa0
+  data.tar.gz: a506eb318972490b316604732aded93e5079e5d7
 SHA512:
-  metadata.gz: 1ad54c3ab7af8f4edbc2fea17cba7f1d32d784d4107ba8fe186e58fed676dd30f61b91bef610d3912b9f0bc1022286b39366b8b605228ba9e2c38939f155910b
-  data.tar.gz: 8dffdfc6857d604ab66931b0a30eca0d6e5b5d9fd148ec1dcb73721dd29cf338de3744730974581cb4f624e1cf402e2c1790357201310904e8cdef8787be7d54
+  metadata.gz: dc20088b6faeba8de52781af835d3cc078017bfcb7139b14e96d9f503fc3019340bbbe5fc0ae1ce8a000fb42a620a1fc3fda114b2dbe057f36d5e974ed892b28
+  data.tar.gz: 4600c5ed962dfb2682cc9f5911292442ac90951af19c3511d069b97175a5114f4c4f05de46bbfad25f5ed821c44388946b6336b84c4b636f08b498f57fae68b7

data/.travis.yml

@@ -22,7 +22,7 @@ script:
 env:
   - JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=mysql AR_VERSION="~> 4.1.9" HIKARI_VERSION="2.3.12"
   - JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=postgresql AR_VERSION="~> 4.1.9" HIKARI_VERSION="2.3.2-java6"
-  - JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=mysql AR_VERSION="~> 4.1.9" HIKARI_VERSION="2.0.1-java6"
+  - JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=mysql AR_VERSION="~> 4.1.11" HIKARI_VERSION="2.0.1-java6"
   - JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=postgresql AR_VERSION="~> 3.2.18" HIKARI_VERSION="1.4.0"
   - JRUBY_OPTS="--1.8 $JRUBY_OPTS" AR_ADAPTER=mysql AR_VERSION="~> 3.2.18" HIKARI_VERSION="2.2.5-java6"
 matrix:
@@ -36,15 +36,28 @@ matrix:
       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
-      env: JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=mysql AR_VERSION="~> 4.1.9" HIKARI_VERSION="2.0.1-java6"
+      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
       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
-      env: JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=mysql AR_VERSION="~> 4.1.9" HIKARI_VERSION="2.2.5-java6"
+      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
       env: JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=mysql AR_VERSION="~> 3.2.18" HIKARI_VERSION="2.3.9"
-      jdk: oraclejdk8
+      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
+      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
+      env: JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=postgresql AR_VERSION="~> 4.1.13" HIKARI_VERSION="2.3.12"
+      jdk: oraclejdk7

data/lib/active_record/bogacs/default_pool.rb

@@ -33,14 +33,16 @@ module ActiveRecord
     # There are several connection-pooling-related options that you can add to
     # your database connection configuration:
     #
-    # * +pool+: number indicating size of connection pool (default 5)
-    # * +checkout_timeout+: number of seconds to block and wait for a connection
+    # * **pool**: number indicating size of connection pool (default 5)
+    # * **checkout_timeout**: number of seconds to block and wait for a connection
     # before giving up and raising a timeout error (default 5 seconds).
-    # * +reaping_frequency+: frequency in seconds to periodically run the
-    # Reaper, which attempts to find and close dead connections, which can
-    # occur if a programmer forgets to close a connection at the end of a
-    # thread or a thread dies unexpectedly. (Default nil, which means don't
-    # run the Reaper - reaping will still happen occasionally).
+    # * **pool_initial**: number of connections to pre-initialize when the pool
+    # is created (default 0).
+    # * **reaping_frequency**: frequency in seconds to periodically run a reaper,
+    # which attempts to find and close "dead" connections (can occur if a caller
+    # forgets to close a connection at the end of a thread or a thread dies unexpectedly)
+    # Default is `nil`, which means don't run the periodical Reaper at all (reaping
+    # will still happen occasionally).
     class DefaultPool
       # Threadsafe, fair, FIFO queue. Meant to be used by ConnectionPool
       # with which it shares a Monitor. But could be a generic Queue.
@@ -158,7 +160,7 @@ module ActiveRecord
 
           yield if block_given?
 
-          loop do
+          while true
             @cond.wait(timeout - elapsed)
 
             return remove if any?
@@ -227,8 +229,8 @@ module ActiveRecord
         if spec.config[:pool]
           @size = spec.config[:pool].to_i
         else
-          if defined? Rails.env && Rails.env.production?
-            logger && logger.debug("pool: option not set, using a default = 5")
+          if defined? Rails.env && ( (! Rails.env.development? && ! Rails.env.test?) rescue nil )
+            logger && logger.debug("pool: option not set, using default size: 5")
           end
           @size = 5
         end
@@ -253,6 +255,8 @@ module ActiveRecord
       #
       # #connection can be called any number of times; the connection is
       # held in a hash keyed by the thread id.
+      #
+      # @return [ActiveRecord::ConnectionAdapters::AbstractAdapter]
       def connection
         connection_id = current_connection_id
         unless conn = @reserved_connections.fetch(connection_id, nil)
@@ -264,6 +268,8 @@ module ActiveRecord
       end
 
       # Is there an open connection that is being used for the current thread?
+      #
+      # @return [true, false]
       def active_connection?
         connection_id = current_connection_id
         if conn = @reserved_connections.fetch(connection_id, nil)
@@ -286,6 +292,8 @@ module ActiveRecord
       # If a connection already exists yield it to the block. If no connection
       # exists checkout a connection, yield it to the block, and checkin the
       # connection when finished.
+      #
+      # @yield [ActiveRecord::ConnectionAdapters::AbstractAdapter]
       def with_connection
         connection_id = current_connection_id
         fresh_connection = true unless active_connection?
@@ -295,6 +303,8 @@ module ActiveRecord
       end
 
       # Returns true if a connection has already been opened.
+      #
+      # @return [true, false]
       def connected?
         @connections.size > 0 # synchronize { @connections.any? }
       end
@@ -344,6 +354,7 @@ module ActiveRecord
 
       # Return any checked-out connections back to the pool by threads that
       # are no longer alive.
+      # @private AR 3.2 compatibility
       def clear_stale_cached_connections!
         keys = Thread.list.find_all { |t| t.alive? }.map(&:object_id)
         keys = @reserved_connections.keys - keys
@@ -354,60 +365,58 @@ module ActiveRecord
         end
       end if ActiveRecord::VERSION::MAJOR < 4
 
-      # Check-out a database connection from the pool, indicating that you want
-      # to use it. You should call #checkin when you no longer need this.
+      # Check-out a database connection from the pool, callers are expected to
+      # call #checkin when the connection is no longer needed, so that others
+      # can use it.
       #
       # This is done by either returning and leasing existing connection, or by
       # creating a new connection and leasing it.
       #
-      # If all connections are leased and the pool is at capacity (meaning the
-      # number of currently leased connections is greater than or equal to the
-      # size limit set), an ActiveRecord::ConnectionTimeoutError exception will be raised.
-      #
-      # Returns: an AbstractAdapter object.
-      #
-      # Raises:
-      # - ConnectionTimeoutError: no connection can be obtained from the pool.
+      # @return [ActiveRecord::ConnectionAdapters::AbstractAdapter]
+      # @raise [ActiveRecord::ConnectionTimeoutError] if all connections are leased
+      # and the pool is at capacity (meaning the number of currently leased
+      # connections is greater than or equal to the size limit set)
       def checkout
+        conn = nil
         synchronize do
           conn = acquire_connection
           conn.lease
-          checkout_and_verify(conn)
         end
+        checkout_and_verify(conn)
       end
 
-      # Check-in a database connection back into the pool, indicating that you
-      # no longer need this connection.
+      # Check-in a database connection back into the pool.
       #
-      # +conn+: an AbstractAdapter object, which was obtained by earlier by
-      # calling +checkout+ on this pool.
+      # @param [ActiveRecord::ConnectionAdapters::AbstractAdapter] connection
+      # object, which was obtained earlier by calling #checkout on this pool
+      # @see #checkout
       def checkin(conn, released = nil)
         synchronize do
-          conn.run_callbacks :checkin do
-            conn.expire
-          end
+          _run_checkin_callbacks(conn)
 
-          release conn.owner unless released
+          release conn, conn.owner unless released
 
           @available.add conn
         end
       end
 
-      # Remove a connection from the connection pool. The connection will
-      # remain open and active but will no longer be managed by this pool.
+      # Remove a connection from the connection pool. The returned connection
+      # will remain open and active but will no longer be managed by this pool.
+      #
+      # @return [ActiveRecord::ConnectionAdapters::AbstractAdapter]
       def remove(conn)
         synchronize do
           @connections.delete conn
           @available.delete conn
 
-          release conn.owner
+          release conn, conn.owner
 
           @available.add checkout_new_connection if @available.any_waiting?
         end
       end
 
       # Recover lost connections for the pool. A lost connection can occur if
-      # a programmer forgets to checkin a connection at the end of a thread
+      # a caller forgets to #checkin a connection for a given thread when its done
       # or a thread dies unexpectedly.
       def reap
         stale_connections = synchronize do
@@ -449,25 +458,25 @@ module ActiveRecord
         end
       end
 
-      def release(owner)
+      def release(conn, owner)
         thread_id = owner.object_id
-        @reserved_connections.delete thread_id
+        if @reserved_connections[thread_id] == conn
+          @reserved_connections.delete thread_id
+        end
       end
 
       def checkout_new_connection
         raise ConnectionNotEstablished unless @automatic_reconnect
 
-        c = new_connection
-        c.pool = self
-        @connections << c
-        c
+        conn = new_connection
+        conn.pool = self
+        @connections << conn
+        conn
       end
 
-      def checkout_and_verify(c)
-        c.run_callbacks :checkout do
-          c.verify!
-        end
-        c
+      def checkout_and_verify(conn)
+        _run_checkout_callbacks(conn)
+        conn
       end
 
       def prefill_initial_connections
@@ -481,189 +490,11 @@ module ActiveRecord
         conns
       end
 
-      def logger
-        ActiveRecord::Base.logger
-      end
-
-    end
-
-=begin
-
-    # ConnectionHandler is a collection of ConnectionPool objects. It is used
-    # for keeping separate connection pools for Active Record models that connect
-    # to different databases.
-    #
-    # For example, suppose that you have 5 models, with the following hierarchy:
-    #
-    # |
-    # +-- Book
-    # | |
-    # | +-- ScaryBook
-    # | +-- GoodBook
-    # +-- Author
-    # +-- BankAccount
-    #
-    # Suppose that Book is to connect to a separate database (i.e. one other
-    # than the default database). Then Book, ScaryBook and GoodBook will all use
-    # the same connection pool. Likewise, Author and BankAccount will use the
-    # same connection pool. However, the connection pool used by Author/BankAccount
-    # is not the same as the one used by Book/ScaryBook/GoodBook.
-    #
-    # Normally there is only a single ConnectionHandler instance, accessible via
-    # ActiveRecord::Base.connection_handler. Active Record models use this to
-    # determine the connection pool that they should use.
-    class ConnectionHandler
-      def initialize
-        # These caches are keyed by klass.name, NOT klass. Keying them by klass
-        # alone would lead to memory leaks in development mode as all previous
-        # instances of the class would stay in memory.
-        @owner_to_pool = ThreadSafe::Cache.new(:initial_capacity => 2) do |h,k|
-          h[k] = ThreadSafe::Cache.new(:initial_capacity => 2)
-        end
-        @class_to_pool = ThreadSafe::Cache.new(:initial_capacity => 2) do |h,k|
-          h[k] = ThreadSafe::Cache.new
-        end
-      end
-
-      def connection_pool_list
-        owner_to_pool.values.compact
-      end
-
-      def connection_pools
-        ActiveSupport::Deprecation.warn(
-          "In the next release, this will return the same as #connection_pool_list. " \
-          "(An array of pools, rather than a hash mapping specs to pools.)"
-        )
-        Hash[connection_pool_list.map { |pool| [pool.spec, pool] }]
-      end
-
-      def establish_connection(owner, spec)
-        @class_to_pool.clear
-        raise RuntimeError, "Anonymous class is not allowed." unless owner.name
-        owner_to_pool[owner.name] = ConnectionAdapters::ConnectionPool.new(spec)
-      end
-
-      # Returns true if there are any active connections among the connection
-      # pools that the ConnectionHandler is managing.
-      def active_connections?
-        connection_pool_list.any?(&:active_connection?)
-      end
-
-      # Returns any connections in use by the current thread back to the pool,
-      # and also returns connections to the pool cached by threads that are no
-      # longer alive.
-      def clear_active_connections!
-        connection_pool_list.each(&:release_connection)
-      end
-
-      # Clears the cache which maps classes.
-      def clear_reloadable_connections!
-        connection_pool_list.each(&:clear_reloadable_connections!)
-      end
-
-      def clear_all_connections!
-        connection_pool_list.each(&:disconnect!)
-      end
+      #@@logger = nil
+      def logger; ::ActiveRecord::Base.logger end
+      #def logger=(logger); @@logger = logger end
 
-      # Locate the connection of the nearest super class. This can be an
-      # active or defined connection: if it is the latter, it will be
-      # opened and set as the active connection for the class it was defined
-      # for (not necessarily the current class).
-      def retrieve_connection(klass) #:nodoc:
-        pool = retrieve_connection_pool(klass)
-        (pool && pool.connection) or raise ConnectionNotEstablished
-      end
-
-      # Returns true if a connection that's accessible to this class has
-      # already been opened.
-      def connected?(klass)
-        conn = retrieve_connection_pool(klass)
-        conn && conn.connected?
-      end
-
-      # Remove the connection for this class. This will close the active
-      # connection and the defined connection (if they exist). The result
-      # can be used as an argument for establish_connection, for easily
-      # re-establishing the connection.
-      def remove_connection(owner)
-        if pool = owner_to_pool.delete(owner.name)
-          @class_to_pool.clear
-          pool.automatic_reconnect = false
-          pool.disconnect!
-          pool.spec.config
-        end
-      end
-
-      # Retrieving the connection pool happens a lot so we cache it in @class_to_pool.
-      # This makes retrieving the connection pool O(1) once the process is warm.
-      # When a connection is established or removed, we invalidate the cache.
-      #
-      # Ideally we would use #fetch here, as class_to_pool[klass] may sometimes be nil.
-      # However, benchmarking (https://gist.github.com/jonleighton/3552829) showed that
-      # #fetch is significantly slower than #[]. So in the nil case, no caching will
-      # take place, but that's ok since the nil case is not the common one that we wish
-      # to optimise for.
-      def retrieve_connection_pool(klass)
-        class_to_pool[klass.name] ||= begin
-          until pool = pool_for(klass)
-            klass = klass.superclass
-            break unless klass <= Base
-          end
-
-          class_to_pool[klass.name] = pool
-        end
-      end
-
-      private
-
-      def owner_to_pool
-        @owner_to_pool[Process.pid]
-      end
-
-      def class_to_pool
-        @class_to_pool[Process.pid]
-      end
-
-      def pool_for(owner)
-        owner_to_pool.fetch(owner.name) {
-          if ancestor_pool = pool_from_any_process_for(owner)
-            # A connection was established in an ancestor process that must have
-            # subsequently forked. We can't reuse the connection, but we can copy
-            # the specification and establish a new connection with it.
-            establish_connection owner, ancestor_pool.spec
-          else
-            owner_to_pool[owner.name] = nil
-          end
-        }
-      end
-
-      def pool_from_any_process_for(owner)
-        owner_to_pool = @owner_to_pool.values.find { |v| v[owner.name] }
-        owner_to_pool && owner_to_pool[owner.name]
-      end
     end
 
-    class ConnectionManagement
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        testing = env.key?('rack.test')
-
-        response = @app.call(env)
-        response[2] = ::Rack::BodyProxy.new(response[2]) do
-          ActiveRecord::Base.clear_active_connections! unless testing
-        end
-
-        response
-      rescue Exception
-        ActiveRecord::Base.clear_active_connections! unless testing
-        raise
-      end
-    end
-
-=end
-
   end
 end

data/lib/active_record/bogacs/false_pool.rb

@@ -144,7 +144,7 @@ module ActiveRecord
         #synchronize do
           conn = checkout_new_connection # acquire_connection
           conn.lease
-          conn.run_callbacks(:checkout) { conn.verify! } # checkout_and_verify(conn)
+          _run_checkout_callbacks(conn) # checkout_and_verify(conn)
           conn
         #end
       end
@@ -157,7 +157,7 @@ module ActiveRecord
       def checkin(conn, do_release = true)
         release(conn) if do_release
         #synchronize do
-          conn.run_callbacks(:checkin) { conn.expire }
+          _run_checkin_callbacks(conn)
           #release conn
           #@available.add conn
         #end

data/lib/active_record/bogacs/pool_support.rb

@@ -36,6 +36,50 @@ module ActiveRecord
         end
       end if ActiveRecord::VERSION::MAJOR < 4
 
+      private
+
+      if ActiveRecord::VERSION::STRING > '4.2'
+
+        def _run_checkin_callbacks(conn)
+          if conn.respond_to?(:_run_checkin_callbacks)
+            conn._run_checkin_callbacks do
+              conn.expire
+            end
+          else
+            conn.run_callbacks :checkin do
+              conn.expire
+            end
+          end
+        end
+
+        def _run_checkout_callbacks(conn)
+          if conn.respond_to?(:_run_checkout_callbacks)
+            conn._run_checkout_callbacks do
+              conn.verify!
+            end
+          else
+            conn.run_callbacks :checkout do
+              conn.verify!
+            end
+          end
+        end
+
+      else
+
+        def _run_checkin_callbacks(conn)
+          conn.run_callbacks :checkin do
+            conn.expire
+          end
+        end
+
+        def _run_checkout_callbacks(conn)
+          conn.run_callbacks :checkout do
+            conn.verify!
+          end
+        end
+
+      end
+
     end
   end
 end

data/lib/active_record/bogacs/version.rb

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

data/test/active_record/bogacs/default_pool_test.rb

@@ -29,6 +29,8 @@ module ActiveRecord
         assert_equal 0, @pool.connections.size
       end
 
+      def self.startup; puts "running with ActiveRecord: #{ActiveRecord::VERSION::STRING}" end
+
     end
   end
 end

data/test/active_record/bogacs/false_pool_test.rb

@@ -12,8 +12,6 @@ module ActiveRecord
         # extend Bogacs::TestHelper
         extend Bogacs::JndiTestHelper
 
-        @@data_source = nil
-
         def self.startup
           return if self == TestBase
 
@@ -25,7 +23,11 @@ module ActiveRecord
         def self.shutdown
           return if self == TestBase
 
-          close_data_source
+          begin
+            close_data_source
+          ensure
+            @@data_source = nil
+          end
 
           ActiveRecord::Base.connection_pool.disconnect!
           ConnectionAdapters::ConnectionHandler.connection_pool_class = ConnectionAdapters::ConnectionPool
@@ -46,6 +48,8 @@ module ActiveRecord
           end
         end
 
+        @@data_source = nil
+
         def self.init_data_source
           setup_jdbc_context
           bind_data_source @@data_source = build_data_source(raw_config)
@@ -343,9 +347,6 @@ module ActiveRecord
           com.zaxxer.hikari.HikariDataSource.class_eval do
             field_reader :pool unless method_defined? :pool
           end
-          com.zaxxer.hikari.pool.HikariPool.class_eval do
-            field_reader :isShutdown unless method_defined? :isShutdown
-          end
 
           data_source
         end

data/test/active_record/connection_pool_test_methods.rb

@@ -329,6 +329,52 @@ module ActiveRecord
         # assert_raises { handler.establish_connection anonymous, nil }
       #end
 
+      def test_pooled_connection_remove
+        # ActiveRecord::Base.establish_connection(@connection.merge({:pool => 2, :checkout_timeout => 0.5}))
+        @pool.instance_variable_set(:@size, 2)
+        # old_connection = ActiveRecord::Base.connection
+        old_connection = @pool.connection
+        # extra_connection = ActiveRecord::Base.connection_pool.checkout
+        extra_connection = @pool.checkout
+        # ActiveRecord::Base.connection_pool.remove(extra_connection)
+        @pool.remove(extra_connection)
+        # assert_equal ActiveRecord::Base.connection, old_connection
+        assert_equal @pool.connection, old_connection
+      end
+
+      def test_pooled_connection_checkin_two
+        checkout_checkin_connections_loop 2, 3
+        assert_equal 3, @connection_count
+        assert_equal 0, @timed_out
+        # assert_equal 2, ActiveRecord::Base.connection_pool.connections.size
+        assert_equal 2, @pool.connections.size
+      end
+
+      protected
+
+      def checkout_checkin_connections_loop(pool_size, loops)
+        # ActiveRecord::Base.establish_connection(@connection.merge({:pool => pool_size, :checkout_timeout => 0.5}))
+        @pool.instance_variable_set(:@size, pool_size)
+        @pool.instance_variable_set(:@checkout_timeout, 0.5)
+
+        @connection_count = 0; @timed_out = 0
+        loops.times do
+          begin
+            # conn = ActiveRecord::Base.connection_pool.checkout
+            conn = @pool.checkout
+            # ActiveRecord::Base.connection_pool.checkin conn
+            @pool.checkin conn
+
+            @connection_count += 1
+
+            # ActiveRecord::Base.connection.tables
+            @pool.connection.tables
+          rescue ActiveRecord::ConnectionTimeoutError
+            @timed_out += 1
+          end
+        end
+      end
+
       private
 
       def active_connections(pool = self.pool)

data/test/test_helper.rb

@@ -349,7 +349,7 @@ module ActiveRecord
 
         if ar_jdbc_config[:properties]
           properties = java.util.Properties.new
-          properties.putAll ar_jdbc_config[:properties]
+          ar_jdbc_config[:properties].each { |key, val| properties.put key.to_s, val.to_s }
           data_source.setProperties properties
         end
         # JDBC pool tunings (some mapped from AR configuration) :
@@ -371,7 +371,15 @@ module ActiveRecord
 
 
       def build_hikari_data_source(ar_jdbc_config = AR_CONFIG)
-        Dir.glob('test/jars/{javassist,slf4j,HikariCP}*.jar').each { |jar| load jar }
+        unless hikari_jar = Dir.glob('test/jars/HikariCP*.jar').last
+          raise 'HikariCP jar not found in test/jars directory'
+        end
+        if ( version = File.basename(hikari_jar, '.jar').match(/\-([\w\.\-]$)/) ) && version[1] < '2.3.9'
+          Dir.glob('test/jars/{javassist,slf4j}*.jar').each { |jar| require jar }
+        else
+          Dir.glob('test/jars/{slf4j}*.jar').each { |jar| require jar }
+        end
+        require hikari_jar
 
         configure_hikari_data_source(ar_jdbc_config)
       end
@@ -400,7 +408,7 @@ module ActiveRecord
           hikari_config.setDataSourceClassName 'org.postgresql.ds.PGSimpleDataSource'
           hikari_config.addDataSourceProperty 'serverName', ar_jdbc_config[:host] || 'localhost'
           hikari_config.addDataSourceProperty 'databaseName', ar_jdbc_config[:database]
-          hikari_config.addDataSourceProperty 'port', ar_jdbc_config[:port] if ar_jdbc_config[:port]
+          hikari_config.addDataSourceProperty 'portNumber', ar_jdbc_config[:port] if ar_jdbc_config[:port]
           if ar_jdbc_config[:username]
             hikari_config.addDataSourceProperty 'user', ar_jdbc_config[:username]
           end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-bogacs
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Karol Bucek
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-10-22 00:00:00.000000000 Z
+date: 2015-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby