connection_pool 2.1.3 → 2.2.4

data/lib/connection_pool/version.rb

@@ -1,3 +1,3 @@
 class ConnectionPool
-  VERSION = "2.1.3"
+  VERSION = "2.2.4"
 end

data/lib/connection_pool/wrapper.rb

@@ -0,0 +1,51 @@
+class ConnectionPool
+  class Wrapper < ::BasicObject
+    METHODS = [:with, :pool_shutdown, :wrapped_pool]
+
+    def initialize(options = {}, &block)
+      @pool = options.fetch(:pool) { ::ConnectionPool.new(options, &block) }
+    end
+
+    def wrapped_pool
+      @pool
+    end
+
+    def with(&block)
+      @pool.with(&block)
+    end
+
+    def pool_shutdown(&block)
+      @pool.shutdown(&block)
+    end
+
+    def pool_size
+      @pool.size
+    end
+
+    def pool_available
+      @pool.available
+    end
+
+    def respond_to?(id, *args)
+      METHODS.include?(id) || with { |c| c.respond_to?(id, *args) }
+    end
+
+    # rubocop:disable Style/MethodMissingSuper
+    # rubocop:disable Style/MissingRespondToMissing
+    if ::RUBY_VERSION >= "2.7.0"
+      def method_missing(name, *args, **kwargs, &block)
+        with do |connection|
+          connection.send(name, *args, **kwargs, &block)
+        end
+      end
+    else
+      def method_missing(name, *args, &block)
+        with do |connection|
+          connection.send(name, *args, &block)
+        end
+      end
+    end
+    # rubocop:enable Style/MethodMissingSuper
+    # rubocop:enable Style/MissingRespondToMissing
+  end
+end

data/test/helper.rb

@@ -1,8 +1,8 @@
-gem 'minitest'
+gem "minitest"
 
-require 'minitest/pride'
-require 'minitest/autorun'
+require "minitest/pride"
+require "minitest/autorun"
 
 $VERBOSE = 1
 
-require_relative '../lib/connection_pool'
+require_relative "../lib/connection_pool"

data/test/test_connection_pool.rb

@@ -1,15 +1,16 @@
-require_relative 'helper'
+require_relative "helper"
 
 class TestConnectionPool < Minitest::Test
-
   class NetworkConnection
+    SLEEP_TIME = 0.1
+
     def initialize
       @x = 0
     end
 
-    def do_something
-      @x += 1
-      sleep 0.05
+    def do_something(*_args, increment: 1)
+      @x += increment
+      sleep SLEEP_TIME
       @x
     end
 
@@ -19,7 +20,7 @@ class TestConnectionPool < Minitest::Test
 
     def do_something_with_block
       @x += yield
-      sleep 0.05
+      sleep SLEEP_TIME
       @x
     end
 
@@ -41,12 +42,12 @@ class TestConnectionPool < Minitest::Test
   end
 
   def use_pool(pool, size)
-    Array.new(size) do
+    Array.new(size) {
       Thread.new do
-        pool.with do sleep end
+        pool.with { sleep }
       end
-    end.each do |thread|
-      Thread.pass until thread.status == 'sleep'
+    }.each do |thread|
+      Thread.pass until thread.status == "sleep"
     end
   end
 
@@ -58,33 +59,38 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_basic_multithreaded_usage
-    pool = ConnectionPool.new(:size => 5) { NetworkConnection.new }
+    pool_size = 5
+    pool = ConnectionPool.new(size: pool_size) { NetworkConnection.new }
+
+    start = Time.new
+
+    generations = 3
 
-    threads = Array.new(15) do
+    result = Array.new(pool_size * generations) {
       Thread.new do
         pool.with do |net|
           net.do_something
         end
       end
-    end
+    }.map(&:value)
+
+    finish = Time.new
+
+    assert_equal((1..generations).cycle(pool_size).sort, result.sort)
 
-    a = Time.now
-    result = threads.map(&:value)
-    b = Time.now
-    assert_operator((b - a), :>, 0.125)
-    assert_equal([1,2,3].cycle(5).sort, result.sort)
+    assert_operator(finish - start, :>, generations * NetworkConnection::SLEEP_TIME)
   end
 
   def test_timeout
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { NetworkConnection.new }
-    thread = Thread.new do
+    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
+    thread = Thread.new {
       pool.with do |net|
         net.do_something
         sleep 0.01
       end
-    end
+    }
 
-    Thread.pass while thread.status == 'run'
+    Thread.pass while thread.status == "run"
 
     assert_raises Timeout::Error do
       pool.with { |net| net.do_something }
