activerecord-bogacs 0.1.0

data/test/active_record/builtin_pool_test.rb

@@ -0,0 +1,18 @@
+require File.expand_path('../test_helper', File.dirname(__FILE__))
+
+module ActiveRecord
+  module ConnectionAdapters
+    class BuiltinPoolTest < Test::Unit::TestCase
+
+      include ConnectionAdapters::ConnectionPoolTestMethods
+
+      def config; AR_CONFIG end
+
+      def setup
+        super
+        @pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
+      end
+
+    end
+  end
+end

data/test/active_record/connection_pool_test_methods.rb

@@ -0,0 +1,336 @@
+# NOTE: based on connection pool test (from AR's test suite)
+module ActiveRecord
+  module ConnectionAdapters
+    module ConnectionPoolTestMethods
+
+      attr_reader :pool
+
+      def setup
+        ActiveRecord::Base.establish_connection(config)
+      end
+
+      def teardown
+        pool.disconnect! if pool
+      end
+
+      def test_checkout_after_close
+        connection = pool.connection
+        assert connection.in_use?
+
+        connection.close
+        assert ! connection.in_use?
+
+        assert pool.connection.in_use?
+      end
+
+      def test_released_connection_moves_between_threads
+        thread_conn = nil
+
+        Thread.new {
+          pool.with_connection do |conn|
+            thread_conn = conn
+          end
+        }.join
+
+        assert thread_conn
+
+        Thread.new {
+          pool.with_connection do |conn|
+            assert_equal thread_conn, conn
+          end
+        }.join
+      end
+
+      def test_with_connection
+        assert_equal 0, active_connections(pool).size
+
+        main_thread = pool.connection
+        assert_equal 1, active_connections(pool).size
+
+        Thread.new {
+          pool.with_connection do |conn|
+            assert conn
+            assert_equal 2, active_connections(pool).size
+          end
+          assert_equal 1, active_connections(pool).size
+        }.join
+
+        main_thread.close
+        assert_equal 0, active_connections(pool).size
+      end
+
+      def test_active_connection_in_use
+        assert !pool.active_connection?
+        main_thread = pool.connection
+
+        assert pool.active_connection?
+
+        main_thread.close
+
+        assert !pool.active_connection?
+      end
+
+      def test_full_pool_exception
+        pool.size.times { pool.checkout }
+        assert_raise(ConnectionTimeoutError) do
+          pool.checkout
+        end
+      end
+
+      def test_full_pool_blocks
+        cs = pool.size.times.map { pool.checkout }
+        t = Thread.new { pool.checkout }
+
+        # make sure our thread is in the timeout section
+        Thread.pass until t.status == "sleep"
+
+        connection = cs.first
+        connection.close
+        assert_equal connection, t.join.value
+      end
+
+      def test_removing_releases_latch
+        cs = pool.size.times.map { pool.checkout }
+        t = Thread.new { pool.checkout }
+
+        # make sure our thread is in the timeout section
+        Thread.pass until t.status == "sleep"
+
+        connection = cs.first
+        pool.remove connection
+        assert_respond_to t.join.value, :execute
+        connection.close
+      end
+
+      def test_reap_and_active
+        pool.checkout
+        pool.checkout
+        pool.checkout
+
+        connections = pool.connections.dup
+
+        pool.reap
+
+        assert_equal connections.length, pool.connections.length
+      end
+
+      def test_reap_inactive
+        ready = Queue.new
+        pool.checkout
+        child = Thread.new do
+          pool.checkout
+          pool.checkout
+          ready.push 42
+          # Thread.stop
+        end
+        ready.pop # awaits
+
+        assert_equal 3, active_connections.size
+
+        child.terminate
+        child.join
+        pool.reap
+
+        # TODO this does not pass on built-in pool (MRI assumption) :
+        #assert_equal 1, active_connections.size
+      ensure
+        pool.connections.each(&:close)
+      end
+
+      def test_remove_connection
+        conn = pool.checkout
+        assert conn.in_use?
+
+        length = pool.connections.length
+        pool.remove conn
+        assert conn.in_use?
+        assert_equal(length - 1, pool.connections.length)
+      ensure
+        conn.close if conn
+      end
+
+      def test_remove_connection_for_thread
+        conn = pool.connection
+        pool.remove conn
+        assert_not_equal(conn, pool.connection)
+      ensure
+        conn.close if conn
+      end
+
+      def test_active_connection?
+        assert_false pool.active_connection?
+        assert pool.connection
+        assert_true pool.active_connection?
+        pool.release_connection
+        assert_false pool.active_connection?
+      end
+
+      def test_checkout_behaviour
+        assert connection = pool.connection
+        threads = []
+        4.times do |i|
+          threads << Thread.new(i) do
+            connection = pool.connection
+            assert_not_nil connection
+            connection.close
+          end
+        end
+
+        threads.each(&:join)
+
+        Thread.new do
+          assert pool.connection
+          pool.connection.close
+        end.join
+      end
+
+      # The connection pool is "fair" if threads waiting for
+      # connections receive them the order in which they began
+      # waiting. This ensures that we don't timeout one HTTP request
+      # even while well under capacity in a multi-threaded environment
+      # such as a Java servlet container.
+      #
+      # We don't need strict fairness: if two connections become
+      # available at the same time, it's fine of two threads that were
+      # waiting acquire the connections out of order.
+      #
+      # Thus this test prepares waiting threads and then trickles in
+      # available connections slowly, ensuring the wakeup order is
+      # correct in this case.
+      def test_checkout_fairness
+        @pool.instance_variable_set(:@size, 10)
+        expected = (1..@pool.size).to_a.freeze
+        # check out all connections so our threads start out waiting
+        conns = expected.map { @pool.checkout }
+        mutex = Mutex.new
+        order = []
+        errors = []
+
+        threads = expected.map do |i|
+          t = Thread.new {
+            begin
+              @pool.checkout # never checked back in
+              mutex.synchronize { order << i }
+            rescue => e
+              mutex.synchronize { errors << e }
+            end
+          }
+          sleep(0.01) # "tuning" for JRuby
+          Thread.pass until t.status == 'sleep'
+          t
+        end
+
+        # this should wake up the waiting threads one by one in order
+        conns.each { |conn| @pool.checkin(conn); sleep 0.1 }
+
+        threads.each(&:join)
+
+        raise errors.first if errors.any?
+
+        assert_equal(expected, order)
+      end
+
+      # As mentioned in #test_checkout_fairness, we don't care about
+      # strict fairness. This test creates two groups of threads:
+      # group1 whose members all start waiting before any thread in
+      # group2. Enough connections are checked in to wakeup all
+      # group1 threads, and the fact that only group1 and no group2
+      # threads acquired a connection is enforced.
+      def test_checkout_fairness_by_group
+        @pool.instance_variable_set(:@size, 10)
+        # take all the connections
+        conns = (1..10).map { @pool.checkout }
+        mutex = Mutex.new
+        successes = [] # threads that successfully got a connection
+        errors = []
+
+        make_thread = proc do |i|
+          t = Thread.new {
+            begin
+              @pool.checkout # never checked back in
+              mutex.synchronize { successes << i }
+            rescue => e
+              mutex.synchronize { errors << e }
+            end
+          }
+          sleep(0.01) # "tuning" for JRuby
+          Thread.pass until t.status == 'sleep'
+          t
+        end
+
+        # all group1 threads start waiting before any in group2
+        group1 = (1..5).map(&make_thread)
+        sleep(0.05) # "tuning" for JRuby
+        group2 = (6..10).map(&make_thread)
+
+        # checkin n connections back to the pool
+        checkin = proc do |n|
+          n.times do
+            c = conns.pop
+            @pool.checkin(c)
+          end
+        end
+
+        checkin.call(group1.size) # should wake up all group1
+
+        loop do
+          sleep 0.1
+          break if mutex.synchronize { (successes.size + errors.size) == group1.size }
+        end
+
+        winners = mutex.synchronize { successes.dup }
+        checkin.call(group2.size) # should wake up everyone remaining
+
+        group1.each(&:join); group2.each(&:join)
+
+        assert_equal (1..group1.size).to_a, winners.sort
+
+        if errors.any?
+          raise errors.first
+        end
+      end
+
+      def test_automatic_reconnect=
+        assert pool.automatic_reconnect
+        assert pool.connection
+
+        pool.disconnect!
+        assert pool.connection
+
+        pool.disconnect!
+        pool.automatic_reconnect = false
+
+        assert_raise(ConnectionNotEstablished) do
+          pool.connection
+        end
+
+        assert_raise(ConnectionNotEstablished) do
+          pool.with_connection
+        end
+      end
+
+      def test_pool_sets_connection_visitor
+        assert pool.connection.visitor.is_a?(Arel::Visitors::ToSql)
+      end
+
+      # make sure exceptions are thrown when establish_connection
+      # is called with an anonymous class
+      #def test_anonymous_class_exception
+        #anonymous = Class.new(ActiveRecord::Base)
+        #handler = ActiveRecord::Base.connection_handler
+
+        #assert_raises(RuntimeError) {
+        #  handler.establish_connection anonymous, nil
+        #}
+        # assert_raises { handler.establish_connection anonymous, nil }
+      #end
+
+      private
+
+      def active_connections(pool = self.pool)
+        pool.connections.find_all(&:in_use?)
+      end
+
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,304 @@
+require 'bundler/setup'
+
+# ENV variables supported :
+# - AR_POOL_SIZE=42 for testing out with higher pools
+# - AR_POOL_CHECKOUT_TIMEOUT=2 for changing the pool connection acquire timeout
+# - AR_POOL_PREFILL=10 how many connections to "prefill" the pool with on start
+# - AR_POOL_SHARED=true/false or size/percentage (0.0-1.0) connection sharing
+# - AR_PREPARED_STATEMENTS=true/false
+
+connect_timeout = 5
+checkout_timeout = 2.5 # default is to wait 5 seconds when all connections used
+pool_size = 10
+#pool_prefill = 10 # (or simply true/false) how many connections to initialize
+shared_pool = 0.75 # shareable pool true/false or size (integer or percentage)
+ENV['DB_POOL_SHARED'] ||= 0.5.to_s
+
+# NOTE: max concurrent threads handled before explicit locking with shared :
+#   pool_size - ( pool_size * shared_pool ) * MAX_THREAD_SHARING (5)
+#   e.g. 40 - ( 40 * 0.75 ) * 5 = 160
+
+require 'active_record'
+
+require 'logger'
+ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+#shared_pool = ENV['AR_POOL_SHARED'] ? # with AR_POOL_SHARED=true use default
+#  ( ENV['AR_POOL_SHARED'] == 'true' ? shared_pool : ENV['AR_POOL_SHARED'] ) :
+#    shared_pool
+#if shared_pool && shared_pool.to_s != 'false'
+#  shared_pool = Float(shared_pool) rescue nil # to number if number
+#  require 'active_record/connection_adapters/shareable_connection_pool'
+#  # ActiveRecord::Base.default_connection_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+#  pool_class = ActiveRecord::ConnectionAdapters::ShareableConnectionPool
+#  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']
+if url = ENV['AR_URL'] || ENV['JDBC_URL']
+  config[:'url'] = url
+else
+  config[:'database'] = ENV['AR_DATABASE'] || 'ar_basin'
+end
+
+config[:'pool'] = ENV['AR_POOL_SIZE'] ? ENV['AR_POOL_SIZE'].to_i : pool_size
+config[:'shared_pool'] = ENV['AR_POOL_SHARED'] || shared_pool
+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
+
+checkout_timeout = ENV['AR_POOL_CHECKOUT_TIMEOUT'] || checkout_timeout
+config[:'checkout_timeout'] = checkout_timeout.to_f if checkout_timeout
+
+AR_CONFIG = config
+
+pool_prefill = ENV['AR_POOL_PREFILL']
+pool_prefill = config[:'pool'] if pool_prefill.to_s == 'true'
+pool_prefill = 0 if pool_prefill.to_s == 'false'
+config[:'pool_prefill'] = pool_prefill.to_i if pool_prefill # NOTE: not yet used
+
+unless ENV['Rake'] == 'true'
+  gem 'test-unit'
+  require 'test/unit'
+
+  ActiveRecord::Base.logger.debug "database configuration: #{config.inspect}"
+end
+
+#if ( pool_prefill = ( pool_prefill || 10 ).to_i ) > 0
+#  pool_prefill = pool.size if pool_prefill > pool.size
+#
+#  conns = []; start = Time.now
+#  ActiveRecord::Base.logger.info "pre-filling pool with #{pool_prefill}/#{pool.size} connections"
+#  begin
+#    pool_prefill.times { conns << pool.checkout }
+#  ensure
+#    conns.each { |conn| pool.checkin(conn) }
+#  end
+#
+#  # NOTE: for 50 connections ~ 2 seconds but in real time this might get
+#  # slower due synchronization - more threads using the pool = more time
+#  ActiveRecord::Base.logger.debug "pre-filling connection pool took #{Time.now - start}"
+#end
+#
+#if ENV['AR_POOL_BENCHMARK'] && ENV['AR_POOL_BENCHMARK'].to_s != 'false'
+#  require 'active_record/connection_adapters/pool_benchmark'
+#  pool.extend ActiveRecord::ConnectionAdapters::PoolBenchmark
+#end
+
+require 'active_record/bogacs'
+
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__))
+
+module ActiveRecord
+  module ConnectionAdapters
+    ConnectionPool.class_eval do
+      attr_reader :size # only since 4.x
+      attr_reader :available # the custom Queue
+      attr_reader :reserved_connections # Thread-Cache
+      # attr_reader :connections # created connections
+    end
+    autoload :ConnectionPoolTestMethods, 'active_record/connection_pool_test_methods'
+  end
+end
+
+module ActiveRecord
+  module Bogacs
+
+    module TestHelper
+
+      def _test_name
+        @method_name # @__name__ on mini-test
+      end
+      private :_test_name
+
+      def with_connection(config)
+        ActiveRecord::Base.establish_connection config
+        yield ActiveRecord::Base.connection
+      ensure
+        ActiveRecord::Base.connection.disconnect!
+      end
+
+      def with_connection_removed
+        connection = ActiveRecord::Base.remove_connection
+        begin
+          yield
+        ensure
+          ActiveRecord::Base.establish_connection connection
+        end
+      end
+
+#      def with_connection_removed
+#        configurations = ActiveRecord::Base.configurations
+#        connection_config = current_connection_config
+#        # ActiveRecord::Base.connection.disconnect!
+#        ActiveRecord::Base.remove_connection
+#        begin
+#          yield connection_config.dup
+#        ensure
+#          # ActiveRecord::Base.connection.disconnect!
+#          ActiveRecord::Base.remove_connection
+#          ActiveRecord::Base.configurations = configurations
+#          ActiveRecord::Base.establish_connection connection_config
+#        end
+#      end
+
+      module_function
+
+      def current_connection_config
+        if ActiveRecord::Base.respond_to?(:connection_config)
+          ActiveRecord::Base.connection_config
+        else
+          ActiveRecord::Base.connection_pool.spec.config
+        end
+      end
+
+      def silence_deprecations(&block)
+        ActiveSupport::Deprecation.silence(&block)
+      end
+
+#      def disable_logger(connection, &block)
+#        raise "need a block" unless block_given?
+#        return disable_connection_logger(connection, &block) if connection
+#        logger = ActiveRecord::Base.logger
+#        begin
+#          ActiveRecord::Base.logger = nil
+#          yield
+#        ensure
+#          ActiveRecord::Base.logger = logger
+#        end
+#      end
+#
+#      def disable_connection_logger(connection)
+#        logger = connection.send(:instance_variable_get, :@logger)
+#        begin
+#          connection.send(:instance_variable_set, :@logger, nil)
+#          yield
+#        ensure
+#          connection.send(:instance_variable_set, :@logger, logger)
+#        end
+#      end
+
+      protected
+
+      @@sample_query = ENV['SAMPLE_QUERY']
+      @@test_query = ENV['TEST_QUERY'] || @@sample_query
+
+      def sample_query
+        @@sample_query ||= begin
+          case current_connection_config[:adapter]
+          when /mysql/ then 'SHOW VARIABLES LIKE "%version%"'
+          when /postgresql/ then 'SELECT version()'
+          else 'SELECT 42'
+          end
+        end
+      end
+
+      def test_query
+        @@test_query ||= begin
+          case current_connection_config[:adapter]
+          when /mysql/ then 'SELECT DATABASE() FROM DUAL'
+          when /postgresql/ then 'SELECT current_database()'
+          else sample_query
+          end
+        end
+      end
+
+    end
+
+    module JndiTestHelper
+
+      def setup_jdbc_context
+        load 'test/jars/tomcat-juli.jar'
+        load 'test/jars/tomcat-catalina.jar'
+
+        java.lang.System.set_property(
+            javax.naming.Context::INITIAL_CONTEXT_FACTORY,
+            'org.apache.naming.java.javaURLContextFactory'
+        )
+        java.lang.System.set_property(
+            javax.naming.Context::URL_PKG_PREFIXES,
+            'org.apache.naming'
+        )
+
+        init_context = javax.naming.InitialContext.new
+        begin
+          init_context.create_subcontext 'jdbc'
+        rescue javax.naming.NameAlreadyBoundException
+        end
+      end
+
+      def init_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)
+
+        data_source.setJmxEnabled false
+
+        data_source
+      end
+
+      def configure_dbcp_data_source_attributes(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.setDriverClassName driver
+        data_source.setUrl ar_jdbc_config[:url]
+        data_source.setUsername ar_jdbc_config[:username] if ar_jdbc_config[:username]
+        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.setDbProperties properties
+        end
+        # JDBC pool tunings (some mapped from AR configuration) :
+        if ar_jdbc_config[:pool] # default is 100
+          data_source.setMaxActive ar_jdbc_config[:pool]
+          if prefill = ar_jdbc_config[:pool_prefill]
+            data_source.setInitialSize prefill
+          end
+          if data_source.max_active < data_source.max_idle
+            data_source.setMaxIdle data_source.max_active
+          end
+        end
+        max_wait = ar_jdbc_config[:checkout_timeout] || 5
+        data_source.setMaxWait max_wait * 1000 # default is 30s
+
+        data_source.setTestWhileIdle false # default
+
+        #data_source.setRemoveAbandoned false
+        #data_source.setLogAbandoned true
+      end
+      private :configure_dbcp_data_source_attributes
+
+      def bind_data_source(data_source, jndi_name = jndi_config[:jndi])
+        load_driver
+        javax.naming.InitialContext.new.bind jndi_name, data_source
+      end
+
+      def load_driver
+        jdbc_driver_module.load_driver
+      end
+
+      def jdbc_driver_module
+        driver = jndi_config[:adapter]
+        driver = 'postgres' if driver == 'postgresql'
+        require "jdbc/#{driver}"
+        ::Jdbc.const_get ::Jdbc.constants.first
+      end
+
+      def jndi_config
+        @jndi_config ||= { :adapter => AR_CONFIG[:adapter], :jndi => jndi_name }
+      end
+
+      def jndi_name; 'jdbc/TestDB' end
+
+    end
+  end
+end