connection_pool 2.2.5 → 2.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0993b72c233b027a1229d532a126b4a1623ef3f146a7b56502c539084f9a228d'
-  data.tar.gz: 274efa04fc445ca0044f62da29484a4ee9fb5e02b5f213fb873fedfd63cadff0
+  metadata.gz: ea0776fcb09a3cc48ef4ca03774399e20b09e51039d0c47c1e4cb3bac621c52b
+  data.tar.gz: b955d6b4e984259f20ae8cf6414f59692f9a51848424231363643e0c16dd2a3f
 SHA512:
-  metadata.gz: 17c5bea167386115e8672b394138e0f66b55e6371b803dcfee7be08e51c84353aa9cd0257f169ae04053bc95be6b0c9b06576579f4915e68271146b1c9d602a5
-  data.tar.gz: 4eeccb9eaf397e8e386a41f81005b10d43d7441297661ab0d7656b6be30ac7ff1e751a95ed5c5b5a412124a29a0af3f5c90ae2882d70d3fa29d9dc8b2df412e3
+  metadata.gz: bf57d8b5547502d91f5550ca6ea0be16905604c90e61efb6741e5ec3ce607c7a65f0b31e1673c96c60a06a2f64f5239cab6e94d3a50095fb822ea9b1c1bb2f0a
+  data.tar.gz: 4b42aa5aa67b0e45bbbc8a9f29ca3a969efd8ade3b6dfca6cff082f526ec65a2a2e5c8fa17f512d33470b82535af8b675fc80903ccd75db26748e9845dd9a612

data/Changes.md

@@ -1,5 +1,21 @@
 # connection_pool Changelog
 
