connection_pool 2.2.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 57159a2ea25da28e141dc80936a642134fbc9680
-  data.tar.gz: 7f534538909e40c117b84090a89b6f4fcd5ca8ee
+  metadata.gz: 7f87d3feec72672723a367bfa62719c8b7af8a35
+  data.tar.gz: 51632684b4d5b93d6de0215180dc0f4e8a2ab922
 SHA512:
-  metadata.gz: bb15e188af8037b01d59ab3728ee010033ab6c71cdd82ed6a8f4f59609c23791d9afdb8a9e31c755079cd1ce7c6e0ca20a7b43d2bd4b142b7ddacbd9b9ad94c3
-  data.tar.gz: 69e22e8e329f525fb875c2abe1090a35a63d035bb9337d9bd79604f46f1f1c3dbb92a83d6bf8d899388e8873cf04060c288bfef0e760e14b23a2fa12b1ffdf32
+  metadata.gz: b3912e67f7b3f01f6e89047a56eb1f08f80820f5a154d0acde2d05f977d7566a33eacce3cee792ce2a52485b3218b9d718e4bacb89aafa050791166fb8d6e337
+  data.tar.gz: 0d2e0ee5ad0c23db00b32737b82f0693cb70e2f5de0f7a5afa03c5ae7ac22765d13b0073086940c12edf6b5a00605e8db1a1ddecc80d373417448ba67e0bcfca

data/.travis.yml

@@ -5,8 +5,8 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
-  - 2.1.0
-  - 2.2.0
+  - 2.1.6
+  - 2.2.2
   - jruby
   - rbx-2
 notifications:

data/Changes.md

@@ -1,6 +1,12 @@
 connection\_pool changelog
 ---------------------------
 
