lazy_connection_pool 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NTI4OGY1M2Y5OGQ4ZDliZmJlMTEzNzg2MWJhZGU5YzI3YTlkODJmZA==
+  data.tar.gz: !binary |-
+    MTVhM2I2YWY5N2NjYWNkMzdmYTUwMWUwY2M0M2M0ZWU5Y2QwN2RiMg==
+SHA512:
+  metadata.gz: !binary |-
+    NDY0YjI0ZjQ0ZmFjZTVmNDg5MjAwODRlM2M5MWI2ZDJlNDhlM2NjYmFkY2Nh
+    NzJhNWI1Y2JjNDZhMTc3Mzk1MzdlYjI5ZTFhYTcwNmU5MDY3NDAyYzg2YTgx
+    MmUxYWFlYTg5ZjRmOWFmM2RhODYzYjA3OTVhODIzMjIzMDI2ODU=
+  data.tar.gz: !binary |-
+    OTQ4YzA5Y2RkOGQxZTQyMWRhOTBkYmJjODhlM2EyYmExZTEyOGFmNjg4Mzdj
+    Y2VhMGM0NDE3MmRkYzVhNTNhNzFhOWQyNWZlNDdjMGU0YjkxOTJjNzBhMWUw
+    NzJkYmI4MzQ4M2VmOTE2NTYyZTc4ZmFhNTZiMzczYWNiNmRiYTg=

data/.gitignore

@@ -0,0 +1,2 @@
+.*.sw?
+

data/LICENSE.md

@@ -0,0 +1,25 @@
+LazyConnectionPool License
+==========================
+
+LazyConnectionPool is provided as-is, with the hopes (but not the promise) 
+that you find it useful.  No warranties are provided, express or implied.
+
+The license may change in the future to be more restrictive, but as of
+this commit, you can copy, include, fork, or redistribute the code, in
+whole or in part, in source or (somehow) compiled, with the request that
+source distributions mention the originating webpage and a description of
+how much the code has changed since you got your hands on it.
+
+For example:
+
+	"This code was originally based on LazyConnectionPool, with
+	some minor fixes"
+	
+or,
+
+	"copied from LazyConnectionPool, and totally rewritten."
+
+If you rewrite it so significantly as to be unrecognizable, this request
+is waived.  Please use your best judgement as to what "unrecognizeable"
+means.
+

data/README.md

