activerecord-bogacs 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 63fff373845781b28c456f85fe34f88f4bf70a50
-  data.tar.gz: 6b3a8ce661500ec191eff3405d6d3e92d9d90c9e
+  metadata.gz: 6cade13cd15b5374a780d1f8d0de1d63b7e0c89a
+  data.tar.gz: 51949daaccd651b2d8fa51ccfa3379109885ed16
 SHA512:
-  metadata.gz: ba7c559f09102200a324592448dd7f283ac2b604dd1cdbc5f8e3a0309c07181ebcfbb7fbb576dfa3421cff9faf1cb2c3c5907b64c519c3dbe6da8ab039daaa01
-  data.tar.gz: bfc98ebdacaab29b8d73be82da0327af06bab79d861426c538106de8918bd3ca90581bde24112d1ce4cce76bb3027d186d14ff9f3f017a7205a262696b8c5657
+  metadata.gz: 91259b8c14a9eeea273eddb83c0b561ab65908683619a6b4f0bd7d744198c7a9e1a1b4dae5d1705b82b98fa5e8c0097d00b06c9b1c90ca7113cbfa1b59018fa7
+  data.tar.gz: 9f814b2b2eb6ced23c2da439c2dfd05c9fec270ed50f2f410748c75906e9911f62a7e794b28e5021de0de9eec5169b13d381dd077fba94fe1f39b159b6bebfde

data/.travis.yml

@@ -1,6 +1,6 @@
 language: ruby
 jdk:
-  - openjdk6
+  #- openjdk6
   - oraclejdk7
   - oraclejdk8
 rvm:
@@ -8,19 +8,19 @@ rvm:
   #- jruby-head
   #- jruby-18mode
   #- jruby-19mode
-  #- 2.1.0
+  #- 2.1.2
 before_install:
   - ((jruby -v | grep 1.8.7) && jruby --1.9 -S gem update --system 2.1.11) || true
 before_script:
-  - echo "JRUBY_OPTS: $JRUBY_OPTS"
+  #- echo \"JRUBY_OPTS: $JRUBY_OPTS\"
   - export JRUBY_OPTS="--server -Xcext.enabled=false -Xcompile.invokedynamic=false"
   - export JAVA_OPTS="$JAVA_OPTS" # -Xmx600M
-  - echo "JAVA_OPTS: $JAVA_OPTS"
 script:
   - bundle exec rake tomcat:jndi:download tomcat:jdbc:download tomcat:dbcp:download
+  - bundle exec rake c3p0:download hikari:download
   - bundle exec rake db:create:mysql db:create:postgresql
 env:
-  - JRUBY_OPTS="--1.8 $JRUBY_OPTS" AR_ADAPTER=mysql
+  - JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=mysql AR_VERSION="~> 4.1.6"
+  - JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=postgresql AR_VERSION="~> 4.1.6"
   - JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=postgresql AR_VERSION="~> 3.2.18"
   - JRUBY_OPTS="--1.8 $JRUBY_OPTS" AR_ADAPTER=mysql AR_VERSION="~> 3.2.18"
-  - JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=postgresql

data/Gemfile

@@ -16,7 +16,21 @@ else
   gem 'activerecord', :require => nil
 end
 
-gem 'activerecord-jdbc-adapter', :require => nil, :platform => :jruby
+platform :jruby do
+  if version = ENV['AR_JDBC_VERSION']
+    if version.index('/') && ::File.exist?(version)
+      gem 'activerecord-jdbc-adapter', :path => version
+    elsif version =~ /^[0-9abcdef]+$/
+      gem 'activerecord-jdbc-adapter', :github => 'jruby/activerecord-jdbc-adapter', :ref => version
+    elsif version.index('.').nil?
+      gem 'activerecord-jdbc-adapter', :github => 'jruby/activerecord-jdbc-adapter', :branch => version
+    else
+      gem 'activerecord-jdbc-adapter', version, :require => nil
+    end
+  else
+    gem 'activerecord-jdbc-adapter', :require => nil
+  end
+end
 
 #gem 'thread_safe', :require => nil # "optional" - we can roll without it
 

data/README.md

@@ -1,12 +1,12 @@
 # ActiveRecord::Bogacs
 
-ActiveRecord pooling "hacks" ... in a relaxed 'spa' fashion!
+ActiveRecord (all-year) pooling "alternatives" ... in a relaxed 'spa' fashion.
 
 ![Bogacs][0]
 
 Bogács is a village in Borsod-Abaúj-Zemplén county, Hungary.
 
-**WiP: don't even thing about putting this on production (TEST IT OUT FIRST)!**
+**WiP: do not put this on production if you do not understand the consequences!**
 
 ## Install
 
@@ -34,7 +34,7 @@ module MyApp
   end
 end
 
-# sample configuration using the "false" pool
+# sample AR-Bogacs setup using the "false" pool :
 if Rails.env.production?
   pool_class = ActiveRecord::Bogacs::FalsePool
   ActiveRecord::ConnectionAdapters::ConnectionHandler.connection_pool_class = pool_class
@@ -50,13 +50,13 @@ facing potential (pool related) concurrency bugs e.g. with high-loads under JRub
 
 Based on pool code from 4.x (which works much better than any previous version),
 with a few minor tunings and extensions such as `pool_initial: 0.5` which allows
-to specify how many connections to prefill when the pool is created.
+to specify how many connections to initialize in advance when the pool is created.
 
 ### False Pool
 
-The false pool won't do any actual pooling, it is assumes that an underlying pool
-is configured. But it does maintain a cache of AR connections mapped to threads.
-Ignores all pool related configuration `pool: 42`, `checkout_timeout: 2.5` etc.
+The false pool won't do any actual pooling, it is assumed that an underlying pool
+is configured. Still, it does maintain a hash of AR connections mapped to threads.
+Ignores pool related configurations such as `pool: 42` or `checkout_timeout: 2.5`.
 
 **NOTE:** be sure to configure an underlying pool e.g. with Trinidad (using the
 default Tomcat JDBC pool) :
@@ -74,7 +74,7 @@ default Tomcat JDBC pool) :
       initialSize: <%= ENV['POOL_INITIAL'] || 25 %> # connections created on start
       maxActive: <%= ENV['POOL_SIZE'] || 100 %> # default 100 (AR pool: size)
       maxIdle: <%= ENV['POOL_SIZE'] || 100 %> # max connections kept in the pool
-      minIdle: <%= ENV['POOL_SIZE'] || 50 %>
+      minIdle: <%= ENV['POOL_INITIAL'] || 50 %>
       # idle connections are checked periodically (if enabled) and connections
       # that been idle for longer than minEvictableIdleTimeMillis will be released
       minEvictableIdleTimeMillis: <%= 3 * 60 * 1000 %> # default 60s
@@ -91,8 +91,7 @@ production:
   jndi: java:/comp/env/jdbc/BogacsDB
 ```
 
-**NOTE:** using the `FalsePool` there's nothing to configure (in *database.yml*)
-that is `no_pool: 5` or `checkout_timeout: 5` defaults!
+**NOTE:** when using `FalsePool` there's nothing to configure (in *database.yml*)!
 
 ### Shareable Pool
 

data/Rakefile

@@ -10,8 +10,8 @@ task :default => :test
 desc "Creates a (test) MySQL database"
 task 'db:create:mysql' do
   fail "could not create database: mysql executable not found" unless mysql = _which('mysql')
-  ENV['Rake'] = true; ENV['AR_ADAPTER'] ||= 'mysql'
-  load File.expand_path('test/test_helper.rb', File.dirname(__FILE__))
+  ENV['Rake'] = true.to_s; ENV['AR_ADAPTER'] ||= 'mysql'
+  require File.expand_path('test/test_helper.rb', File.dirname(__FILE__))
 
   script = "DROP DATABASE IF EXISTS `#{AR_CONFIG[:database]}`;"
   script << "CREATE DATABASE `#{AR_CONFIG[:database]}` DEFAULT CHARACTER SET `utf8` COLLATE `utf8_general_ci`;"
@@ -20,22 +20,20 @@ task 'db:create:mysql' do
     script << "SET PASSWORD FOR #{AR_CONFIG[:username]}@localhost = PASSWORD('#{AR_CONFIG[:password]}');"
   end
   params = { '-u' => 'root' }
-  if ENV['DATABASE_YML']
-    require 'yaml'
+  if ENV['DATABASE_YML']; require 'yaml'
     password = YAML.load(File.new(ENV['DATABASE_YML']))["production"]["password"]
     params['--password'] = password
   end
   puts "Creating MySQL database: #{AR_CONFIG[:database]}"
   sh "cat #{_sql_script(script).path} | #{mysql} #{params.to_a.join(' ')}", :verbose => $VERBOSE
-  puts "... run tests with MySQL using: `rake test AR_ADAPTER=mysql`"
+  # puts "... run tests with MySQL using: `AR_ADAPTER=mysql rake test `"
 end
 
 desc "Creates a (test) PostgreSQL database"
 task 'db:create:postgresql' do
   fail 'could not create database: psql executable not found' unless psql = _which('psql')
-  fail 'could not create database: missing "postgres" role' unless PostgresHelper.postgres_role?
-  ENV['Rake'] = true; ENV['AR_ADAPTER'] ||= 'postgresql'
-  load File.expand_path('test/test_helper.rb', File.dirname(__FILE__))
+  ENV['Rake'] = true.to_s; ENV['AR_ADAPTER'] ||= 'postgresql'
+  require File.expand_path('test/test_helper.rb', File.dirname(__FILE__))
 
   script = "DROP DATABASE IF EXISTS #{AR_CONFIG[:database]};"
   if pg_user = AR_CONFIG[:username] || ENV['PGUSER'] || ENV_JAVA['user.name']
@@ -44,10 +42,15 @@ task 'db:create:postgresql' do
     script << "CREATE USER #{pg_user} CREATEDB SUPERUSER LOGIN PASSWORD '#{pg_password}';"
   end
   script << "CREATE DATABASE #{AR_CONFIG[:database]} OWNER #{pg_user || 'postgres'};"
-  params = { '-U' => ENV['PSQL_USER'] || 'postgres' }; params['-q'] = nil unless $VERBOSE
+
+  psql_params = "-U #{ENV['PSQL_USER'] || 'postgres'}"
+  psql_params << " -h #{ENV['PGHOST']}" if ENV['PGHOST']
+  psql_params << " -p #{ENV['PGPORT']}" if ENV['PGPORT']
+  psql_params << " -q " unless $VERBOSE
+
   puts "Creating PostgreSQL database: #{AR_CONFIG[:database]}"
-  sh "cat #{_sql_script(script).path} | #{psql} #{params.to_a.join(' ')}", :verbose => $VERBOSE
-  puts "... run tests with PostgreSQL using: `rake test AR_ADAPTER=postgresql`"
+  sh "cat #{_sql_script(script).path} | #{psql} #{psql_params}", :verbose => $VERBOSE
+  # puts "... run tests with PostgreSQL using: `AR_ADAPTER=postgresql rake test `"
 end
 
 def _sql_script(content, name = '_sql_script')
@@ -71,6 +74,22 @@ def _which(cmd)
   nil
 end
 
+def _download(uri, download_dir, as_file_name)
+  require 'open-uri'; require 'tmpdir'
+
+  temp_dir = File.join(Dir.tmpdir, (Time.now.to_f * 1000).to_i.to_s)
+  FileUtils.mkdir temp_dir
+
+  Dir.chdir(temp_dir) do
+    FileUtils.mkdir download_dir unless File.exist?(download_dir)
+    puts "downloading #{uri}"
+    file = open(uri)
+    FileUtils.cp file.path, File.join(download_dir, as_file_name)
+  end
+
+  FileUtils.rm_r temp_dir
+end
+
 namespace :tomcat do
 
   tomcat_maven_repo = 'http://repo2.maven.org/maven2/org/apache/tomcat'
@@ -87,19 +106,7 @@ namespace :tomcat do
 
         uri = "#{tomcat_maven_repo}/#{tomcat_pool}/#{version}/#{tomcat_pool}-#{version}.jar"
 
-        require 'open-uri'; require 'tmpdir'
-
-        temp_dir = File.join(Dir.tmpdir, (Time.now.to_f * 1000).to_i.to_s)
-        FileUtils.mkdir temp_dir
-
-        Dir.chdir(temp_dir) do
-          FileUtils.mkdir download_dir unless File.exist?(download_dir)
-          puts "downloading #{uri}"
-          file = open(uri)
-          FileUtils.cp file.path, File.join(download_dir, tomcat_pool_jar)
-        end
-
-        FileUtils.rm_r temp_dir
+        _download(uri, download_dir, tomcat_pool_jar)
       end
 
       task :check do
@@ -165,3 +172,69 @@ namespace :tomcat do
   end
 
 end
+
+namespace :c3p0 do
+
+  mchange_base_repo = 'http://repo2.maven.org/maven2/com/mchange'
+  download_dir = File.expand_path('test/jars', File.dirname(__FILE__))
+  c3p0_version = '0.9.5-pre9'
+  mchange_commons_version = '0.2.8'
+
+  c3p0_jar = "c3p0-#{c3p0_version}.jar"
+  mchange_commons_jar = "mchange-commons-java-#{mchange_commons_version}.jar"
+
+  task :download, :version do |_,args| # rake c3p0:download
+    # version = args[:version] || version_default
+
+    uri = "#{mchange_base_repo}/mchange-commons-java/#{mchange_commons_version}/#{mchange_commons_jar}"
+
+    _download(uri, download_dir, mchange_commons_jar)
+
+    uri = "#{mchange_base_repo}/c3p0/#{c3p0_version}/#{c3p0_jar}"
+
+    _download(uri, download_dir, c3p0_jar)
+  end
+
+  task :clear do
+    Dir.glob( File.join(download_dir, '{c3p0,mchange-commons}*.jar') ).each { |jar| rm jar }
+  end
+
+end
+
+namespace :hikari do
+
+  hikari_base_repo = 'http://repo2.maven.org/maven2/com/zaxxer'
+  slf4j_base_repo = 'http://repo2.maven.org/maven2/org/slf4j'
+  javassist_base_repo = 'http://repo2.maven.org/maven2/org/javassist'
+  download_dir = File.expand_path('test/jars', File.dirname(__FILE__))
+  hikari_version = '1.3.9'
+  slf4j_version = '1.7.7'
+  javassist_version = '3.18.2-GA'
+
+  slf4j_api_jar = "slf4j-api-#{slf4j_version}.jar"
+  slf4j_simple_jar = "slf4j-simple-#{slf4j_version}.jar"
+  javassist_jar = "javassist-#{javassist_version}.jar"
+
+  task :download, :version do |_,args| # rake c3p0:download
+    version = args[:version] || hikari_version
+
+    hikari_jar = "HikariCP-#{hikari_version}.jar"
+
+    uri = "#{hikari_base_repo}/HikariCP/#{version}/#{hikari_jar}"
+    _download(uri, download_dir, hikari_jar)
+
+    uri = "#{slf4j_base_repo}/slf4j-api/#{slf4j_version}/#{slf4j_api_jar}"
+    _download(uri, download_dir, slf4j_api_jar)
+
+    uri = "#{slf4j_base_repo}/slf4j-simple/#{slf4j_version}/#{slf4j_simple_jar}"
+    _download(uri, download_dir, slf4j_simple_jar)
+
+    uri = "#{javassist_base_repo}/javassist/#{javassist_version}/#{javassist_jar}"
+    _download(uri, download_dir, javassist_jar)
+  end
+
+  task :clear do
+    Dir.glob( File.join(download_dir, '{HikariCP,slf4j}*.jar') ).each { |jar| rm jar }
+  end
+
+end

