activerecord-bogacs 0.1.0

data/lib/active_record/bogacs/version.rb

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

data/lib/active_record/connection_adapters/adapter_compat.rb

@@ -0,0 +1,57 @@
+require 'active_record/connection_adapters/abstract_adapter'
+
+module ActiveRecord
+  module ConnectionAdapters
+    AbstractAdapter.class_eval do
+
+      attr_accessor :pool unless method_defined? :pool
+
+      unless method_defined? :owner
+
+        attr_reader :owner
+
+        if method_defined? :in_use?
+
+          def lease
+            unless in_use?
+              @owner = Thread.current; @in_use = true
+            end
+          end
+
+          def expire
+            @in_use = false; @owner = nil
+          end
+
+        else
+
+          alias :in_use? :owner
+
+          def lease
+            unless in_use?
+              @owner = Thread.current
+            end
+          end
+
+          def expire
+            @owner = nil
+          end
+
+        end
+
+        alias :in_use? :owner
+
+        def lease
+          unless in_use?
+            @owner = Thread.current
+          end
+        end
+
+        def expire
+          @owner = nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/active_record/shared_connection.rb

@@ -0,0 +1,24 @@
+module ActiveRecord
+  module SharedConnection
+
+    def with_shared_connection(&block)
+      ActiveRecord::SharedConnection.with_shared_connection(self.class, &block)
+    end
+
+    # NOTE: shareable pool loaded and setup to be used (from an initializer) :
+    if ActiveRecord::Base.connection_pool.respond_to?(:with_shared_connection)
+
+      def self.with_shared_connection(model = ActiveRecord::Base, &block)
+        model.connection_pool.with_shared_connection(&block)
+      end
+
+    else
+
+      def self.with_shared_connection(model = ActiveRecord::Base, &block)
+        model.connection_pool.with_connection(&block) # default pool is used
+      end
+
+    end
+
+  end
+end

data/test/active_record/bogacs/default_pool_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path('../../test_helper', File.dirname(__FILE__))
+
+ActiveRecord::Bogacs::DefaultPool.class_eval do
+  # ...
+end
+
+module ActiveRecord
+  module Bogacs
+    class DefaultPoolTest < Test::Unit::TestCase
+
+      include ConnectionAdapters::ConnectionPoolTestMethods
+
+      def config; AR_CONFIG end
+
+      def setup
+        super
+        @pool = DefaultPool.new ActiveRecord::Base.connection_pool.spec
+      end
+
+      def test_prefills_initial_connections
+        @pool.disconnect!
+        spec = ActiveRecord::Base.connection_pool.spec.dup
+        spec.instance_variable_set :@config, spec.config.merge(:pool_initial => 1.0)
+        @pool = DefaultPool.new spec
+        assert_equal @pool.size, @pool.connections.size
+      end
+
+      def test_does_not_prefill_connections_by_default
+        assert_equal 0, @pool.connections.size
+      end
+
+    end
+  end
+end

data/test/active_record/bogacs/false_pool_test.rb

@@ -0,0 +1,200 @@
+require File.expand_path('../../test_helper', File.dirname(__FILE__))
+
+require 'atomic'
+
+ActiveRecord::Bogacs::FalsePool.class_eval do
+  # ...
+end
+
+module ActiveRecord
+  module Bogacs
+    class FalsePool
+
+      class TestBase < ::Test::Unit::TestCase
+        # extend Bogacs::TestHelper
+        extend Bogacs::JndiTestHelper
+
+        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
+        end
+
+        def self.shutdown
+          return if self == TestBase
+
+          ActiveRecord::Base.connection_pool.disconnect!
+          ConnectionAdapters::ConnectionHandler.connection_pool_class = ConnectionAdapters::ConnectionPool
+        end
+
+      end
+
+      class ConnectionPoolWrappingTomcatJdbcTest < TestBase
+
+        @@data_source = nil
+        def self.init_data_source(config)
+          @@data_source = init_tomcat_jdbc_data_source(config)
+        end
+
+        include ConnectionAdapters::ConnectionPoolTestMethods
+
+        def setup
+          @pool = FalsePool.new ActiveRecord::Base.connection_pool.spec
+        end
+
+        def teardown
+          @@data_source.send(:close, true) 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')
+        end
+
+        # adjust ConnectionAdapters::ConnectionPoolTestMethods :
+
+        undef :test_checkout_fairness
+        undef :test_checkout_fairness_by_group
+
+        undef :test_released_connection_moves_between_threads
+
+        undef :test_reap_inactive
+
+        undef :test_automatic_reconnect= # or does automatic_reconnect make sense?
+
+        undef :test_removing_releases_latch
+
+        # @override
+        def test_remove_connection
+          conn = pool.checkout
+          assert conn.in_use?
+
+          #length = pool.connections.size
+          pool.remove conn
+          assert conn.in_use?
+          #assert_equal(length - 1, pool.connections.length)
+        ensure
+          conn.close if conn
+        end
+
+        # @override
+        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|
+            threads << Thread.new do
+              begin
+                conn = ActiveRecord::Base.connection
+                threads_block.update { |v| v + 1 }
+                threads_ready << i
+                while threads_block.value != -1 # await
+                  sleep(0.005)
+                end
+              rescue => e
+                puts "block thread failed: #{e.inspect}"
+              ensure
+                conn && conn.close
+              end
+            end
+          end
+          pool_size.times { threads_ready.pop } # awaits
+
+          assert_raise(ConnectionTimeoutError) do
+            ActiveRecord::Base.connection # ~ pool.checkout
+          end
+
+        ensure
+          #connection && connection.close
+          threads_block && threads_block.swap(-1)
+          threads && threads.each(&:join)
+        end
+
+        # @override
+        def test_full_pool_blocks
+          t1_ready = Queue.new; t1_block = Queue.new
+          t1 = Thread.new do
+            begin
+              conn = ActiveRecord::Base.connection
+              t1_ready.push(conn)
+              t1_block.pop # await
+            rescue => e
+              puts "t1 thread failed: #{e.inspect}"
+            ensure
+              conn && conn.close
+            end
+          end
+
+          threads_ready = Queue.new; threads_block = Atomic.new(0); threads = []
+          (pool_size - 1).times do |i|
+            threads << Thread.new do
+              begin
+                conn = ActiveRecord::Base.connection
+                threads_block.update { |v| v + 1 }
+                threads_ready << i
+                while threads_block.value != -1 # await
+                  sleep(0.005)
+                end
+              rescue => e
+                puts "block thread failed: #{e.inspect}"
+              ensure
+                conn && conn.close
+              end
+            end
+          end
+          (pool_size - 1).times { threads_ready.pop } # awaits
+
+          connection = t1_ready.pop
+          t1_jdbc_connection = connection.jdbc_connection(true)
+
+          # pool = ActiveRecord::Base.connection_pool
+
+          t2 = Thread.new do
+            begin
+              ActiveRecord::Base.connection
+            rescue => e
+              puts "t2 thread failed: #{e.inspect}"
+            end
+          end; sleep(0.1)
+
+          # make sure our thread is in the timeout section
+          # Thread.pass until t2.status == "sleep"
+
+          sleep(0.02); assert t2.alive?
+          sleep(0.03); assert t2.alive?
+
+          t1_block.push(:release); t1.join
+
+          sleep(0.01); assert_not_equal 'sleep', t2.status
+
+          if defined? JRUBY_VERSION
+            if connection2 = t2.join.value
+              assert_equal t1_jdbc_connection, connection2.jdbc_connection(true)
+            end
+          end
+
+        ensure
+          #connection && connection.close
+          threads_block && threads_block.swap(-1)
+          threads && threads.each(&:join)
+        end
+
+        private
+
+        def pool_size; @@data_source.max_active end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,186 @@
+require File.expand_path('../shareable_pool_helper', File.dirname(__FILE__))
+
+module ActiveRecord
+  module Bogacs
+    class ShareablePool
+
+      class ConnectionPoolTest < TestBase
+
+        include ConnectionAdapters::ConnectionPoolTestMethods
+
+        def setup
+          @pool = ShareablePool.new ActiveRecord::Base.connection_pool.spec
+        end
+
+        if ActiveRecord::VERSION::MAJOR < 4
+          # TODO override with similar (back-ported) tests :
+          undef :test_remove_connection
+          undef :test_remove_connection_for_thread
+          undef :test_removing_releases_latch
+
+          undef :test_reap_and_active
+          undef :test_reap_inactive
+        end
+
+      end
+
+      class PoolAPITest < TestBase
+
+        def setup; ActiveRecord::Base.connection end
+        # def teardown; ActiveRecord::Base.connection_pool.reap end
+
+        def test_is_setup
+          assert ActiveRecord::Base.connection_pool.is_a? ShareablePool
+        end
+
+        def test_can_checkout_a_connection
+          assert ActiveRecord::Base.connection.exec_query('SELECT 42')
+        end
+
+        def test_connected?
+          assert ActiveRecord::Base.connected?
+          begin
+            ActiveRecord::Base.connection_pool.disconnect!
+            assert ! ActiveRecord::Base.connected?
+          ensure
+            ActiveRecord::Base.connection
+          end
+        end
+
+        def test_active?
+          conn = ActiveRecord::Base.connection
+          conn.exec_query('SELECT 42')
+          assert conn.active?
+          assert reserved_connections.size > 0
+          begin
+            ActiveRecord::Base.clear_active_connections!
+            assert_equal 0, reserved_connections.size
+          ensure
+            ActiveRecord::Base.connection
+          end
+        end
+
+        def test_disconnect!
+          ActiveRecord::Base.connection
+          threads = []
+          threads << Thread.new { ActiveRecord::Base.connection }
+          threads << Thread.new { ActiveRecord::Base.connection }
+          threads.each(&:join)
+
+          begin
+            ActiveRecord::Base.connection_pool.disconnect!
+            assert_equal 0, reserved_connections.size
+            assert_equal 0, connections.size
+            assert_equal 0, shared_connections.size
+          ensure
+            ActiveRecord::Base.connection
+          end
+        end
+
+        def test_clear_reloadable_connections!
+          ActiveRecord::Base.connection
+          threads = []
+          threads << Thread.new { ActiveRecord::Base.connection }
+          threads << Thread.new { ActiveRecord::Base.connection }
+          threads.each(&:join)
+
+          begin
+            ActiveRecord::Base.connection_pool.clear_reloadable_connections!
+            assert_equal 0, reserved_connections.size
+            assert connections.size > 0 # returned
+            assert_equal 0, shared_connections.size
+          ensure
+            ActiveRecord::Base.connection
+          end
+        end
+
+        def test_remove
+          conn = ActiveRecord::Base.connection
+          assert connections.include? conn
+          begin
+            connection_pool.remove(conn)
+            refute connections.include?(conn)
+            refute shared_connection?(conn)
+          ensure
+            ActiveRecord::Base.connection
+          end
+        end if ActiveRecord::VERSION::MAJOR >= 4
+
+      end
+
+      class PoolAPIWithSharedConnectionTest < PoolAPITest
+
+        def setup
+          with_shared_connection do
+            @shared_connection = ActiveRecord::Base.connection
+          end
+        end
+
+        def teardown
+          connection_pool.release_shared_connection(@shared_connection)
+          super
+        end
+
+      end
+
+      class CustomAPITest < TestBase
+
+        def setup
+          connection_pool.disconnect!
+        end
+
+        def teardown
+          clear_active_connections!; clear_shared_connections!
+        end
+
+        def test_with_shared_connection
+          shared_connection = nil
+          assert shared_connections.empty?
+          begin
+            with_shared_connection do |connection|
+              assert shared_connection = connection
+              assert shared_connections.get(connection)
+              assert connections.include?(connection)
+            end
+          ensure
+            connection_pool.remove(shared_connection) if shared_connection
+          end
+        end
+
+        def test_with_shared_connection_disconnected
+          shared_connection = nil
+          begin
+            connections_size = connections.size
+            with_shared_connection do |connection|
+              assert shared_connection = connection
+              assert shared_connection?(connection)
+              assert_equal connections_size + 1, connections.size
+            end
+          ensure
+            connection_pool.remove(shared_connection) if shared_connection
+            ActiveRecord::Base.connection
+          end
+        end
+
+        def test_release_shared_connection
+          begin
+            with_shared_connection do |connection|
+              assert shared_connection?(connection)
+              refute available_connection?(connection)
+
+              connection_pool.release_shared_connection(connection)
+
+              refute shared_connection?(connection)
+              assert available_connection?(connection)
+            end
+          ensure
+            connection_pool.disconnect!
+            ActiveRecord::Base.connection
+          end
+        end
+
+      end
+
+    end
+  end
+end