@@ -98,79 +104,132 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_with
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { Object.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
 
     pool.with do
-      assert_raises Timeout::Error do
-        Thread.new { pool.checkout }.join
-      end
+      Thread.new {
+        assert_raises Timeout::Error do
+          pool.checkout
+        end
+      }.join
     end
 
     assert Thread.new { pool.checkout }.join
   end
 
-  def test_with_with_dangerous_timeouts
-    case RUBY_ENGINE.to_sym
-    when :jruby
-      skip('JRuby GC dislikes this test')
-    when :ruby
-      if RUBY_VERSION == '2.0.0' && RUBY_PATCHLEVEL == 598
-        skip("#{RUBY_VERSION}p#{RUBY_PATCHLEVEL} GC dislikes this test")
+  def test_then
+    pool = ConnectionPool.new { Object.new }
+
+    assert_equal pool.method(:then), pool.method(:with)
+  end
+
+  def test_with_timeout
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
+
+    assert_raises Timeout::Error do
+      Timeout.timeout(0.01) do
+        pool.with do |obj|
+          assert_equal 0, pool.available
+          sleep 0.015
+        end
       end
     end
+    assert_equal 1, pool.available
+  end
 
-    marker_class = Class.new
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { marker_class.new }
+  def test_invalid_size
+    assert_raises ArgumentError, TypeError do
+      ConnectionPool.new(timeout: 0, size: nil) { Object.new }
+    end
+    assert_raises ArgumentError, TypeError do
+      ConnectionPool.new(timeout: 0, size: "") { Object.new }
+    end
+  end
 
-    # no "connections" allocated yet
-    assert_equal [], ObjectSpace.each_object(marker_class).to_a
+  def test_handle_interrupt_ensures_checkin
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
+    def pool.checkout(options)
+      sleep 0.015
+      super
+    end
 
-    checkin_time = 0.05
+    did_something = false
 
-    assert_raises Timeout::Error do
-      Timeout.timeout(checkin_time) do
-        pool.with do
-          # a "connection" has been allocated
-          refute_equal [], ObjectSpace.each_object(marker_class).to_a
-          sleep 2 * checkin_time
+    action = lambda do
+      Timeout.timeout(0.01) do
+        pool.with do |obj|
+          did_something = true
+          # Timeout::Error will be triggered by any non-trivial Ruby code
+          # executed here since it couldn't be raised during checkout.
+          # It looks like setting the local variable above does not trigger
+          # the Timeout check in MRI 2.2.1.
+          obj.tap { obj.hash }
         end
       end
     end
 
-    GC.start
+    if RUBY_ENGINE == "ruby"
+      # These asserts rely on the Ruby implementation reaching `did_something =
+      # true` before the interrupt is detected by the thread. Interrupt
+      # detection timing is implementation-specific in practice, with JRuby,
+      # Rubinius, and TruffleRuby all having different interrupt timings to MRI.
+      # In fact they generally detect interrupts more quickly than MRI, so they
+      # may not reach `did_something = true` before detecting the interrupt.
+
+      assert_raises Timeout::Error, &action
+
+      assert did_something
+    else
+      action.call
+    end
+
+    assert_equal 1, pool.available
+  end
+
+  def test_explicit_return
+    pool = ConnectionPool.new(timeout: 0, size: 1) {
+      mock = Minitest::Mock.new
+      def mock.disconnect!
+        raise "should not disconnect upon explicit return"
+      end
+      mock
+    }
 
-    # no dangling references to this "connection" remain
-    assert_equal [], ObjectSpace.each_object(marker_class).to_a
+    pool.with do |conn|
+      return true
+    end
   end
 
   def test_with_timeout_override
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { NetworkConnection.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
 
-    t = Thread.new do
+    t = Thread.new {
       pool.with do |net|
         net.do_something
         sleep 0.01
       end
-    end
+    }
 
-    Thread.pass while t.status == 'run'
+    Thread.pass while t.status == "run"
 
     assert_raises Timeout::Error do
       pool.with { |net| net.do_something }
     end
 
-    pool.with(:timeout => 0.1) do |conn|
+    pool.with(timeout: 2 * NetworkConnection::SLEEP_TIME) do |conn|
       refute_nil conn
     end
   end
 
   def test_checkin
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { NetworkConnection.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
     conn = pool.checkout
 
-    assert_raises Timeout::Error do
-      Thread.new { pool.checkout }.join
-    end
+    Thread.new {
+      assert_raises Timeout::Error do
+        pool.checkout
+      end
+    }.join
 
     pool.checkin
 
@@ -178,22 +237,19 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_returns_value
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { Object.new }
-    assert_equal 1, pool.with {|o| 1 }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
+    assert_equal 1, pool.with { |o| 1 }
   end
 
   def test_checkin_never_checkout
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { Object.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
 
-    e = assert_raises ConnectionPool::Error do
-      pool.checkin
-    end
-
-    assert_equal 'no connections are checked out', e.message
+    e = assert_raises(ConnectionPool::Error) { pool.checkin }
+    assert_equal "no connections are checked out", e.message
   end
 
   def test_checkin_no_current_checkout
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { Object.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
 
     pool.checkout
     pool.checkin
@@ -204,18 +260,18 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_checkin_twice
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { Object.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
 
     pool.checkout
     pool.checkout
 
     pool.checkin
 
-    assert_raises Timeout::Error do
-      Thread.new do
+    Thread.new {
+      assert_raises Timeout::Error do
         pool.checkout
-      end.join
-    end
+      end
+    }.join
 
     pool.checkin
 
@@ -223,7 +279,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_checkout
-    pool = ConnectionPool.new(:size => 1) { NetworkConnection.new }
+    pool = ConnectionPool.new(size: 1) { NetworkConnection.new }
 
     conn = pool.checkout
 
@@ -233,18 +289,18 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_checkout_multithread
-    pool = ConnectionPool.new(:size => 2) { NetworkConnection.new }
+    pool = ConnectionPool.new(size: 2) { NetworkConnection.new }
     conn = pool.checkout
 
-    t = Thread.new do
+    t = Thread.new {
       pool.checkout
-    end
+    }
 
     refute_same conn, t.value
   end
 
   def test_checkout_timeout
-    pool = ConnectionPool.new(:timeout => 0, :size => 0) { Object.new }
+    pool = ConnectionPool.new(timeout: 0, size: 0) { Object.new }
 
     assert_raises Timeout::Error do
       pool.checkout
@@ -252,34 +308,35 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_checkout_timeout_override
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { NetworkConnection.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
 
-    thread = Thread.new do
+    thread = Thread.new {
       pool.with do |net|
         net.do_something
         sleep 0.01
       end
-    end
+    }
 
-    Thread.pass while thread.status == 'run'
+    Thread.pass while thread.status == "run"
 
     assert_raises Timeout::Error do
       pool.checkout
     end
 
-    assert pool.checkout :timeout => 0.1
+    assert pool.checkout timeout: 2 * NetworkConnection::SLEEP_TIME
   end
 
   def test_passthru
-    pool = ConnectionPool.wrap(:timeout => 0.1, :size => 1) { NetworkConnection.new }
+    pool = ConnectionPool.wrap(timeout: 2 * NetworkConnection::SLEEP_TIME, size: 1) { NetworkConnection.new }
     assert_equal 1, pool.do_something
     assert_equal 2, pool.do_something
     assert_equal 5, pool.do_something_with_block { 3 }
     assert_equal 6, pool.with { |net| net.fast }
+    assert_equal 8, pool.do_something(increment: 2)
   end
 
   def test_passthru_respond_to
-    pool = ConnectionPool.wrap(:timeout => 0.1, :size => 1) { NetworkConnection.new }
+    pool = ConnectionPool.wrap(timeout: 2 * NetworkConnection::SLEEP_TIME, size: 1) { NetworkConnection.new }
     assert pool.respond_to?(:with)
     assert pool.respond_to?(:do_something)
     assert pool.respond_to?(:do_magic)
@@ -287,67 +344,67 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_return_value
-    pool = ConnectionPool.new(:timeout => 0.1, :size => 1) { NetworkConnection.new }
-    result = pool.with do |net|
+    pool = ConnectionPool.new(timeout: 2 * NetworkConnection::SLEEP_TIME, size: 1) { NetworkConnection.new }
+    result = pool.with { |net|
       net.fast
-    end
+    }
     assert_equal 1, result
   end
 
   def test_heavy_threading
-    pool = ConnectionPool.new(:timeout => 0.5, :size => 3) { NetworkConnection.new }
+    pool = ConnectionPool.new(timeout: 0.5, size: 3) { NetworkConnection.new }
 
-    threads = Array.new(20) do
+    threads = Array.new(20) {
       Thread.new do
         pool.with do |net|
           sleep 0.01
         end
       end
-    end
+    }
 
     threads.map { |thread| thread.join }
   end
 
   def test_reuses_objects_when_pool_not_saturated
-    pool = ConnectionPool.new(:size => 5) { NetworkConnection.new }
+    pool = ConnectionPool.new(size: 5) { NetworkConnection.new }
 
-    ids = 10.times.map do
+    ids = 10.times.map {
       pool.with { |c| c.object_id }
-    end
+    }
 
     assert_equal 1, ids.uniq.size
   end
 
   def test_nested_checkout
     recorder = Recorder.new
-    pool = ConnectionPool.new(:size => 1) { recorder }
+    pool = ConnectionPool.new(size: 1) { recorder }
     pool.with do |r_outer|
-      @other = Thread.new do |t|
+      @other = Thread.new { |t|
         pool.with do |r_other|
-          r_other.do_work('other')
+          r_other.do_work("other")
         end
-      end
+      }
 
       pool.with do |r_inner|
-        r_inner.do_work('inner')
+        r_inner.do_work("inner")
       end
 
       Thread.pass
 
-      r_outer.do_work('outer')
+      r_outer.do_work("outer")
     end
 
     @other.join
 
-    assert_equal ['inner', 'outer', 'other'], recorder.calls
+    assert_equal ["inner", "outer", "other"], recorder.calls
   end
 
   def test_shutdown_is_executed_for_all_connections
     recorders = []
 
-    pool = ConnectionPool.new(:size => 3) do
+    pool = ConnectionPool.new(size: 3) {
       Recorder.new.tap { |r| recorders << r }
-    end
+    }
 
     threads = use_pool pool, 3
 
@@ -361,9 +418,9 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_raises_error_after_shutting_down
-    pool = ConnectionPool.new(:size => 1) { true }
+    pool = ConnectionPool.new(size: 1) { true }
 
-    pool.shutdown { }
+    pool.shutdown {}
 
     assert_raises ConnectionPool::PoolShuttingDownError do
       pool.checkout
@@ -373,9 +430,9 @@ class TestConnectionPool < Minitest::Test
   def test_runs_shutdown_block_asynchronously_if_connection_was_in_use
     recorders = []
 
-    pool = ConnectionPool.new(:size => 3) do
+    pool = ConnectionPool.new(size: 3) {
       Recorder.new.tap { |r| recorders << r }
-    end
+    }
 
     threads = use_pool pool, 2
 
@@ -395,7 +452,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_raises_an_error_if_shutdown_is_called_without_a_block
-    pool = ConnectionPool.new(:size => 1) { }
+    pool = ConnectionPool.new(size: 1) {}
 
     assert_raises ArgumentError do
       pool.shutdown
@@ -405,9 +462,9 @@ class TestConnectionPool < Minitest::Test
   def test_shutdown_is_executed_for_all_connections_in_wrapped_pool
     recorders = []
 
-    wrapper = ConnectionPool::Wrapper.new(:size => 3) do
+    wrapper = ConnectionPool::Wrapper.new(size: 3) {
       Recorder.new.tap { |r| recorders << r }
-    end
+    }
 
     threads = use_pool wrapper, 3
 
@@ -420,6 +477,11 @@ class TestConnectionPool < Minitest::Test
     assert_equal [["shutdown"]] * 3, recorders.map { |r| r.calls }
   end
 
+  def test_wrapper_wrapped_pool
+    wrapper = ConnectionPool::Wrapper.new { NetworkConnection.new }
+    assert_equal ConnectionPool, wrapper.wrapped_pool.class
+  end
+
   def test_wrapper_method_missing
     wrapper = ConnectionPool::Wrapper.new { NetworkConnection.new }
 
@@ -436,17 +498,17 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_wrapper_with
-    wrapper = ConnectionPool::Wrapper.new(:timeout => 0, :size => 1) { Object.new }
+    wrapper = ConnectionPool::Wrapper.new(timeout: 0, size: 1) { Object.new }
 
     wrapper.with do
-      assert_raises Timeout::Error do
-        Thread.new do
-          wrapper.with { flunk 'connection checked out :(' }
-        end.join
-      end
+      Thread.new {
+        assert_raises Timeout::Error do
+          wrapper.with { flunk "connection checked out :(" }
+        end
+      }.join
     end
 
-    assert Thread.new { wrapper.with { } }.join
+    assert Thread.new { wrapper.with {} }.join
   end
 
   class ConnWithEval
@@ -461,4 +523,38 @@ class TestConnectionPool < Minitest::Test
     assert_equal "eval'ed 1", wrapper.eval(1)
   end
 
+  def test_wrapper_with_connection_pool
+    recorder = Recorder.new
+    pool = ConnectionPool.new(size: 1) { recorder }
+    wrapper = ConnectionPool::Wrapper.new(pool: pool)
+
+    pool.with { |r| r.do_work("with") }
+    wrapper.do_work("wrapped")
+
+    assert_equal ["with", "wrapped"], recorder.calls
+  end
+
+  def test_stats_without_active_connection
+    pool = ConnectionPool.new(size: 2) { NetworkConnection.new }
+
+    assert_equal(2, pool.size)
+    assert_equal(2, pool.available)
+  end
+
+  def test_stats_with_active_connection
+    pool = ConnectionPool.new(size: 2) { NetworkConnection.new }
+
+    pool.with do
+      assert_equal(1, pool.available)
+    end
+  end
+
+  def test_stats_with_string_size
+    pool = ConnectionPool.new(size: "2") { NetworkConnection.new }
+
+    pool.with do
+      assert_equal(2, pool.size)
+      assert_equal(1, pool.available)
+    end
+  end
 end