data/lib/active_record/bogacs/false_pool.rb

@@ -220,7 +220,7 @@ module ActiveRecord
         rescue ConnectionTimeoutError => e
           raise e
         rescue => e
-          raise ConnectionTimeoutError, e.message if _timeout_error?(e)
+          raise ConnectionTimeoutError, e.message if timeout_error?(e)
           raise e
         end
         conn.pool = self
@@ -233,27 +233,30 @@ module ActiveRecord
       #  conn
       #end
 
-      # sample on JRuby + 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].>
-      # )
-
-      def _timeout_error?(error)
-        error.inspect =~ /timeout/i
+      def timeout_error?(error)
+        full_error = error.inspect
+        # sample on JRuby + 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
+        # NOTE: not sure what to do on MRI and friends (C-pools not tested)
+        false
       end
 
-#      def _timeout_error?(error); end # TODO: not sure what to do on MRI and friends
-#
-#      def _timeout_error?(error)
-#        if error.is_a?(JDBCError)
-#          if sql_exception = error.sql_exception
-#            return true if sql_exception.to_s =~ /timeout/i
-#          end
-#        end
-#      end if defined? ArJdbc
+      #def timeout_error?(error)
+      #  if error.is_a?(JDBCError)
+      #    if sql_exception = error.sql_exception
+      #      return true if sql_exception.to_s =~ /timeout/i
+      #    end
+      #  end
+      #end if defined? ArJdbc
 
     end
   end
-end
+end

data/lib/active_record/bogacs/pool_support.rb

@@ -13,9 +13,29 @@ module ActiveRecord
       end
 
       def current_connection_id
-        Base.connection_id ||= Thread.current.object_id # TODO
+        # NOTE: possible fiber work-around on JRuby ?!
+        Base.connection_id ||= Thread.current.object_id
       end
 
+      # @note Method not part of the pre 4.0 API (does no exist).
+      def remove(conn)
+        synchronize do
+          @connections.delete conn
+          release conn
+        end
+      end if ActiveRecord::VERSION::MAJOR < 4
+
+      # clear_stale_cached_connections! without the deprecation :
+      def reap
+        keys = @reserved_connections.keys -
+         Thread.list.find_all { |t| t.alive? }.map(&:object_id)
+        keys.each do |key|
+          conn = @reserved_connections[key]
+          checkin conn
+          @reserved_connections.delete(key)
+        end
+      end if ActiveRecord::VERSION::MAJOR < 4
+
     end
   end
 end

data/lib/active_record/bogacs/shareable_pool.rb

@@ -1,8 +1,11 @@
 require 'active_record/connection_adapters/abstract/connection_pool'
+
 require 'thread'
 require 'thread_safe'
 require 'atomic'
 
+require 'active_record/bogacs/pool_support'
+
 # NOTE: needs explicit configuration - before connection gets established e.g.
 #
 #   pool_class = ActiveRecord::ConnectionAdapters::ShareableConnectionPool
@@ -10,8 +13,9 @@ require 'atomic'
 #
 module ActiveRecord
   module Bogacs
-    class ShareablePool < ConnectionAdapters::ConnectionPool # TODO do not override?!
+    class ShareablePool < ConnectionAdapters::ConnectionPool # NOTE: maybe do not override?!
       include ThreadSafe::Util::CheapLockable
+      include PoolSupport
 
       DEFAULT_SHARED_POOL = 0.25 # only allow 25% of the pool size to be shared
       MAX_THREAD_SHARING = 5 # not really a strict limit but should hold
@@ -31,15 +35,14 @@ module ActiveRecord
 
       # @override
       def connection
-        # TODO we assume here a single pool - multiple pool support not implemented!
-        Thread.current[:shared_pool_connection] || begin # super - simplified :
+        Thread.current[shared_connection_key] || begin # super - simplified :
           super # @reserved_connections.compute_if_absent(current_connection_id) { checkout }
         end
       end
 
       # @override
       def active_connection?
-        if shared_conn = Thread.current[:shared_pool_connection]
+        if shared_conn = Thread.current[shared_connection_key]
           return shared_conn.in_use?
         end
         super_active_connection? current_connection_id
@@ -95,8 +98,9 @@ module ActiveRecord
       # Custom API :
 
       def release_shared_connection(connection)
-        if connection == Thread.current[:shared_pool_connection]
-          Thread.current[:shared_pool_connection] = nil
+        shared_conn_key = shared_connection_key
+        if connection == Thread.current[shared_conn_key]
+          Thread.current[shared_conn_key] = nil
         end
 
         @shared_connections.delete(connection)
@@ -104,8 +108,9 @@ module ActiveRecord
       end
 
       def with_shared_connection
+        shared_conn_key = shared_connection_key
         # with_shared_connection call nested in the same thread
-        if connection = Thread.current[:shared_pool_connection]
+        if connection = Thread.current[shared_conn_key]
           emulated_checkout(connection)
           return yield connection
         end
@@ -138,12 +143,12 @@ module ActiveRecord
             shared = true
           end
 
-          Thread.current[:shared_pool_connection] = connection if shared
+          Thread.current[shared_conn_key] = connection if shared
 
           DEBUG && debug("with_shared_conn obtaining a connection took #{(Time.now - start) * 1000}ms")
           yield connection
         ensure
-          Thread.current[:shared_pool_connection] = nil # if shared
+          Thread.current[shared_conn_key] = nil # if shared
           rem_shared_connection(connection) if shared
         end
       end
@@ -162,10 +167,21 @@ module ActiveRecord
 
       def acquire_connection_no_wait?
         synchronize do
-          @available.send(:can_remove_no_wait?) || @connections.size < @size
+          @connections.size < @size || @available.send(:can_remove_no_wait?)
+          #return true if @connections.size < @size
+          # @connections.size < @size || Queue#can_remove_no_wait? :
+          #queue = @available.instance_variable_get(:@queue)
+          #num_waiting = @available.instance_variable_get(:@num_waiting)
+          #queue.size > num_waiting
         end
       end
 
+      def acquire_connection_no_wait?
+        synchronize do
+          @connections.size < @size || @connections.any? { |c| ! c.in_use? }
+        end
+      end if ActiveRecord::VERSION::MAJOR < 4
+
       # get a (shared) connection that is least shared among threads (or nil)
       # nil gets returned if it's 'better' to checkout a new one to be shared
       # ... to better utilize shared connection reuse among multiple threads
@@ -231,6 +247,10 @@ module ActiveRecord
         connection.lease; # connection.verify! auto-reconnect should do this
       end
 
+      def shared_connection_key
+        @shared_connection_key ||= :"shared_pool_connection##{object_id}"
+      end
+
       DEBUG = begin
         debug = ENV['DB_POOL_DEBUG'].to_s
         if debug.to_s == 'false' then false
@@ -252,4 +272,4 @@ module ActiveRecord
 
     end
   end
-end
+end

data/lib/active_record/bogacs/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Bogacs
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

data/lib/active_record/connection_adapters/adapter_compat.rb

@@ -12,10 +12,24 @@ module ActiveRecord
 
         if method_defined? :in_use?
 
-          def lease
-            unless in_use?
-              @owner = Thread.current; @in_use = true
+          if method_defined? :last_use
+
+            def lease
+              unless in_use?
+                @owner = Thread.current
+                @in_use = true; @last_use = Time.now
+              end
             end
+
+          else
+
+            def lease
+              unless in_use?
+                @owner = Thread.current
+                @in_use = true
+              end
+            end
+
           end
 
           def expire
@@ -38,18 +52,6 @@ module ActiveRecord
 
         end
 
-        alias :in_use? :owner
-
-        def lease
-          unless in_use?
-            @owner = Thread.current
-          end
-        end
-
-        def expire
-          @owner = nil
-        end
-
       end
 
     end

data/test/active_record/bogacs/false_pool_test.rb

@@ -14,54 +14,72 @@ module ActiveRecord
         # extend Bogacs::TestHelper
         extend Bogacs::JndiTestHelper
 
+        @@data_source = nil
+
         def self.startup
           return if self == TestBase
 
-          ActiveRecord::Base.establish_connection AR_CONFIG
-
-          ActiveRecord::Base.connection.jdbc_connection # force connection
-          current_config = Bogacs::TestHelper.current_connection_config
-
-          ActiveRecord::Base.connection_pool.disconnect!
-
-          setup_jdbc_context
-          bind_data_source init_data_source current_config
-
           ConnectionAdapters::ConnectionHandler.connection_pool_class = FalsePool
-          ActiveRecord::Base.establish_connection jndi_config
+
+          establish_jndi_connection
         end
 
         def self.shutdown
           return if self == TestBase
 
+          close_data_source
+
           ActiveRecord::Base.connection_pool.disconnect!
           ConnectionAdapters::ConnectionHandler.connection_pool_class = ConnectionAdapters::ConnectionPool
         end
 
-      end
+        @@raw_config = nil
 
-      class ConnectionPoolWrappingTomcatJdbcTest < TestBase
+        def self.raw_config
+          @@raw_config ||= begin
+            ActiveRecord::Base.establish_connection AR_CONFIG
 
-        @@data_source = nil
-        def self.init_data_source(config)
-          @@data_source = init_tomcat_jdbc_data_source(config)
+            ActiveRecord::Base.connection.jdbc_connection # force connection
+            current_config = Bogacs::TestHelper.current_connection_config
+
+            ActiveRecord::Base.connection_pool.disconnect!
+
+            current_config
+          end
         end
 
-        include ConnectionAdapters::ConnectionPoolTestMethods
+        def self.init_data_source
+          setup_jdbc_context
+          bind_data_source @@data_source = build_data_source(raw_config)
+        end
 
-        def setup
-          @pool = FalsePool.new ActiveRecord::Base.connection_pool.spec
+        def self.establish_jndi_connection
+          if ActiveRecord::Base.connected?
+            ActiveRecord::Base.clear_all_connections!
+            close_data_source
+          end
+
+          init_data_source
+          ActiveRecord::Base.establish_connection jndi_config
         end
 
-        def teardown
-          @@data_source.send(:close, true) if @@data_source
+        def self.close_data_source
+          @@data_source.close if @@data_source
         end
 
-        def test_uses_false_pool_and_can_execute_query
-          assert_instance_of ActiveRecord::Bogacs::FalsePool, ActiveRecord::Base.connection_pool
-          assert ActiveRecord::Base.connection.exec_query('SELECT 42')
+        def data_source; @@data_source end
+
+      end
+
+      module ConnectionPoolWrappingDataSourceTestMethods
+        include ConnectionAdapters::ConnectionPoolTestMethods
+
+        def setup
+          @pool = FalsePool.new ActiveRecord::Base.connection_pool.spec
         end
 
+        def max_pool_size; raise "#{__method__} not implemented" end
+
         # adjust ConnectionAdapters::ConnectionPoolTestMethods :
 
         undef :test_checkout_fairness
@@ -75,6 +93,11 @@ module ActiveRecord
 
         undef :test_removing_releases_latch
 
+        def test_uses_false_pool_and_can_execute_query
+          assert_instance_of ActiveRecord::Bogacs::FalsePool, ActiveRecord::Base.connection_pool
+          assert ActiveRecord::Base.connection.exec_query('SELECT 42')
+        end
+
         # @override
         def test_remove_connection
           conn = pool.checkout
@@ -92,7 +115,7 @@ module ActiveRecord
         def test_full_pool_exception
           # ~ pool_size.times { pool.checkout }
           threads_ready = Queue.new; threads_block = Atomic.new(0); threads = []
-          pool_size.times do |i|
+          max_pool_size.times do |i|
             threads << Thread.new do
               begin
                 conn = ActiveRecord::Base.connection
@@ -108,7 +131,7 @@ module ActiveRecord
               end
             end
           end
-          pool_size.times { threads_ready.pop } # awaits
+          max_pool_size.times { threads_ready.pop } # awaits
 
           assert_raise(ConnectionTimeoutError) do
             ActiveRecord::Base.connection # ~ pool.checkout
@@ -136,7 +159,7 @@ module ActiveRecord
           end
 
           threads_ready = Queue.new; threads_block = Atomic.new(0); threads = []
-          (pool_size - 1).times do |i|
+          (max_pool_size - 1).times do |i|
             threads << Thread.new do
               begin
                 conn = ActiveRecord::Base.connection
@@ -152,7 +175,7 @@ module ActiveRecord
               end
             end
           end
-          (pool_size - 1).times { threads_ready.pop } # awaits
+          (max_pool_size - 1).times { threads_ready.pop } # awaits
 
           connection = t1_ready.pop
           t1_jdbc_connection = connection.jdbc_connection(true)
@@ -189,9 +212,96 @@ module ActiveRecord
           threads && threads.each(&:join)
         end
 
-        private
+      end
 