+2.2.1
+------
+
+- Allow CP::Wrapper to use an existing pool [#87, etiennebarrie]
+- Use monotonic time for more accurate timeouts [#84, jdantonio]
+
 2.2.0
 ------
 

data/README.md

@@ -8,11 +8,6 @@ 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.
 
-**WARNING**: Don't ever use `Timeout.timeout` in your Ruby code or you will see
-occasional silent corruption and mysterious errors.  The Timeout API is unsafe
-and cannot be used correctly, ever.  Use proper socket timeout options as
-exposed by Net::HTTP, Redis, Dalli, etc.
-
 
 Usage
 -----
@@ -50,8 +45,10 @@ 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.
 
+## Migrating to a Connection Pool
+
 You can use `ConnectionPool::Wrapper` to wrap a single global connection,
-making it easier to port your connection code over time:
+making it easier to migrate existing connection code over time:
 
 ``` ruby
 $redis = ConnectionPool::Wrapper.new(size: 5, timeout: 3) { Redis.connect }
@@ -74,17 +71,20 @@ end
 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.
 
 ```ruby
 cp = ConnectionPool.new { Redis.new }
-cp.shutdown { |conn| conn.close }
+cp.shutdown { |conn| conn.quit }
 ```
 
 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
+**Note that shutting down is completely optional**; Ruby's garbage collector will reclaim
 unreferenced pools under normal circumstances.
 
 
@@ -95,14 +95,10 @@ Notes
 - There is no provision for repairing or checking the health of a connection;
   connections should be self-repairing.  This is true of the Dalli and Redis
   clients.
-
-
-Install
--------
-
-```
-$ gem install connection_pool
-```
+- **WARNING**: Don't ever use `Timeout.timeout` in your Ruby code or you will see
+  occasional silent corruption and mysterious errors.  The Timeout API is unsafe
+  and cannot be used correctly, ever.  Use proper socket timeout options as
+  exposed by Net::HTTP, Redis, Dalli, etc.
 
 
 Author

data/lib/connection_pool.rb

@@ -15,7 +15,7 @@ require_relative 'connection_pool/timed_stack'
 #
 # Using optional timeout override (for that single invocation)
 #
-#    @pool.with(:timeout => 2.0) do |redis|
+#    @pool.with(timeout: 2.0) do |redis|
 #      redis.lpop('my-list') if redis.llen('my-list') > 0
 #    end
 #
@@ -124,7 +124,7 @@ end
     METHODS = [:with, :pool_shutdown]
 
     def initialize(options = {}, &block)
-      @pool = ::ConnectionPool.new(options, &block)
+      @pool = options.fetch(:pool) { ::ConnectionPool.new(options, &block) }
     end
 
     def with(&block)

data/lib/connection_pool/monotonic_time.rb

@@ -0,0 +1,66 @@
+# Global monotonic clock from Concurrent Ruby 1.0.
+# Copyright (c) Jerry D'Antonio -- released under the MIT license.
+# Slightly modified; used with permission.
+# https://github.com/ruby-concurrency/concurrent-ruby
+
+require 'thread'
+
+class ConnectionPool
+
+  class_definition = Class.new do
+
+    if defined?(Process::CLOCK_MONOTONIC)
+
+      # @!visibility private
+      def get_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+    elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
+      # @!visibility private
+      def get_time
+        java.lang.System.nanoTime() / 1_000_000_000.0
+      end
+
+    else
+
+      # @!visibility private
+      def initialize
+        @mutex = Mutex.new
+        @last_time = Time.now.to_f
+      end
+
+      # @!visibility private
+      def get_time
+        @mutex.synchronize do
+          now = Time.now.to_f
+          if @last_time < now
+            @last_time = now
+          else # clock has moved back in time
+            @last_time += 0.000_001
+          end
+        end
+      end
+    end
+  end
+
+  ##
+  # Clock that cannot be set and represents monotonic time since
+  # some unspecified starting point.
+  #
+  # @!visibility private
+  GLOBAL_MONOTONIC_CLOCK = class_definition.new
+  private_constant :GLOBAL_MONOTONIC_CLOCK
+
+  class << self
+    ##
+    # Returns the current time a tracked by the application monotonic clock.
+    #
+    # @return [Float] The current monotonic time when `since` not given else
+    #   the elapsed monotonic time between `since` and the current time
+    def monotonic_time
+      GLOBAL_MONOTONIC_CLOCK.get_time
+    end
+  end
+end

data/lib/connection_pool/timed_stack.rb

@@ -1,5 +1,6 @@
 require 'thread'
 require 'timeout'
+require_relative 'monotonic_time'
 
 ##
 # Raised when you attempt to retrieve a connection from a pool that has been
@@ -72,7 +73,7 @@ class ConnectionPool::TimedStack
     options, timeout = timeout, 0.5 if Hash === timeout
     timeout = options.fetch :timeout, timeout
 
-    deadline = Time.now + timeout
+    deadline = ConnectionPool.monotonic_time + timeout
     @mutex.synchronize do
       loop do
         raise ConnectionPool::PoolShuttingDownError if @shutdown_block
@@ -81,7 +82,7 @@ class ConnectionPool::TimedStack
         connection = try_create(options)
         return connection if connection
 
-        to_wait = deadline - Time.now
+        to_wait = deadline - ConnectionPool.monotonic_time
         raise Timeout::Error, "Waited #{timeout} sec" if to_wait <= 0
         @resource.wait(@mutex, to_wait)
       end

data/lib/connection_pool/version.rb

@@ -1,3 +1,3 @@
 class ConnectionPool
-  VERSION = "2.2.0"
+  VERSION = "2.2.1"
 end

data/test/test_connection_pool.rb

@@ -3,13 +3,15 @@ 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
+      sleep SLEEP_TIME
       @x
     end
 
@@ -19,7 +21,7 @@ class TestConnectionPool < Minitest::Test
 
     def do_something_with_block
       @x += yield
-      sleep 0.05
+      sleep SLEEP_TIME
       @x
     end
 
@@ -58,25 +60,30 @@ 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) do
       Thread.new do
         pool.with do |net|
           net.do_something
         end
       end
-    end
+    end.map(&:value)
+
+    finish = Time.new
 
-    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_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 }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
     thread = Thread.new do
       pool.with do |net|
         net.do_something
@@ -98,7 +105,7 @@ 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
@@ -110,7 +117,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_with_timeout
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { Object.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
 
     assert_raises Timeout::Error do
       Timeout.timeout(0.01) do
@@ -126,7 +133,7 @@ class TestConnectionPool < Minitest::Test
   def test_checkout_ignores_timeout
     skip("Thread.handle_interrupt not available") unless Thread.respond_to?(:handle_interrupt)
 
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { Object.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
     def pool.checkout(options)
       sleep 0.015
       super
@@ -150,7 +157,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_explicit_return
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) do
+    pool = ConnectionPool.new(timeout: 0, size: 1) do
       mock = Minitest::Mock.new
       def mock.disconnect!
         raise "should not disconnect upon explicit return"
@@ -164,7 +171,7 @@ class TestConnectionPool < Minitest::Test
   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
       pool.with do |net|
@@ -179,13 +186,13 @@ class TestConnectionPool < Minitest::Test
       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
@@ -198,12 +205,12 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_returns_value
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { Object.new }
+    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
@@ -213,7 +220,7 @@ class TestConnectionPool < Minitest::Test
   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
@@ -224,7 +231,7 @@ 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
@@ -243,7 +250,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
 
@@ -253,7 +260,7 @@ 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
@@ -264,7 +271,7 @@ class TestConnectionPool < Minitest::Test
   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
@@ -272,7 +279,7 @@ 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
       pool.with do |net|
@@ -287,11 +294,11 @@ class TestConnectionPool < Minitest::Test
       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 }
@@ -299,7 +306,7 @@ class TestConnectionPool < Minitest::Test
   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)
@@ -307,7 +314,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_return_value
-    pool = ConnectionPool.new(:timeout => 0.1, :size => 1) { NetworkConnection.new }
+    pool = ConnectionPool.new(timeout: 2 * NetworkConnection::SLEEP_TIME, size: 1) { NetworkConnection.new }
     result = pool.with do |net|
       net.fast
     end
@@ -315,7 +322,7 @@ class TestConnectionPool < Minitest::Test
   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
       Thread.new do
@@ -329,7 +336,7 @@ class TestConnectionPool < Minitest::Test
   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
       pool.with { |c| c.object_id }
@@ -340,7 +347,7 @@ class TestConnectionPool < Minitest::Test
 
   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|
         pool.with do |r_other|
@@ -365,7 +372,7 @@ class TestConnectionPool < Minitest::Test
   def test_shutdown_is_executed_for_all_connections
     recorders = []
 
-    pool = ConnectionPool.new(:size => 3) do
+    pool = ConnectionPool.new(size: 3) do
       Recorder.new.tap { |r| recorders << r }
     end
 
@@ -381,7 +388,7 @@ 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 { }
 
@@ -393,7 +400,7 @@ 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) do
       Recorder.new.tap { |r| recorders << r }
     end
 
@@ -415,7 +422,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
@@ -425,7 +432,7 @@ 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) do
       Recorder.new.tap { |r| recorders << r }
     end
 
@@ -456,7 +463,7 @@ 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
@@ -481,4 +488,14 @@ 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
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: connection_pool
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.1
 platform: ruby
 authors:
 - Mike Perham
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-11 00:00:00.000000000 Z
+date: 2016-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -70,6 +70,7 @@ files:
 - Rakefile
 - connection_pool.gemspec
 - lib/connection_pool.rb
+- lib/connection_pool/monotonic_time.rb
 - lib/connection_pool/timed_stack.rb
 - lib/connection_pool/version.rb
 - test/helper.rb
@@ -95,7 +96,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Generic connection pool for Ruby
@@ -103,3 +104,4 @@ test_files:
 - test/helper.rb
 - test/test_connection_pool.rb
 - test/test_connection_pool_timed_stack.rb
+has_rdoc: