connection_pool 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eead858733d8dbd69d9ce236f18977ea847b3a83
-  data.tar.gz: a686e2981051d33b6b170d2f7aac5709a78bb0cc
+  metadata.gz: b24f806aed835d638868cfeee4d30cd53b32c561
+  data.tar.gz: eeb809403e4ae18c350800712b97d9b65cff0194
 SHA512:
-  metadata.gz: 268fe355fb087c14e1820ae8e3f5d903ddf6d2bc9b762091df9e14daa4a20ebf162766f54185c03857ca752f6f15e31a60b4e18c434798950c563a9b17865a73
-  data.tar.gz: 9cc05e0c0b554dd131add7a31b328a85d768141be6e250d34472dc8db7bdd1a46f7fca30cf71fc5edb4b33d1d24403a98bc71a3696dec896918f8af05d8e0653
+  metadata.gz: f815103822aaced056e316cf955a3d6a35fbb07b9e87d6f646e83a324e8c28aba570c55f0561ef94bcd76134670320f441c1141bcc2103f82843aa17d0ab42a2
+  data.tar.gz: d5883346fa243b8d0de199288722d4ec84092dbe4a8c984c33c4c48c3deb4f4ce0d11187be0a83941bac1231341b4a98f7f2d5968c6d4f5c159df6a15eddc365

data/.travis.yml

@@ -0,0 +1,10 @@
+---
+language: ruby
+notifications:
+  email:
+  - drbrain@segment7.net
+rvm:
+- 1.9.3
+- 2.0.0
+- 2.1.0
+script: rake test

data/Changes.md

@@ -1,3 +1,9 @@
+2.0.0
+-----
+
+- The connection pool is now lazy.  Connections are created as needed
+  and retained until the pool is shut down. [drbrain, #52]
+
 1.2.0
 -----
 
@@ -16,7 +22,7 @@ end
     This method accepts a block and calls the block for each
     connection in the pool. After calling this method, trying to get a
     connection from the pool raises `PoolShuttingDownError`.
-    
+
 1.0.0
 -----
 

data/README.md

@@ -1,40 +1,28 @@
-connection_pool
-======================
+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.
-
-
-Install
-------------
-
-    gem install connection_pool
-
-
-Notes
-------------
-
-- Connections are eager created when the pool is created.
-- 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.
+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 }
+$memcached = ConnectionPool.new(size: 5, timeout: 5) { Dalli::Client.new }
 ```
 
 Then use the pool in your application:
 
 ``` ruby
-@memcached.with do |dalli|
-  dalli.get('some-count')
+$memcached.with do |conn|
+  conn.get('some-count')
 end
 ```
 
@@ -45,29 +33,30 @@ until one becomes available.  If no object is available within `:timeout` second
 Optionally, you can specify a timeout override using the with-block semantics:
 
 ``` ruby
-@memcached.with(:timeout => 2.0) do |dalli|
-  dalli.get('some-count')
+$memcached.with(timeout: 2.0) do |conn|
+  conn.get('some-count')
 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.
+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.
 
-You can use `ConnectionPool::Wrapper` to wrap a single global connection, making
-it easier to port your connection code over time:
+You can use `ConnectionPool::Wrapper` to wrap a single global connection,
+making it easier to port your connection code over time:
 
 ``` ruby
-$redis = ConnectionPool::Wrapper.new(:size => 5, :timeout => 3) { Redis.connect }
+$redis = ConnectionPool::Wrapper.new(size: 5, timeout: 3) { Redis.connect }
 $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,10 +65,28 @@ $redis.with do |conn|
 end
 ```
 