-        def pool_size; @@data_source.max_active end
+      class ConnectionPoolWrappingTomcatJdbcDataSourceTest < TestBase
+        include ConnectionPoolWrappingDataSourceTestMethods
+
+        def self.build_data_source(config)
+          build_tomcat_jdbc_data_source(config)
+        end
+
+        def self.jndi_name; 'jdbc/TestTomcatJdbcDB' end
+
+        def self.close_data_source
+          @@data_source.send(:close, true) if @@data_source
+        end
+
+        def max_pool_size; @@data_source.max_active end
+
+        def teardown
+          self.class.close_data_source
+        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
+        include ConnectionPoolWrappingDataSourceTestMethods
+
+        def self.build_data_source(config)
+          data_source = build_hikari_data_source(config)
+
+          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
+
+        def self.jndi_name; 'jdbc/TestHikariDB' end
+
+        def max_pool_size; @@data_source.maximum_pool_size end
+
+
+        def self.close_data_source
+          @@data_source.shutdown if @@data_source
+        end
+
+        def teardown
+          self.class.establish_jndi_connection # for next test
+        end
 
       end
 

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

@@ -160,7 +160,7 @@ module ActiveRecord
         def test_does_not_use_more_shared_connections_than_configured_shared_size
           shared_conn_threads = {}
           begin
-            block_connections_in_threads(2) do # only 2 connections left
+            block_connections_in_threads(4) do # 6 (out of 10) connections left
 
               shared_conn_threads = start_shared_connection_threads(7, :wait)
 
@@ -170,6 +170,7 @@ module ActiveRecord
                 assert shared_connection?(conn)
                 conn
               end
+              
               assert_equal 5, shared_conns.uniq.size
 
               # still one left for normal connections :
@@ -290,7 +291,7 @@ module ActiveRecord
         protected
 
         def current_shared_pool_connection
-          Thread.current[:shared_pool_connection]
+          Thread.current[ connection_pool.send(:shared_connection_key) ]
         end
 
         def set_pool_size(size, shared_size = nil)

data/test/active_record/builtin_pool_test.rb

@@ -9,8 +9,9 @@ module ActiveRecord
       def config; AR_CONFIG end
 
       def setup
-        super
+        super; require 'active_record/bogacs/pool_support'
         @pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
+        @pool.extend Bogacs::PoolSupport # aligns API for AR < 4.0
       end
 
     end

data/test/active_record/connection_pool_test_methods.rb

@@ -160,7 +160,11 @@ module ActiveRecord
       def test_active_connection?
         assert_false pool.active_connection?
         assert pool.connection
-        assert_true pool.active_connection?
+        if ActiveRecord::VERSION::MAJOR >= 4
+          assert_true pool.active_connection?
+        else
+          assert pool.active_connection?
+        end
         pool.release_connection
         assert_false pool.active_connection?
       end

data/test/test_helper.rb

@@ -19,6 +19,7 @@ ENV['DB_POOL_SHARED'] ||= 0.5.to_s
 #   e.g. 40 - ( 40 * 0.75 ) * 5 = 160
 
 require 'active_record'
+require 'arjdbc' if defined? JRUBY_VERSION
 
 require 'logger'
 ActiveRecord::Base.logger = Logger.new(STDOUT)
@@ -40,6 +41,7 @@ config[:'password'] = ENV['AR_PASSWORD'] if ENV['AR_PASSWORD']
 if url = ENV['AR_URL'] || ENV['JDBC_URL']
   config[:'url'] = url
 else
+  config[:'host'] = ENV['AR_HOST'] || 'localhost'
   config[:'database'] = ENV['AR_DATABASE'] || 'ar_basin'
 end
 
@@ -211,7 +213,9 @@ module ActiveRecord
 
     module JndiTestHelper
 
-      def setup_jdbc_context
+      @@setup_jdbc_context = nil
+
+      def setup_jdbc_context!
         load 'test/jars/tomcat-juli.jar'
         load 'test/jars/tomcat-catalina.jar'
 
@@ -231,18 +235,23 @@ module ActiveRecord
         end
       end
 
-      def init_tomcat_jdbc_data_source(ar_jdbc_config = AR_CONFIG)
+      def setup_jdbc_context
+        @@setup_jdbc_context || setup_jdbc_context!
+        @@setup_jdbc_context = true
+      end
+
+      def build_tomcat_jdbc_data_source(ar_jdbc_config = AR_CONFIG)
         load 'test/jars/tomcat-jdbc.jar'
 
         data_source = org.apache.tomcat.jdbc.pool.DataSource.new
-        configure_dbcp_data_source_attributes(data_source, ar_jdbc_config)
+        configure_dbcp_data_source(data_source, ar_jdbc_config)
 
         data_source.setJmxEnabled false
 
         data_source
       end
 
-      def configure_dbcp_data_source_attributes(data_source, ar_jdbc_config)
+      def configure_dbcp_data_source(data_source, ar_jdbc_config)
         unless driver = ar_jdbc_config[:driver]
           jdbc_driver_module.load_driver
           driver = jdbc_driver_module.driver_name
@@ -275,11 +284,125 @@ module ActiveRecord
         #data_source.setRemoveAbandoned false
         #data_source.setLogAbandoned true
       end
