1
0
Fork 0
mirror of https://github.com/mperham/connection_pool synced 2023-03-27 23:22:21 -04:00
Generic connection pooling for Ruby
Find a file
Damian Janowski 5053b327f1 Checking in pushes objects to the head of the queue.
This means that, when not saturated, objects in the pool will be reused
more often.

This behavior allows you to create a pool of objects which in turn have
some kind of time outs themselves. For instance, objects which keep an
underlying TCP connection open until they're idle for some time. An
example of this is `Net::HTTP::Persistent`.

See also issue #20.
2012-12-18 14:05:13 -03:00
lib Checking in pushes objects to the head of the queue. 2012-12-18 14:05:13 -03:00
test Checking in pushes objects to the head of the queue. 2012-12-18 14:05:13 -03:00
.gitignore Initial pass at a generic connection pool 2011-05-14 12:29:51 -07:00
Changes.md Doc, bump version 2012-06-29 20:22:42 -07:00
connection_pool.gemspec Add homepage to gemspec. 2012-10-08 17:28:24 -03:00
Gemfile Suggestions from @brixen 2011-09-25 19:23:35 -07:00
LICENSE Add project info, tests 2011-05-14 15:36:17 -07:00
Rakefile Don't require Bundler to run tests. 2012-12-18 13:35:50 -03:00
README.md Document what will happen if the pool is empty. 2012-11-02 12:21:57 -06:00

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.

Usage

Create a pool of objects to share amongst the fibers or threads in your Ruby application:

@memcached = ConnectionPool.new(:size => 5, :timeout => 5) { Dalli::Client.new }

Then use the pool in your application:

@memcached.with_connection do |dalli|
  dalli.get('some-count')
end

If all the objects in the connection pool are in use, with_connection will block until one becomes available. If no object is available within :timeout seconds, with_connection will raise a Timeout::Error.

You can use ConnectionPool::Wrapper to wrap a single global connection, making it easier to port your connection code over time:

$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_connection as soon as possible.

$redis.with_connection do |conn|
  conn.sadd('foo', 1)
  conn.smembers('foo')
end

Once you've ported your entire system to use with, you can simply remove ::Wrapper and use a simple, fast ConnectionPool.

Author

Mike Perham, @mperham, http://mikeperham.com