-Once you've ported your entire system to use `with`, you can simply
-remove ::Wrapper and use a simple, fast ConnectionPool.
+Once you've ported your entire system to use `with`, you can simply remove
+`Wrapper` and use the simpler and faster `ConnectionPool`.
+
+
+Notes
+-----
+
+- Connections are lazily created as needed.
+- 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
+```
+
 
 Author
---------------
+------
 
 Mike Perham, [@mperham](https://twitter.com/mperham), <http://mikeperham.com>

data/lib/connection_pool.rb

@@ -1,5 +1,5 @@
-require 'connection_pool/version'
-require 'connection_pool/timed_stack'
+require_relative 'connection_pool/version'
+require_relative 'connection_pool/timed_stack'
 
 # Generic connection pool class for e.g. sharing a limited number of network connections
 # among many threads.  Note: Connections are eager created.
@@ -33,6 +33,9 @@ require 'connection_pool/timed_stack'
 class ConnectionPool
   DEFAULTS = {size: 5, timeout: 5}
 
+  class Error < RuntimeError
+  end
+
   def self.wrap(options, &block)
     Wrapper.new(options, &block)
   end
@@ -74,6 +77,9 @@ class ConnectionPool
 
   def checkin
     stack = ::Thread.current[@key]
+    raise ConnectionPool::Error, 'no connections are checked out' if
+      !stack || stack.empty?
+
     conn = stack.pop
     if stack.empty?
       @available << conn
@@ -93,9 +99,12 @@ class ConnectionPool
     end
 
     def with
-      yield @pool.checkout
-    ensure
-      @pool.checkin
+      conn = @pool.checkout
+      begin
+        yield conn
+      ensure
+        @pool.checkin
+      end
     end
 
     def pool_shutdown(&block)

data/lib/connection_pool/timed_stack.rb

@@ -5,8 +5,11 @@ class ConnectionPool::PoolShuttingDownError < RuntimeError; end
 
 class ConnectionPool::TimedStack
 
-  def initialize(size = 0)
-    @que = Array.new(size) { yield }
+  def initialize(size = 0, &block)
+    @create_block = block
+    @created = 0
+    @que = []
+    @max = size
     @mutex = Mutex.new
     @resource = ConditionVariable.new
     @shutdown_block = nil
@@ -31,6 +34,10 @@ class ConnectionPool::TimedStack
       loop do
         raise ConnectionPool::PoolShuttingDownError if @shutdown_block
         return @que.pop unless @que.empty?
+        unless @created == @max
+          @created += 1
+          return @create_block.call
+        end
         to_wait = deadline - Time.now
         raise Timeout::Error, "Waited #{timeout} sec" if to_wait <= 0
         @resource.wait(@mutex, to_wait)
@@ -53,10 +60,10 @@ class ConnectionPool::TimedStack
   end
 
   def empty?
-    @que.empty?
+    (@created - @que.length) >= @max
   end
 
   def length
-    @que.length
+    @max - @created + @que.length
   end
 end

data/lib/connection_pool/version.rb

@@ -1,3 +1,3 @@
 class ConnectionPool
-  VERSION = "1.2.0"
+  VERSION = "2.0.0"
 end

data/test/helper.rb

@@ -1,6 +1,10 @@
+gem 'minitest'
+
 require 'minitest/pride'
 require 'minitest/autorun'
 
+Thread.abort_on_exception = true
+
 $VERBOSE = 1
 
 require_relative '../lib/connection_pool'

data/test/test_connection_pool.rb

@@ -1,5 +1,4 @@
-Thread.abort_on_exception = true
-require 'helper'
+require_relative 'helper'
 
 class TestConnectionPool < Minitest::Test
 
@@ -41,11 +40,24 @@ class TestConnectionPool < Minitest::Test
     end
   end
 
+  def use_pool(pool, size)
+    Array.new(size) do
+      Thread.new do
+        pool.with do sleep end
+      end
+    end.each do |thread|
+      Thread.pass until thread.status == 'sleep'
+    end.map do |thread|
+      thread.kill
+      Thread.pass while thread.alive?
+    end
+  end
+
   def test_basic_multithreaded_usage
     pool = ConnectionPool.new(:size => 5) { NetworkConnection.new }
-    threads = []
-    15.times do
-      threads << Thread.new do
+
+    threads = Array.new(15) do
+      Thread.new do
         pool.with do |net|
           net.do_something
         end
@@ -60,56 +72,169 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_timeout
-    pool = ConnectionPool.new(:timeout => 0.05, :size => 1) { NetworkConnection.new }
-    Thread.new do
+    pool = ConnectionPool.new(:timeout => 0, :size => 1) { NetworkConnection.new }
+    thread = Thread.new do
       pool.with do |net|
         net.do_something
-        sleep 0.1
+        sleep 0.01
       end
     end
-    sleep 0.05
+
+    Thread.pass while thread.status == 'run'
+
     assert_raises Timeout::Error do
       pool.with { |net| net.do_something }
     end
 
-    sleep 0.05
+    thread.join
+
     pool.with do |conn|
       refute_nil conn
     end
   end
-  
-  def test_with_timeout_override 
-    pool = ConnectionPool.new(:timeout => 0.05, :size => 1) { NetworkConnection.new }
-    Thread.new do
+
+  def test_with
+    pool = ConnectionPool.new(:timeout => 0, :size => 1) { Object.new }
+
+    pool.with do
+      assert_raises Timeout::Error do
+        Thread.new { pool.checkout }.join
+      end
+    end
+
+    assert Thread.new { pool.checkout }.join
+  end
+
+  def test_with_timeout_override
+    pool = ConnectionPool.new(:timeout => 0, :size => 1) { NetworkConnection.new }
+
+    t = Thread.new do
       pool.with do |net|
         net.do_something
-        sleep 0.3
+        sleep 0.01
       end
     end
-    sleep 0.05
+
+    Thread.pass while t.status == 'run'
+
     assert_raises Timeout::Error do
       pool.with { |net| net.do_something }
-    end    
-    pool.with(:timeout => 0.4) do |conn|
+    end
+
+    pool.with(:timeout => 0.1) do |conn|
       refute_nil conn
-    end     
+    end
+  end
+
+  def test_checkin
+    pool = ConnectionPool.new(:timeout => 0, :size => 1) { NetworkConnection.new }
+    conn = pool.checkout
+
+    t1 = Thread.new do
+      pool.checkout
+    end
+
+    assert_raises Timeout::Error do
+      t1.join
+    end
+
+    pool.checkin
+
+    t2 = Thread.new do
+      pool.checkout
+    end
+
+    assert_same conn, t2.value
+  end
+
+  def test_checkin_never_checkout
+    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
+  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
+
+    assert_raises Timeout::Error do
+      Thread.new do
+        pool.checkout
+      end.join
+    end
+
+    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 do
+      pool.checkout
+    end
+
+    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.05, :size => 1) { NetworkConnection.new }
-    Thread.new do
+    pool = ConnectionPool.new(:timeout => 0, :size => 1) { NetworkConnection.new }
+
+    thread = Thread.new do
       pool.with do |net|
         net.do_something
-        sleep 0.2
+        sleep 0.01
       end
-    end 
-    sleep 0.05
+    end
+
+    Thread.pass while thread.status == 'run'
+
     assert_raises Timeout::Error do
-      pool.checkout 
+      pool.checkout
     end
-    assert pool.checkout :timeout => 0.3    
+
+    assert pool.checkout :timeout => 0.1
   end
-  
+
   def test_passthru
     pool = ConnectionPool.wrap(:timeout => 0.1, :size => 1) { NetworkConnection.new }
     assert_equal 1, pool.do_something
@@ -136,14 +261,16 @@ class TestConnectionPool < Minitest::Test
 
   def test_heavy_threading
     pool = ConnectionPool.new(:timeout => 0.5, :size => 3) { NetworkConnection.new }
-    20.times do
+
+    threads = Array.new(20) do
       Thread.new do
         pool.with do |net|
-          sleep 0.05
+          sleep 0.01
         end
       end
     end
-    sleep 0.5
+
+    threads.map { |thread| thread.join }
   end
 
   def test_reuses_objects_when_pool_not_saturated
@@ -170,7 +297,7 @@ class TestConnectionPool < Minitest::Test
         r_inner.do_work('inner')
       end
 
-      sleep 0.1
+      Thread.pass
 
       r_outer.do_work('outer')
     end
@@ -187,6 +314,8 @@ class TestConnectionPool < Minitest::Test
       Recorder.new.tap { |r| recorders << r }
     end
 
+    use_pool pool, 3
+
     pool.shutdown do |recorder|
       recorder.do_work("shutdown")
     end
@@ -211,13 +340,15 @@ class TestConnectionPool < Minitest::Test
       Recorder.new.tap { |r| recorders << r }
     end
 
+    use_pool pool, 3
+
     pool.checkout
 
     pool.shutdown do |recorder|
       recorder.do_work("shutdown")
     end
 
-    assert_equal [["shutdown"], ["shutdown"], []], recorders.map { |r| r.calls }
+    assert_equal [[], ["shutdown"], ["shutdown"]], recorders.map { |r| r.calls }.sort
 
     pool.checkin
 
@@ -239,10 +370,54 @@ class TestConnectionPool < Minitest::Test
       Recorder.new.tap { |r| recorders << r }
     end
 
+    use_pool wrapper, 3
+
     wrapper.pool_shutdown do |recorder|
       recorder.do_work("shutdown")
     end
 
     assert_equal [["shutdown"]] * 3, recorders.map { |r| r.calls }
   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
+      assert_raises Timeout::Error do
+        Thread.new do
+          wrapper.with { flunk 'connection checked out :(' }
+        end.join
+      end
+    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
+
 end

data/test/test_connection_pool_timed_stack.rb

@@ -0,0 +1,122 @@
+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_pop
+    object = Object.new
+    @stack.push object
+
+    popped = @stack.pop
+
+    assert_same object, popped
+  end
+
+  def test_pop_empty
+    e = assert_raises Timeout::Error do
+      @stack.pop 0
+    end
+
+    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 do
+      @stack.pop
+    end
+
+    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_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
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: connection_pool
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Mike Perham
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-26 00:00:00.000000000 Z
+date: 2014-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -48,6 +48,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Changes.md
 - Gemfile
 - LICENSE
@@ -59,6 +60,7 @@ files:
 - lib/connection_pool/version.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
@@ -79,10 +81,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.9
+rubygems_version: 2.0.14
 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