-      private :configure_dbcp_data_source_attributes
+      private :configure_dbcp_data_source
+
+      def build_c3p0_data_source(ar_jdbc_config = AR_CONFIG)
+        Dir.glob('test/jars/{c3p0,mchange-commons}*.jar').each { |jar| load jar }
+
+        data_source = com.mchange.v2.c3p0.ComboPooledDataSource.new
+        configure_c3p0_data_source(data_source, ar_jdbc_config)
+
+        data_source
+      end
+
+      def configure_c3p0_data_source(data_source, ar_jdbc_config)
+        unless driver = ar_jdbc_config[:driver]
+          jdbc_driver_module.load_driver
+          driver = jdbc_driver_module.driver_name
+        end
+
+        data_source.setDriverClass driver
+        data_source.setJdbcUrl ar_jdbc_config[:url]
+        if user = ar_jdbc_config[:username]
+          # data_source.setUser user # WTF C3P0
+          data_source.setOverrideDefaultUser user
+        end
+        data_source.setPassword ar_jdbc_config[:password] if ar_jdbc_config[:password]
+
+        if ar_jdbc_config[:properties]
+          properties = java.util.Properties.new
+          properties.putAll ar_jdbc_config[:properties]
+          data_source.setProperties properties
+        end
+        # JDBC pool tunings (some mapped from AR configuration) :
+        if ar_jdbc_config[:pool] # default is 100
+          data_source.setMaxPoolSize ar_jdbc_config[:pool].to_i
+          if prefill = ar_jdbc_config[:pool_prefill]
+            data_source.setInitialPoolSize prefill.to_i
+          end
+        end
+        checkout_timeout = ar_jdbc_config[:checkout_timeout] || 5
+        data_source.setCheckoutTimeout checkout_timeout * 1000
+
+        data_source.setAcquireIncrement 1 # default 3
+        data_source.setAcquireRetryAttempts 3 # default 30
+        data_source.setAcquireRetryDelay 1000 # default 1000
+        data_source.setNumHelperThreads 2 # default 3
+      end
+      private :configure_c3p0_data_source
+
+
+      def build_hikari_data_source(ar_jdbc_config = AR_CONFIG)
+        Dir.glob('test/jars/{javassist,slf4j,HikariCP}*.jar').each { |jar| load jar }
+
+        configure_hikari_data_source(ar_jdbc_config)
+      end
+
+      def configure_hikari_data_source(ar_jdbc_config)
+        hikari_config = com.zaxxer.hikari.HikariConfig.new
+
+        unless driver = ar_jdbc_config[:driver]
+          jdbc_driver_module.load_driver
+          driver = jdbc_driver_module.driver_name
+        end
+
+        case driver
+        when /mysql/i
+          hikari_config.setDataSourceClassName 'com.mysql.jdbc.jdbc2.optional.MysqlDataSource'
+          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]
+          if true
+            hikari_config.addDataSourceProperty 'user', ar_jdbc_config[:username] || 'root'
+          end
+          if ar_jdbc_config[:password]
+            hikari_config.addDataSourceProperty 'password', ar_jdbc_config[:password]
+          end
+        when /postgres/i
+          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]
+          if ar_jdbc_config[:username]
+            hikari_config.addDataSourceProperty 'user', ar_jdbc_config[:username]
+          end
+          if ar_jdbc_config[:password]
+            hikari_config.addDataSourceProperty 'password', ar_jdbc_config[:password]
+          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
+
+        # TODO: we shall handle raw properties ?!
+        #if ar_jdbc_config[:properties]
+        #  properties = java.util.Properties.new
+        #  properties.putAll ar_jdbc_config[:properties]
+        #  hikari_config.setProperties properties
+        #end
+
+        # JDBC pool tunings (some mapped from AR configuration) :
+        if ar_jdbc_config[:pool] # default is 100
+          hikari_config.setMaximumPoolSize ar_jdbc_config[:pool].to_i
+          if prefill = ar_jdbc_config[:pool_prefill]
+            hikari_config.setMinConnectionsPerPartition prefill.to_i
+          end
+        end
+
+        checkout_timeout = ar_jdbc_config[:checkout_timeout] || 5
+        hikari_config.setConnectionTimeout checkout_timeout * 1000
+
+        hikari_config.setLeakDetectionThreshold 30 * 1000 # default 10s
+
+        com.zaxxer.hikari.HikariDataSource.new hikari_config
+      end
+      private :configure_hikari_data_source
 
       def bind_data_source(data_source, jndi_name = jndi_config[:jndi])
         load_driver
-        javax.naming.InitialContext.new.bind jndi_name, data_source
+        javax.naming.InitialContext.new.rebind jndi_name, data_source
       end
 
       def load_driver
@@ -289,6 +412,7 @@ module ActiveRecord
       def jdbc_driver_module
         driver = jndi_config[:adapter]
         driver = 'postgres' if driver == 'postgresql'
+        driver = 'mysql'    if driver == 'mysql2'
         require "jdbc/#{driver}"
         ::Jdbc.const_get ::Jdbc.constants.first
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-bogacs
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Karol Bucek
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-08-01 00:00:00.000000000 Z
+date: 2014-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: atomic