@@ -0,0 +1,109 @@
+LazyConnectionPooler
+====================
+
+A lazy connection pooler for Ruby.
+
+This gem is meant to provide functionality similar to Mike Perham's lovely
+[connection_pool](http://github.com/mperham/connection_pool), with the
+twist that connections will be lazily created whenever there's a shortage
+in the pool.  It is not, however, meant to be a drop-in replacement for
+that library.
+
+I've tested this lightly under CRuby 1.9.3 and JRuby 1.7.10, and it doesn't
+appear to deadlock or step on itself, even when running hundreds of threads
+battling for a handful of connections.  But my testing should hardly be a
+promise that it's bug-free, or even functional.
+
+Usage
+=====
+
+The documentation is, uhm, coming real soon now.  The following will have
+to suffice in the meantime.
+
+Pool creation
+-------------
+
+Initiate a pool, passing in a block that'll be used to initialize new
+connections:
+
+	pool = LazyConnectionPool.new {
+		Net::HTTP.new('localhost')
+	}
+
+Connection usage: inline
+------------------------
+
+Your new `LazyConnectionPool` object's `#get` method can take a block.  It
+will pass your block a connection:
+
+	response = pool.get { |sock|
+		sock.get('/')
+	}
+
+When used this way, `#get` will return te result of your block.  If your
+block raises any exceptions, the connection will still be returned to the
+pool, and the exception will be yours to handle.
+
+Connection usage: get/release
+-----------------------------
+
+You can also request a connection, then release it when you're done with
+it, by calling `#get` without a block:
+
+	sock = pool.get
+	response = sock.get('/')
+	pool.release(sock)
+
+Of course, if you don't ever `#release` your connection, it'll just leak
+onto the floor.
+
+Pool limits
+-----------
+
+You can optionally limit the size of the pool:
+
+	pool.poolsize = 16
+
+The default is a limit of `-1`, which is unlimited.  If you specify `0` as
+a limit, no pool objects will be available.
+
+Blocking requests
+-----------------
+
+If you run out of connections in the pool, such that you run into your
+`poolsize` limit, `#get` will block until a connection is available.
+`#get` takes one optional boolean argument, indicating whether it should
+wait for a connection to become available.  If it's false, it'll return
+`nil`.  Note that if you use a block with `#get` and it also potentially
+returns `nil`, it could be difficult to differentiate between the two
+conditions, as below:
+
+	body = pool.get(false) { |sock|
+		response = sock.get('/')
+		if response.code.to_i == 200
+			JSON.parse(response.body)
+		end
+	}
+
+Would it have blocked?  Did it connect but the response was something other
+than a 200?  The world may never know.
+
+Unhealthy connections
+---------------------
+
+LazyConnectionPool assumes that the connections it hands out are healthy,
+or can be made healthy without replacing the connection object.  If this
+isn't true, LazyConnectionPool is not for you.  Your code should detect and
+heal the connection object whenever needed.
+
+Shrinking the pool
+------------------
+
+LazyConnectionPool adds connections to deal with shortages; it does not
+reap them again, unless `poolsize` shrinks somehow.
+
+Contributions
+=============
+
+Bug? Feature? Contributions of any kind: Send me a pull request.
+

data/lazy_connection_pool.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new { |gem|
+  gem.name             = "lazy_connection_pool"
+  gem.version          = "1.0.0"
+  gem.platform         = Gem::Platform::RUBY
+  gem.authors          = ["Joel Boutros"]
+  gem.licenses         = [ 'BSD' ]
+
+  gem.homepage         = "http://github.com/jaydeebee/lazy_connection_pool"
+  gem.summary          = "A lazy connection pooler for Ruby"
+  gem.description      = "A lazy connection pooler for Ruby.  Supports lazy connection allocation and dynamic pool sizing."
+
+  gem.required_rubygems_version = ">= 1.3.6"
+
+  gem.files            = `git ls-files`.split("\n")
+  gem.executables      = []
+
+  gem.require_path     = 'lib'
+}
+

data/lib/lazy_connection_pool.rb

@@ -0,0 +1,107 @@
+#
+# LazyConnectionPool
+#
+# A connection pool that lazily creates connections and can be 
+# resized dynamically.  It attempts optimistic thread-safety.
+#
+
+require 'thread'
+
+class LazyConnectionPool
+  def initialize(poolsize=-1, &block)
+    if block.nil?
+      raise ArgumentError, "LazyConnectionPool requires a block"
+    end
+
+    @max_pool_size = poolsize
+    @cur_pool_size = 0
+    @block = block
+    @pool = Queue.new
+    @mutex = Mutex.new
+  end
+
+  def poolsize=(poolsize)
+    to_release = 0
+
+    @mutex.synchronize {
+      @max_pool_size = poolsize
+      if @max_pool_size >= 0
+        to_release = (@max_pool_size - @cur_pool_size) 
+        to_release = @pool.num_waiting if @pool.num_waiting < to_release
+        to_release = 0 if to_release < 0
+      else
+        to_release = @pool.num_waiting
+      end
+    }
+
+    if to_release > 0
+      to_release.times { |x|
+        self.release @block.call
+      }
+    end
+
+    return @max_pool_size
+  end
+
+  def poolsize
+    @max_pool_size
+  end
+
+  def get(should_wait=true, &block)
+    cx = nil
+
+    # get a cx from the pool
+    begin
+      # see if we can get one.  don't wait if we can't.
+      cx = @pool.pop(true)
+    rescue ThreadError
+      # We did not get one.  Can we grow?
+      if @max_pool_size < 0 or @cur_pool_size < @max_pool_size
+        @mutex.synchronize {
+          @cur_pool_size += 1
+          if @max_pool_size >= 0 and @cur_pool_size > @max_pool_size
+            # back out of our creation (unwind after detecting we lost a
+            # a comparison race condition)
+            @cur_pool_size -= 1
+          else
+            cx = @block.call
+          end
+        }
+      end
+    end
+
+    if cx.nil?
+      begin
+        cx = @pool.pop(!should_wait)
+      rescue ThreadError
+        return nil
+      end
+    end
+
+    # now we have a cx.
+    if block.nil?
+      return cx
+    end
+
+    begin
+      r = yield cx
+    ensure
+      self.release(cx)
+    end
+    return r
+  end
+
+  def release(cx)
+    if @max_pool_size < 0 or (@max_pool_size > 0 and @cur_pool_size <= @max_pool_size)
+      @pool.push cx
+    else
+      @mutex.synchronize {
+        @cur_pool_size -= 1
+        @cur_pool_size = 0 if @cur_pool_size < 0
+      }
+      # XXX: close cx somehow?
+    end
+    nil
+  end
+end
+

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: lazy_connection_pool
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Joel Boutros
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-18 00:00:00.000000000 Z
+dependencies: []
+description: A lazy connection pooler for Ruby.  Supports lazy connection allocation
+  and dynamic pool sizing.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- LICENSE.md
+- README.md
+- lazy_connection_pool.gemspec
+- lib/lazy_connection_pool.rb
+homepage: http://github.com/jaydeebee/lazy_connection_pool
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: A lazy connection pooler for Ruby
+test_files: []