+2.4.1
+------
+
+- New `auto_reload_after_fork` config option to disable auto-drop [#177, shayonj]
+
+2.4.0
+------
+
+- Automatically drop all connections after fork [#166]
+
+2.3.0
+------
+
+- Minimum Ruby version is now 2.5.0
+- Add pool size to TimeoutError message
+
 2.2.5
 ------
 

data/README.md

@@ -4,16 +4,14 @@ connection\_pool
 
 Generic connection pooling for Ruby.
 
-MongoDB has its own connection pool.  ActiveRecord has its own connection pool.
-This is a generic connection pool that can be used with anything, e.g. Redis,
-Dalli and other Ruby network clients.
-
+MongoDB has its own connection pool.
+ActiveRecord has its own connection pool.
+This is a generic connection pool that can be used with anything, e.g. Redis, Dalli and other Ruby network clients.
 
 Usage
 -----
 
-Create a pool of objects to share amongst the fibers or threads in your Ruby
-application:
+Create a pool of objects to share amongst the fibers or threads in your Ruby application:
 
 ``` ruby
 $memcached = ConnectionPool.new(size: 5, timeout: 5) { Dalli::Client.new }
@@ -28,11 +26,12 @@ end
 ```
 
 If all the objects in the connection pool are in use, `with` will block
-until one becomes available.  If no object is available within `:timeout` seconds,
-`with` will raise a `Timeout::Error`.
+until one becomes available.
+If no object is available within `:timeout` seconds,
+`with` will raise a `ConnectionPool::TimeoutError` (a subclass of `Timeout::Error`).
 
 You can also use `ConnectionPool#then` to support _both_ a
-connection pool and a raw client (requires Ruby 2.5+).
+connection pool and a raw client.
 
 ```ruby
 # Compatible with a raw Redis::Client, and ConnectionPool Redis
@@ -48,15 +47,14 @@ end
 ```
 
 This will only modify the resource-get timeout for this particular
-invocation. This is useful if you want to fail-fast on certain non critical
-sections when a resource is not available, or conversely if you are comfortable
-blocking longer on a particular resource. This is not implemented in the below
-`ConnectionPool::Wrapper` class.
+invocation.
+This is useful if you want to fail-fast on certain non-critical
+sections when a resource is not available, or conversely if you are comfortable blocking longer on a particular resource.
+This is not implemented in the `ConnectionPool::Wrapper` class.
 
 ## Migrating to a Connection Pool
 
-You can use `ConnectionPool::Wrapper` to wrap a single global connection,
-making it easier to migrate existing connection code over time:
+You can use `ConnectionPool::Wrapper` to wrap a single global connection, making it easier to migrate existing connection code over time:
 
 ``` ruby
 $redis = ConnectionPool::Wrapper.new(size: 5, timeout: 3) { Redis.new }
@@ -64,10 +62,8 @@ $redis.sadd('foo', 1)
 $redis.smembers('foo')
 ```
 
-The wrapper uses `method_missing` to checkout a connection, run the requested
-method and then immediately check the connection back into the pool.  It's
-**not** high-performance so you'll want to port your performance sensitive code
-to use `with` as soon as possible.
+The wrapper uses `method_missing` to checkout a connection, run the requested method and then immediately check the connection back into the pool.
+It's **not** high-performance so you'll want to port your performance sensitive code to use `with` as soon as possible.
 
 ``` ruby
 $redis.with do |conn|
@@ -76,31 +72,26 @@ $redis.with do |conn|
 end
 ```
 
-Once you've ported your entire system to use `with`, you can simply remove
-`Wrapper` and use the simpler and faster `ConnectionPool`.
+Once you've ported your entire system to use `with`, you can simply remove `Wrapper` and use the simpler and faster `ConnectionPool`.
 
 
 ## Shutdown
 
 You can shut down a ConnectionPool instance once it should no longer be used.
-Further checkout attempts will immediately raise an error but existing checkouts
-will work.
+Further checkout attempts will immediately raise an error but existing checkouts will work.
 
 ```ruby
 cp = ConnectionPool.new { Redis.new }
-cp.shutdown { |conn| conn.quit }
+cp.shutdown { |c| c.close }
 ```
 
 Shutting down a connection pool will block until all connections are checked in and closed.
-**Note that shutting down is completely optional**; Ruby's garbage collector will reclaim
-unreferenced pools under normal circumstances.
+**Note that shutting down is completely optional**; Ruby's garbage collector will reclaim unreferenced pools under normal circumstances.
 
 ## Reload
 
-You can reload a ConnectionPool instance in the case it is desired to close all
-connections to the pool and, unlike `shutdown`, afterwards recreate connections
-so the pool may continue to be used. Reloading may be useful after forking the
-process.
+You can reload a ConnectionPool instance in the case it is desired to close all connections to the pool and, unlike `shutdown`, afterwards recreate connections so the pool may continue to be used.
+Reloading may be useful after forking the process.
 
 ```ruby
 cp = ConnectionPool.new { Redis.new }
@@ -108,8 +99,7 @@ cp.reload { |conn| conn.quit }
 cp.with { |conn| conn.get('some-count') }
 ```
 
-Like `shutdown`, this will block until all connections are checked in and
-closed.
+Like `shutdown`, this will block until all connections are checked in and closed.
 
 ## Current State
 

data/connection_pool.gemspec

@@ -9,13 +9,16 @@ Gem::Specification.new do |s|
   s.homepage = "https://github.com/mperham/connection_pool"
   s.description = s.summary = "Generic connection pool for Ruby"
 
-  s.files = `git ls-files`.split("\n")
-  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.files = ["Changes.md", "LICENSE", "README.md", "connection_pool.gemspec",
+    "lib/connection_pool.rb", "lib/connection_pool/timed_stack.rb",
+    "lib/connection_pool/version.rb", "lib/connection_pool/wrapper.rb"]
+  s.executables = []
   s.require_paths = ["lib"]
   s.license = "MIT"
   s.add_development_dependency "bundler"
   s.add_development_dependency "minitest", ">= 5.0.0"
   s.add_development_dependency "rake"
-  s.required_ruby_version = ">= 2.2.0"
+  s.required_ruby_version = ">= 2.5.0"
+
+  s.metadata = {"changelog_uri" => "https://github.com/mperham/connection_pool/blob/main/Changes.md", "rubygems_mfa_required" => "true"}
 end

data/lib/connection_pool/timed_stack.rb

@@ -29,8 +29,8 @@ class ConnectionPool::TimedStack
     @created = 0
     @que = []
     @max = size
-    @mutex = Mutex.new
-    @resource = ConditionVariable.new
+    @mutex = Thread::Mutex.new
+    @resource = Thread::ConditionVariable.new
     @shutdown_block = nil
   end
 
@@ -49,7 +49,7 @@ class ConnectionPool::TimedStack
       @resource.broadcast
     end
   end
-  alias << push
+  alias_method :<<, :push
 
   ##
   # Retrieves a connection from the stack.  If a connection is available it is
@@ -74,7 +74,7 @@ class ConnectionPool::TimedStack
         return connection if connection
 
         to_wait = deadline - current_time
-        raise ConnectionPool::TimeoutError, "Waited #{timeout} sec" if to_wait <= 0
+        raise ConnectionPool::TimeoutError, "Waited #{timeout} sec, #{length}/#{@max} available" if to_wait <= 0
         @resource.wait(@mutex, to_wait)
       end
     end
@@ -87,7 +87,7 @@ class ConnectionPool::TimedStack
   # +:reload+ is +true+.
 
   def shutdown(reload: false, &block)
-    raise ArgumentError, "shutdown must receive a block" unless block_given?
+    raise ArgumentError, "shutdown must receive a block" unless block
 
     @mutex.synchronize do
       @shutdown_block = block

data/lib/connection_pool/version.rb

@@ -1,3 +1,3 @@
 class ConnectionPool
-  VERSION = "2.2.5"
+  VERSION = "2.4.1"
 end

data/lib/connection_pool/wrapper.rb

@@ -30,7 +30,6 @@ class ConnectionPool
       METHODS.include?(id) || with { |c| c.respond_to?(id, *args) }
     end
 
-    # rubocop:disable Style/MethodMissingSuper
     # rubocop:disable Style/MissingRespondToMissing
     if ::RUBY_VERSION >= "3.0.0"
       def method_missing(name, *args, **kwargs, &block)

data/lib/connection_pool.rb

@@ -1,9 +1,11 @@
 require "timeout"
-require "connection_pool/version"
+require_relative "connection_pool/version"
 
 class ConnectionPool
   class Error < ::RuntimeError; end
+
   class PoolShuttingDownError < ::ConnectionPool::Error; end
+
   class TimeoutError < ::Timeout::Error; end
 end
 
@@ -34,14 +36,57 @@ end
 # Accepts the following options:
 # - :size - number of connections to pool, defaults to 5
 # - :timeout - amount of time to wait for a connection if none currently available, defaults to 5 seconds
+# - :auto_reload_after_fork - automatically drop all connections after fork, defaults to true
 #
 class ConnectionPool
-  DEFAULTS = {size: 5, timeout: 5}
+  DEFAULTS = {size: 5, timeout: 5, auto_reload_after_fork: true}
 
   def self.wrap(options, &block)
     Wrapper.new(options, &block)
   end
 
+  if Process.respond_to?(:fork)
+    INSTANCES = ObjectSpace::WeakMap.new
+    private_constant :INSTANCES
+
+    def self.after_fork
+      INSTANCES.values.each do |pool|
+        next unless pool.auto_reload_after_fork
+
+        # We're on after fork, so we know all other threads are dead.
+        # All we need to do is to ensure the main thread doesn't have a
+        # checked out connection
+        pool.checkin(force: true)
+        pool.reload do |connection|
+          # Unfortunately we don't know what method to call to close the connection,
+          # so we try the most common one.
+          connection.close if connection.respond_to?(:close)
+        end
+      end
+      nil
+    end
+
+    if ::Process.respond_to?(:_fork) # MRI 3.1+
+      module ForkTracker
+        def _fork
+          pid = super
+          if pid == 0
+            ConnectionPool.after_fork
+          end
+          pid
+        end
+      end
+      Process.singleton_class.prepend(ForkTracker)
+    end
+  else
+    INSTANCES = nil
+    private_constant :INSTANCES
+
+    def self.after_fork
+      # noop
+    end
+  end
+
   def initialize(options = {}, &block)
     raise ArgumentError, "Connection pool requires a block" unless block
 
@@ -49,10 +94,12 @@ class ConnectionPool
 
     @size = Integer(options.fetch(:size))
     @timeout = options.fetch(:timeout)
+    @auto_reload_after_fork = options.fetch(:auto_reload_after_fork)
 
     @available = TimedStack.new(@size, &block)
     @key = :"pool-#{@available.object_id}"
     @key_count = :"pool-#{@available.object_id}-count"
+    INSTANCES[self] = self if INSTANCES
   end
 
   def with(options = {})
@@ -67,7 +114,7 @@ class ConnectionPool
       end
     end
   end
-  alias then with
+  alias_method :then, :with
 
   def checkout(options = {})
     if ::Thread.current[@key]
@@ -79,16 +126,16 @@ class ConnectionPool
     end
   end
 
-  def checkin
+  def checkin(force: false)
     if ::Thread.current[@key]
-      if ::Thread.current[@key_count] == 1
+      if ::Thread.current[@key_count] == 1 || force
         @available.push(::Thread.current[@key])
         ::Thread.current[@key] = nil
         ::Thread.current[@key_count] = nil
       else
         ::Thread.current[@key_count] -= 1
       end
-    else
+    elsif !force
       raise ConnectionPool::Error, "no connections are checked out"
     end
 
@@ -115,6 +162,8 @@ class ConnectionPool
 
   # Size of this connection pool
   attr_reader :size
+  # Automatically drop all connections after fork
+  attr_reader :auto_reload_after_fork
 
   # Number of pool entries available for checkout at this instant.
   def available
@@ -122,5 +171,5 @@ class ConnectionPool
   end
 end
 
-require "connection_pool/timed_stack"
-require "connection_pool/wrapper"
+require_relative "connection_pool/timed_stack"
+require_relative "connection_pool/wrapper"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: connection_pool
 version: !ruby/object:Gem::Version
-  version: 2.2.5
+  version: 2.4.1
 platform: ruby
 authors:
 - Mike Perham
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-14 00:00:00.000000000 Z
+date: 2023-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -61,25 +61,20 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/ci.yml"
-- ".gitignore"
 - Changes.md
-- Gemfile
 - LICENSE
 - README.md
-- Rakefile
 - connection_pool.gemspec
 - lib/connection_pool.rb
 - lib/connection_pool/timed_stack.rb
 - lib/connection_pool/version.rb
 - lib/connection_pool/wrapper.rb
-- test/helper.rb
-- test/test_connection_pool.rb
-- test/test_connection_pool_timed_stack.rb
 homepage: https://github.com/mperham/connection_pool
 licenses:
 - MIT
-metadata: {}
+metadata:
+  changelog_uri: https://github.com/mperham/connection_pool/blob/main/Changes.md
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -88,18 +83,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.4.7
 signing_key:
 specification_version: 4
 summary: Generic connection pool for Ruby
-test_files:
-- test/helper.rb
-- test/test_connection_pool.rb
-- test/test_connection_pool_timed_stack.rb
+test_files: []

data/.github/workflows/ci.yml

@@ -1,26 +0,0 @@
-name: CI
-
-on: [push, pull_request]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    continue-on-error: ${{ matrix.experimental }}
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby: ["2.4", "2.5", "2.6", "2.7", "3.0", "jruby"]
-        experimental: [false]
-        include:
-        - ruby: "truffleruby"
-          experimental: true
-    steps:
-    - uses: actions/checkout@v2
-    - uses: ruby/setup-ruby@v1
-      with:
-        ruby-version: ${{matrix.ruby}}
-        bundler-cache: true
-
-    - name: Run tests
-      timeout-minutes: 5
-      run: ${{matrix.env}} bundle exec rake

data/.gitignore

@@ -1,4 +0,0 @@
-*.gem
-.bundle
-Gemfile.lock
-pkg/*

data/Gemfile

@@ -1,3 +0,0 @@
-source "https://rubygems.org"
-
-gemspec(development_group: :runtime)

data/Rakefile

@@ -1,6 +0,0 @@
-require "bundler/gem_tasks"
-
-require "rake/testtask"
-Rake::TestTask.new
-
-task default: :test

data/test/helper.rb

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

data/test/test_connection_pool.rb

@@ -1,567 +0,0 @@
-require_relative "helper"
-
-class TestConnectionPool < Minitest::Test
-  class NetworkConnection
-    SLEEP_TIME = 0.1
-
-    def initialize
-      @x = 0
-    end
-
-    def do_something(*_args, increment: 1)
-      @x += increment
-      sleep SLEEP_TIME
-      @x
-    end
-
-    def do_something_with_positional_hash(options)
-      @x += options[:increment] || 1
-      sleep SLEEP_TIME
-      @x
-    end
-
-    def fast
-      @x += 1
-    end
-
-    def do_something_with_block
-      @x += yield
-      sleep SLEEP_TIME
-      @x
-    end
-
-    def respond_to?(method_id, *args)
-      method_id == :do_magic || super(method_id, *args)
-    end
-  end
-
-  class Recorder
-    def initialize
-      @calls = []
-    end
-
-    attr_reader :calls
-
-    def do_work(label)
-      @calls << label
-    end
-  end
-
-  def use_pool(pool, size)
-    Array.new(size) {
-      Thread.new do
-        pool.with { sleep }
-      end
-    }.each do |thread|
-      Thread.pass until thread.status == "sleep"
-    end
-  end
-
-  def kill_threads(threads)
-    threads.each do |thread|
-      thread.kill
-      thread.join
-    end
-  end
-
-  def test_basic_multithreaded_usage
-    pool_size = 5
-    pool = ConnectionPool.new(size: pool_size) { NetworkConnection.new }
-
-    start = Time.new
-
-    generations = 3
-
-    result = Array.new(pool_size * generations) {
-      Thread.new do
-        pool.with do |net|
-          net.do_something
-        end
-      end
-    }.map(&:value)
-
-    finish = Time.new
-
-    assert_equal((1..generations).cycle(pool_size).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 {
-      pool.with do |net|
-        net.do_something
-        sleep 0.01
-      end
-    }
-
-    Thread.pass while thread.status == "run"
-
-    assert_raises Timeout::Error do
-      pool.with { |net| net.do_something }
-    end
-
-    thread.join
-
-    pool.with do |conn|
-      refute_nil conn
-    end
-  end
-
-  def test_with
-    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
-
-    pool.with do
-      Thread.new {
-        assert_raises Timeout::Error do
-          pool.checkout
-        end
-      }.join
-    end
-
-    assert Thread.new { pool.checkout }.join
-  end
-
-  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
-
-  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
-
-  def test_handle_interrupt_ensures_checkin
-    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
-    def pool.checkout(options)
-      sleep 0.015
-      super
-    end
-
-    did_something = false
-
-    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
-
-    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
-    }
-
-    pool.with do |conn|
-      return true
-    end
-  end
-
-  def test_with_timeout_override
-    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
-
-    t = Thread.new {
-      pool.with do |net|
-        net.do_something
-        sleep 0.01
-      end
-    }
-
-    Thread.pass while t.status == "run"
-
-    assert_raises Timeout::Error do
-      pool.with { |net| net.do_something }
-    end
-
-    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 }
-    conn = pool.checkout
-
-    Thread.new {
-      assert_raises Timeout::Error do
-        pool.checkout
-      end
-    }.join
-
-    pool.checkin
-
-    assert_same conn, Thread.new { pool.checkout }.value
-  end
-
-  def test_returns_value
-    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 }
-
-    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.checkout
-    pool.checkin
-
-    assert_raises ConnectionPool::Error do
-      pool.checkin
-    end
-  end
-
-  def test_checkin_twice
-    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
-
-    pool.checkout
-    pool.checkout
-
-    pool.checkin
-
-    Thread.new {
-      assert_raises Timeout::Error do
-        pool.checkout
-      end
-    }.join
-
-    pool.checkin
-
-    assert Thread.new { pool.checkout }.join
-  end
-
-  def test_checkout
-    pool = ConnectionPool.new(size: 1) { NetworkConnection.new }
-
-    conn = pool.checkout
-
-    assert_kind_of NetworkConnection, conn
-
-    assert_same conn, pool.checkout
-  end
-
-  def test_checkout_multithread
-    pool = ConnectionPool.new(size: 2) { NetworkConnection.new }
-    conn = pool.checkout
-
-    t = Thread.new {
-      pool.checkout
-    }
-
-    refute_same conn, t.value
-  end
-
-  def test_checkout_timeout
-    pool = ConnectionPool.new(timeout: 0, size: 0) { Object.new }
-
-    assert_raises Timeout::Error do
-      pool.checkout
-    end
-  end
-
-  def test_checkout_timeout_override
-    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
-
-    thread = Thread.new {
-      pool.with do |net|
-        net.do_something
-        sleep 0.01
-      end
-    }
-
-    Thread.pass while thread.status == "run"
-
-    assert_raises Timeout::Error do
-      pool.checkout
-    end
-
-    assert pool.checkout timeout: 2 * NetworkConnection::SLEEP_TIME
-  end
-
-  def test_passthru
-    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)
-    assert_equal 10, pool.do_something_with_positional_hash({ increment: 2, symbol_key: 3, "string_key" => 4 })
-  end
-
-  def test_passthru_respond_to
-    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)
-    refute pool.respond_to?(:do_lots_of_magic)
-  end
-
-  def test_return_value
-    pool = ConnectionPool.new(timeout: 2 * NetworkConnection::SLEEP_TIME, size: 1) { NetworkConnection.new }
-    result = pool.with { |net|
-      net.fast
-    }
-    assert_equal 1, result
-  end
-
-  def test_heavy_threading
-    pool = ConnectionPool.new(timeout: 0.5, size: 3) { NetworkConnection.new }
-
-    threads = Array.new(20) {
-      Thread.new do
-        pool.with do |net|
-          sleep 0.01
-        end
-      end
-    }
-
-    threads.map { |thread| thread.join }
-  end
-
-  def test_reuses_objects_when_pool_not_saturated
-    pool = ConnectionPool.new(size: 5) { NetworkConnection.new }
-
-    ids = 10.times.map {
-      pool.with { |c| c.object_id }
-    }
-
-    assert_equal 1, ids.uniq.size
-  end
-
-  def test_nested_checkout
-    recorder = Recorder.new
-    pool = ConnectionPool.new(size: 1) { recorder }
-    pool.with do |r_outer|
-      @other = Thread.new { |t|
-        pool.with do |r_other|
-          r_other.do_work("other")
-        end
-      }
-
-      pool.with do |r_inner|
-        r_inner.do_work("inner")
-      end
-
-      Thread.pass
-
-      r_outer.do_work("outer")
-    end
-
-    @other.join
-
-    assert_equal ["inner", "outer", "other"], recorder.calls
-  end
-
-  def test_shutdown_is_executed_for_all_connections
-    recorders = []
-
-    pool = ConnectionPool.new(size: 3) {
-      Recorder.new.tap { |r| recorders << r }
-    }
-
-    threads = use_pool pool, 3
-
-    pool.shutdown do |recorder|
-      recorder.do_work("shutdown")
-    end
-
-    kill_threads(threads)
-
-    assert_equal [["shutdown"]] * 3, recorders.map { |r| r.calls }
-  end
-
-  def test_raises_error_after_shutting_down
-    pool = ConnectionPool.new(size: 1) { true }
-
-    pool.shutdown {}
-
-    assert_raises ConnectionPool::PoolShuttingDownError do
-      pool.checkout
-    end
-  end
-
-  def test_runs_shutdown_block_asynchronously_if_connection_was_in_use
-    recorders = []
-
-    pool = ConnectionPool.new(size: 3) {
-      Recorder.new.tap { |r| recorders << r }
-    }
-
-    threads = use_pool pool, 2
-
-    pool.checkout
-
-    pool.shutdown do |recorder|
-      recorder.do_work("shutdown")
-    end
-
-    kill_threads(threads)
-
-    assert_equal [["shutdown"], ["shutdown"], []], recorders.map { |r| r.calls }
-
-    pool.checkin
-
-    assert_equal [["shutdown"], ["shutdown"], ["shutdown"]], recorders.map { |r| r.calls }
-  end
-
-  def test_raises_an_error_if_shutdown_is_called_without_a_block
-    pool = ConnectionPool.new(size: 1) {}
-
-    assert_raises ArgumentError do
-      pool.shutdown
-    end
-  end
-
-  def test_shutdown_is_executed_for_all_connections_in_wrapped_pool
-    recorders = []
-
-    wrapper = ConnectionPool::Wrapper.new(size: 3) {
-      Recorder.new.tap { |r| recorders << r }
-    }
-
-    threads = use_pool wrapper, 3
-
-    wrapper.pool_shutdown do |recorder|
-      recorder.do_work("shutdown")
-    end
-
-    kill_threads(threads)
-
-    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 }
-
-    assert_equal 1, wrapper.fast
-  end
-
-  def test_wrapper_respond_to_eh
-    wrapper = ConnectionPool::Wrapper.new { NetworkConnection.new }
-
-    assert_respond_to wrapper, :with
-
-    assert_respond_to wrapper, :fast
-    refute_respond_to wrapper, :"nonexistent method"
-  end
-
-  def test_wrapper_with
-    wrapper = ConnectionPool::Wrapper.new(timeout: 0, size: 1) { Object.new }
-
-    wrapper.with do
-      Thread.new {
-        assert_raises Timeout::Error do
-          wrapper.with { flunk "connection checked out :(" }
-        end
-      }.join
-    end
-
-    assert Thread.new { wrapper.with {} }.join
-  end
-
-  class ConnWithEval
-    def eval(arg)
-      "eval'ed #{arg}"
-    end
-  end
-
-  def test_wrapper_kernel_methods
-    wrapper = ConnectionPool::Wrapper.new(timeout: 0, size: 1) { ConnWithEval.new }
-
-    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

data/test/test_connection_pool_timed_stack.rb

@@ -1,150 +0,0 @@
-require_relative "helper"
-
-class TestConnectionPoolTimedStack < Minitest::Test
-  def setup
-    @stack = ConnectionPool::TimedStack.new { Object.new }
-  end
-
-  def test_empty_eh
-    stack = ConnectionPool::TimedStack.new(1) { Object.new }
-
-    refute_empty stack
-
-    popped = stack.pop
-
-    assert_empty stack
-
-    stack.push popped
-
-    refute_empty stack
-  end
-
-  def test_length
-    stack = ConnectionPool::TimedStack.new(1) { Object.new }
-
-    assert_equal 1, stack.length
-
-    popped = stack.pop
-
-    assert_equal 0, stack.length
-
-    stack.push popped
-
-    assert_equal 1, stack.length
-  end
-
-  def test_object_creation_fails
-    stack = ConnectionPool::TimedStack.new(2) { raise "failure" }
-
-    begin
-      stack.pop
-    rescue => error
-      assert_equal "failure", error.message
-    end
-
-    begin
-      stack.pop
-    rescue => error
-      assert_equal "failure", error.message
-    end
-
-    refute_empty stack
-    assert_equal 2, stack.length
-  end
-
-  def test_pop
-    object = Object.new
-    @stack.push object
-
-    popped = @stack.pop
-
-    assert_same object, popped
-  end
-
-  def test_pop_empty
-    e = assert_raises(ConnectionPool::TimeoutError) { @stack.pop timeout: 0 }
-    assert_equal "Waited 0 sec", e.message
-  end
-
-  def test_pop_empty_2_0_compatibility
-    e = assert_raises(Timeout::Error) { @stack.pop 0 }
-    assert_equal "Waited 0 sec", e.message
-  end
-
-  def test_pop_full
-    stack = ConnectionPool::TimedStack.new(1) { Object.new }
-
-    popped = stack.pop
-
-    refute_nil popped
-    assert_empty stack
-  end
-
-  def test_pop_wait
-    thread = Thread.start {
-      @stack.pop
-    }
-
-    Thread.pass while thread.status == "run"
-
-    object = Object.new
-
-    @stack.push object
-
-    assert_same object, thread.value
-  end
-
-  def test_pop_shutdown
-    @stack.shutdown {}
-
-    assert_raises ConnectionPool::PoolShuttingDownError do
-      @stack.pop
-    end
-  end
-
-  def test_pop_shutdown_reload
-    stack = ConnectionPool::TimedStack.new(1) { Object.new }
-    object = stack.pop
-    stack.push(object)
-
-    stack.shutdown(reload: true) {}
-
-    refute_equal object, stack.pop
-  end
-
-  def test_push
-    stack = ConnectionPool::TimedStack.new(1) { Object.new }
-
-    conn = stack.pop
-
-    stack.push conn
-
-    refute_empty stack
-  end
-
-  def test_push_shutdown
-    called = []
-
-    @stack.shutdown do |object|
-      called << object
-    end
-
-    @stack.push Object.new
-
-    refute_empty called
-    assert_empty @stack
-  end
-
-  def test_shutdown
-    @stack.push Object.new
-
-    called = []
-
-    @stack.shutdown do |object|
-      called << object
-    end
-
-    refute_empty called
-    assert_empty @stack
-  end
-end