cassilds-connection-pool 0.0.2

data/.gitignore

@@ -0,0 +1,2 @@
+pools*.gem
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) Michael Rykov
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,30 @@
+cassilds-connection-pool
+-----
+(forked from rykov/pools)
+
+Our interest in on Cassandra connection pooling.
+
+See Cassilds, and Cassilds-Model.
+
+-----
+
+Provides connection pooling for multiple services that use persistent connections.
+
+Installation
+============
+
+    $ gem install cassilds-connection-pool
+
+
+Notes
+=====
+
+We have copied ActiveSupport::Concern to our initializer directory in Rails config!!
+
+
+Author
+=====
+
+Michael Rykov :: mrykov@gmail.com
+
+Umanni        :: contato@umanni.com.br

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler'
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+task :default => :spec
+task :test    => :spec
+
+task :noop do; end
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new(:spec => :noop)
+
+Bundler::GemHelper.install_tasks

data/cassilds-connection-pool.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "pools/version"
+
+Gem::Specification.new do |s|
+  s.name          = "cassilds-connection-pool"
+  s.version       = Pools::VERSION
+  s.platform      = Gem::Platform::RUBY
+  s.date          = Time.now.strftime('%Y-%m-%d')
+  s.summary       = "Generalized connection pooling"
+  s.homepage      = "http://github.com/umanni/cassilds-connection-pool"
+  s.email         = ["mrykov@gmail", "contato@umanni.com.br"]
+  s.authors       = [ "Michael Rykov", "Umanni" ]
+  s.has_rdoc      = false
+
+  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.require_paths = ["lib"]
+
+  s.add_dependency 'activesupport', '>= 3.0.0', '< 3.2'
+
+  s.description = <<DESCRIPTION
+Generalized connection pooling
+DESCRIPTION
+end

data/lib/cassandra/pooled.rb

@@ -0,0 +1,40 @@
+require 'pools'
+require 'cassandra'
+
+class Cassandra
+  class Pooled
+    include ::Pools::Pooled
+
+    def initialize(*args)
+      @cassandra_args = args.dup
+      super
+    end
+
+    def __connection
+      Cassandra.new(*@cassandra_args)
+    end
+
+    def __disconnect(client)
+      client.disconnect! if client
+    end
+
+    preparation_methods :login!, :disable_node_auto_discovery!
+
+    connection_methods *(Cassandra.public_instance_methods(false) - [:login!, :disable_node_auto_discovery!])
+      # :add, :add_column_family, :add_keyspace, :auth_request, 
+      # :batch, :clear_column_family!, :clear_keyspace!, :cluster_name, 
+      # :column_families, :count_columns, :count_range, :create_idx_clause, 
+      # :create_idx_expr, :create_index, :create_index_clause, :create_index_expression, 
+      # :default_read_consistency=, :default_write_consistency=, 
+      # :disable_node_auto_discovery!, :disconnect!, :drop_column_family, :drop_index, 
+      # :drop_keyspace, :each, :each_key, :exists?, :get, :get_columns, 
+      # :get_indexed_slices, :get_range, :get_range_batch, :get_range_keys, 
+      # :get_range_single, :insert, :inspect, :keyspace, :keyspace=, :keyspaces, 
+      # :login!, :multi_count_columns, :multi_get, :multi_get_columns, 
+      # :partitioner, :remove, :rename_column_family, :rename_keyspace, :ring, 
+      # :schema, :schema_agreement?, :servers, :thrift_client_class, 
+      # :thrift_client_options, :truncate!, :update_column_family, 
+      # :update_keyspace, :version
+
+  end
+end

data/lib/pools.rb

@@ -0,0 +1,6 @@
+require 'pools/connection_pool'
+require 'pools/handler'
+require 'pools/middleware'
+require 'pools/pooled'
+
+require 'pools/engine' if defined?(Rails)

data/lib/pools/connection_pool.rb

@@ -0,0 +1,237 @@
+##
+# This file adapted from activerecord gem
+#
+
+require 'thread'
+require 'monitor'
+require 'set'
+require 'active_support/core_ext/module/synchronization'
+
+module Pools
+  # Raised when a connection could not be obtained within the connection
+  # acquisition timeout period.
+  ConnectionNotEstablished = Class.new(StandardError)
+  ConnectionTimeoutError = Class.new(ConnectionNotEstablished)
+
+  # Connection pool base class for managing Active Record database
+  # connections.
+  #
+  # == Introduction
+  #
+  # A connection pool synchronizes thread access to a limited number of
+  # database connections. The basic idea is that each thread checks out a
+  # database connection from the pool, uses that connection, and checks the
+  # connection back in. ConnectionPool is completely thread-safe, and will
+  # ensure that a connection cannot be used by two threads at the same time,
+  # as long as ConnectionPool's contract is correctly followed. It will also
+  # handle cases in which there are more threads than connections: if all
+  # connections have been checked out, and a thread tries to checkout a
+  # connection anyway, then ConnectionPool will wait until some other thread
+  # has checked in a connection.
+  #
+  # == Obtaining (checking out) a connection
+  #
+  # Connections can be obtained and used from a connection pool in several
+  # ways:
+  #
+  # 1. Simply use ActiveRecord::Base.connection as with Active Record 2.1 and
+  #    earlier (pre-connection-pooling). Eventually, when you're done with
+  #    the connection(s) and wish it to be returned to the pool, you call
+  #    ActiveRecord::Base.clear_active_connections!. This will be the
+  #    default behavior for Active Record when used in conjunction with
+  #    Action Pack's request handling cycle.
+  # 2. Manually check out a connection from the pool with
+  #    ActiveRecord::Base.connection_pool.checkout. You are responsible for
+  #    returning this connection to the pool when finished by calling
+  #    ActiveRecord::Base.connection_pool.checkin(connection).
+  # 3. Use ActiveRecord::Base.connection_pool.with_connection(&block), which
+  #    obtains a connection, yields it as the sole argument to the block,
+  #    and returns it to the pool after the block completes.
+  #
+  # Connections in the pool are actually AbstractAdapter objects (or objects
+  # compatible with AbstractAdapter's interface).
+  #
+  # == Options
+  #
+  # There are two connection-pooling-related options that you can add to
+  # your database connection configuration:
+  #
+  # * +pool+: number indicating size of connection pool (default 20)
+  # * +wait_timeout+: number of seconds to block and wait for a connection
+  #   before giving up and raising a timeout error (default 10 seconds).
+  class ConnectionPool
+    attr_reader :options, :connections
+
+    # Creates a new ConnectionPool object. +spec+ is a ConnectionSpecification
+    # object which describes database connection information (e.g. adapter,
+    # host name, username, password, etc), as well as the maximum size for
+    # this ConnectionPool.
+    #
+    # The default ConnectionPool maximum size is 20.
+    def initialize(pooled, options)
+      @pooled = pooled
+      @options = options
+
+      # The cache of reserved connections mapped to threads
+      @reserved_connections = {}
+
+      # The mutex used to synchronize pool access
+      @connection_mutex = Monitor.new
+      @queue = @connection_mutex.new_cond
+
+      # default 10 second timeout unless on ruby 1.9
+      @timeout = options[:wait_timeout] || 10
+
+      # default max pool size to 20
+      @size = (options[:pool] && options[:pool].to_i) || 20
+
+      @connections = []
+      @checked_out = []
+    end
+
+    # Retrieve the connection associated with the current thread, or call
+    # #checkout to obtain one if necessary.
+    #
+    # #connection can be called any number of times; the connection is
+    # held in a hash keyed by the thread id.
+    def connection
+      @reserved_connections[current_connection_id] ||= checkout
+    end
+
+    # Signal that the thread is finished with the current connection.
+    # #release_connection releases the connection-thread association
+    # and returns the connection to the pool.
+    def release_connection(with_id = current_connection_id)
+      conn = @reserved_connections.delete(with_id)
+      checkin conn if conn
+    end
+
+    # If a connection already exists yield it to the block.  If no connection
+    # exists checkout a connection, yield it to the block, and checkin the
+    # connection when finished.
+    def with_connection
+      connection_id = current_connection_id
+      fresh_connection = true unless @reserved_connections[connection_id]
+      yield connection
+    ensure
+      release_connection(connection_id) if fresh_connection
+    end
+
+    # Returns true if a connection has already been opened.
+    def connected?
+      !@connections.empty?
+    end
+
+    # Disconnects all connections in the pool, and clears the pool.
+    def disconnect!
+      @reserved_connections.each do |name,conn|
+        checkin conn
+      end
+      @reserved_connections = {}
+      @connections.each do |conn|
+        @pooled.__disconnect(conn)
+      end
+      @connections = []
+    end
+
+    # Verify active connections and remove and disconnect connections
+    # associated with stale threads.
+    def verify_active_connections! #:nodoc:
+      clear_stale_cached_connections!
+      @connections.each do |connection|
+        @pooled.__disconnect(connection)
+      end
+    end
+
+    # Return any checked-out connections back to the pool by threads that
+    # are no longer alive.
+    def clear_stale_cached_connections!
+      keys = @reserved_connections.keys - Thread.list.find_all { |t|
+        t.alive?
+      }.map { |thread| thread.object_id }
+      keys.each do |key|
+        checkin @reserved_connections[key]
+        @reserved_connections.delete(key)
+      end
+    end
+
+    # Check-out a database connection from the pool, indicating that you want
+    # to use it. You should call #checkin when you no longer need this.
+    #
+    # This is done by either returning an existing connection, or by creating
+    # a new connection. If the maximum number of connections for this pool has
+    # already been reached, but the pool is empty (i.e. they're all being used),
+    # then this method will wait until a thread has checked in a connection.
+    # The wait time is bounded however: if no connection can be checked out
+    # within the timeout specified for this pool, then a ConnectionTimeoutError
+    # exception will be raised.
+    #
+    # Returns: an AbstractAdapter object.
+    #
+    # Raises:
+    # - ConnectionTimeoutError: no connection can be obtained from the pool
+    #   within the timeout period.
+    def checkout
+      # Checkout an available connection
+      @connection_mutex.synchronize do
+        loop do
+          conn = if @checked_out.size < @connections.size
+                   checkout_existing_connection
+                 elsif @connections.size < @size
+                   checkout_new_connection
+                 end
+          return conn if conn
+
+          @queue.wait(@timeout)
+
+          if(@checked_out.size < @connections.size)
+            next
+          else
+            clear_stale_cached_connections!
+            if @size == @checked_out.size
+              raise ConnectionTimeoutError, "could not obtain a pooled connection#{" within #{@timeout} seconds" if @timeout}.  The max pool size is currently #{@size}; consider increasing it."
+            end
+          end
+
+        end
+      end
+    end
+
+    # Check-in a database connection back into the pool, indicating that you
+    # no longer need this connection.
+    #
+    # +conn+: an AbstractAdapter object, which was obtained by earlier by
+    # calling +checkout+ on this pool.
+    def checkin(conn)
+      @connection_mutex.synchronize do
+        @checked_out.delete conn
+        @queue.signal
+      end
+    end
+
+    synchronize :verify_active_connections!, :connected?, :disconnect!,
+                :with => :@connection_mutex
+
+  private
+    def current_connection_id #:nodoc:
+      Thread.current.object_id
+    end
+
+    def checkout_new_connection
+      c = @pooled.__connection
+      @pooled.__prepare(c)
+      @connections << c
+      checkout_connection(c)
+    end
+
+    def checkout_existing_connection
+      c = (@connections - @checked_out).first
+      checkout_connection(c)
+    end
+
+    def checkout_connection(c)
+      @checked_out << c
+      c
+    end
+  end
+end

data/lib/pools/engine.rb

@@ -0,0 +1,19 @@
+require 'rails'
+
+module Pools
+  class Engine < Rails::Engine
+	engine_name :pools
+
+    # The tests bellow did not work
+
+    # Test 1
+    # middleware.use Pools::Middleware
+
+    # Test 2
+	# initializer "pools.configure_pools_middleware" do |app|
+	#   app.middleware.use Pools::Middleware
+    # end
+
+  end
+end
+

data/lib/pools/handler.rb

@@ -0,0 +1,62 @@
+##
+# This file adapted from activerecord gem
+#
+
+module Pools
+  class Handler
+    attr_reader :pools
+
+    def initialize(pools = {})
+      @pools = pools
+    end
+
+    # Add a new connection pool to the mix
+    def add(pool, name = nil)
+      @pools[name || pool.object_id] = pool
+    end
+
+    # Returns any connections in use by the current thread back to the
+    # pool, and also returns connections to the pool cached by threads
+    # that are no longer alive.
+    def clear_active_connections!
+      @pools.each_value {|pool| pool.release_connection }
+    end
+
+    def clear_all_connections!
+      @pools.each_value {|pool| pool.disconnect! }
+    end
+
+    # Verify active connections.
+    def verify_active_connections! #:nodoc:
+      @pools.each_value {|pool| pool.verify_active_connections! }
+    end
+
+    # Returns true if a connection that's accessible to this class has
+    # already been opened.
+    def connected?(name)
+      conn = retrieve_connection_pool(name)
+      conn && conn.connected?
+    end
+
+    # Remove the connection for this class. This will close the active
+    # connection and the defined connection (if they exist). The result
+    # can be used as an argument for establish_connection, for easily
+    # re-establishing the connection.
+    def remove_connection(name)
+      pool = retrieve_connection_pool(name)
+      return nil unless pool
+
+      @pools.delete_if { |key, value| value == pool }
+      pool.disconnect!
+    end
+
+    def retrieve_connection_pool(name)
+      pool = @pools[name]
+      return pool if pool
+    end
+  end
+
+  def self.handler
+    @@pool_handler ||= Handler.new
+  end
+end

data/lib/pools/middleware.rb

@@ -0,0 +1,17 @@
+##
+# This file adapted from activerecord gem
+#
+
+module Pools
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    ensure
+      Pools.handler.clear_active_connections!
+    end
+  end
+end

data/lib/pools/pooled.rb

@@ -0,0 +1,52 @@
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/concern'
+
+module Pools
+  module Pooled
+    extend ActiveSupport::Concern
+    attr_reader :connection_pool, :preparation_chain
+
+    def initialize(*args)
+      options = args.extract_options!
+      @preparation_chain = []
+      @connection_pool = ConnectionPool.new(self, options)
+      Pools.handler.add(@connection_pool, options[:pool_name])
+    end
+
+    def with_connection(&block)
+      @connection_pool.with_connection(&block)
+    end
+
+    def __connection
+      # Override in parent
+    end
+
+    def __disconnect(connection)
+      # Override in parent
+    end
+
+    def __prepare(connection)
+      @preparation_chain.each { |args| connection.send(*args) }
+    end
+
+    module ClassMethods
+      def connection_methods(*methods)
+        methods.each do |method|
+          define_method(method) do |*params, &block|
+            with_connection do |client|
+              client.send(method, *params, &block)
+            end
+          end
+        end
+      end
+
+      def preparation_methods(*methods)
+        methods.each do |method|
+          define_method(method) do |*params|
+            @preparation_chain << ([method] + params)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pools/version.rb

@@ -0,0 +1,4 @@
+class Pools
+  VERSION = '0.0.2'
+end
+

data/lib/redis/pooled.rb

@@ -0,0 +1,44 @@
+require 'pools'
+require 'redis'
+
+class Redis
+  class Pooled
+    include ::Pools::Pooled
+
+    def initialize(options = {})
+      @redis_options = options
+      super
+    end
+
+    def __connection
+      Redis.connect(@redis_options)
+    end
+
+    def __disconnect(client)
+      client.quit if client
+    end
+
+    # Method not supported:
+    # Subscribe/Unsubscribe methods and the following...
+    # :auth, :select, :discard, :quit, :watch, :unwatch
+    # :exec, :multi, :disconnect
+
+    connection_methods :info, :config, :flushdb, :flushall, :save,
+      :bgsave, :bgrewriteaof, :get, :getset, :mget, :append, :substr,
+      :strlen, :hgetall, :hget, :hdel, :hkeys, :keys, :randomkey,
+      :echo, :ping, :lastsave, :dbsize, :exists, :llen, :lrange,
+      :ltrim, :lindex, :linsert, :lset, :lrem, :rpush, :rpushx,
+      :lpush, :lpushx, :rpop, :blpop, :brpop, :rpoplpush, :lpop,
+      :smembers, :sismember, :sadd, :srem, :smove, :sdiff, :sdiffstore,
+      :sinter, :sinterstore, :sunion, :sunionstore, :spop, :scard,
+      :srandmember, :zadd, :zrank, :zrevrank, :zincrby, :zcard,
+      :zrange, :zrangebyscore, :zcount, :zrevrange, :zremrangebyscore,
+      :zremrangebyrank, :zscore, :zrem, :zinterstore, :zunionstore,
+      :move, :setnx, :del, :rename, :renamenx, :expire, :persist,
+      :ttl, :expireat, :hset, :hsetnx, :hmset, :mapped_hmset, :hmget,
+      :mapped_hmget, :hlen, :hvals, :hincrby, :hexists, :monitor,
+      :debug, :sync, :[], :[]=, :set, :setex, :mset, :mapped_mset,
+      :msetnx, :mapped_msetnx, :mapped_mget, :sort, :incr, :incrby,
+      :decr, :decrby, :type, :publish, :id
+  end
+end

data/lib/redis/pooled_store.rb

@@ -0,0 +1,40 @@
+require 'redis-store'
+require 'redis/pooled'
+
+class Redis
+  class PooledStore < Pooled
+    include Store::Ttl, Store::Interface
+
+    def initialize(options = { })
+      super
+      _extend_marshalling options
+    end
+
+    def self.rails3? #:nodoc:
+      defined?(::Rails) && ::Rails::VERSION::MAJOR == 3
+    end
+
+    def to_s
+      with_connection do |c|
+        "Redis::Pooled => #{c.host}:#{c.port} against DB #{c.db}"
+      end
+    end
+
+  private
+    def _extend_marshalling(options) # Copied from Store
+      @marshalling = !(options[:marshalling] === false)
+      extend Store::Marshalling if @marshalling
+    end
+  end
+
+  class << Store
+    def new(*args)
+      if args.size == 1 && args.first.is_a?(Hash) && args.first[:pool]
+        PooledStore.new(*args)
+      else
+        super(*args)
+      end
+    end
+  end
+end
+

data/spec/pooled_spec.rb

@@ -0,0 +1,141 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'logger'
+
+class TestPool
+  include Pools::Pooled
+
+  class Connection
+    attr_accessor :valid, :prepared
+
+    def test_method
+      '__TEST__'
+    end
+
+    def test_method_with_args(input)
+      input
+    end
+
+    def prepare_method(value)
+      self.prepared = value
+    end
+
+    def yielding_method(value)
+      yield(value)
+    end
+  end
+
+  def __connection
+    c = Connection.new
+    c.valid = true
+    c.prepared = false
+    c
+  end
+
+  preparation_methods :prepare_method
+  connection_methods :test_method, :test_method_with_args, :prepared,
+                     :yielding_method
+end
+
+describe Pools::Pooled do
+  def checkout_connections
+    @pool = TestPool.new(:pool => 2, :wait_timeout => 0.3)
+    @connections = []
+    @timed_out = 0
+
+    4.times do
+      Thread.new do
+        begin
+          @connections << @pool.connection_pool.checkout
+        rescue Pools::ConnectionTimeoutError
+          @timed_out += 1
+        end
+      end.join
+    end
+  end
+
+  it "test timeout" do
+    checkout_connections
+    @connections.length.should == 2
+    @timed_out.should == 2
+  end
+
+  def checkout_checkin_connections(pool_size, threads)
+    @pool = TestPool.new(:pool => pool_size, :wait_timeout => 0.5)
+    @connection_count = 0
+    @timed_out = 0
+    threads.times do
+      Thread.new do
+        begin
+          conn = @pool.connection_pool.checkout
+          sleep 0.1
+          @pool.connection_pool.checkin conn
+          @connection_count += 1
+        rescue ActiveRecord::ConnectionTimeoutError
+          @timed_out += 1
+        end
+      end.join
+    end
+  end
+
+  it "pass connection checkout" do
+    checkout_checkin_connections 1, 2
+    @connection_count.should == 2
+    @timed_out.should == 0
+    @pool.connection_pool.connections.size.should == 1
+  end
+
+  it "pass connection checkout overbooking" do
+    checkout_checkin_connections 2, 3
+    @connection_count.should == 3
+    @timed_out.should == 0
+    @pool.connection_pool.connections.size.should == 1
+  end
+
+  it "should check out an existing connection" do
+    cpool = TestPool.new(:pool => 1).connection_pool
+    orig_conn = cpool.checkout
+    cpool.checkin(orig_conn)
+    conn = cpool.checkout
+    conn.should == orig_conn
+    conn.should be_a(TestPool::Connection)
+    cpool.checkin(conn)
+  end
+
+  it "should not be connected on init" do
+    cpool = TestPool.new(:pool => 1).connection_pool
+    cpool.connected?.should be_false
+    cpool.with_connection { }
+    cpool.connected?.should be_true
+  end
+
+  it "with_connection provides a connection" do
+    pool = TestPool.new
+    pool.with_connection do |conn|
+      conn.should be_a(TestPool::Connection)
+    end
+  end
+
+  it "respond to client methods" do
+    pool = TestPool.new
+    pool.test_method.should == '__TEST__'
+    pool.test_method_with_args('hi').should == 'hi'
+  end
+
+  it "respond to yielding methods" do
+    pool = TestPool.new
+    pool.yielding_method(15) do |value|
+      value.should == 15
+    end
+  end
+
+  it "not prematurely call preparation methods" do
+    pool = TestPool.new
+    pool.prepared.should be_false
+  end
+
+  it "not prematurely call preparation methods" do
+    pool = TestPool.new
+    pool.prepare_method(15)
+    pool.prepared.should == 15
+  end
+end

data/spec/redis_spec.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'logger'
+require 'redis/pooled'
+
+describe Redis::Pooled do
+  let(:rpool) { Redis::Pooled.new(:pool => 1) }
+
+  it "create a client" do
+    rpool.with_connection do |conn|
+      conn.should be_a(Redis)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+$TESTING=true
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'pools'

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: cassilds-connection-pool
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Michael Rykov
+- Umanni
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-22 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &19260040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: *19260040
+description: ! 'Generalized connection pooling
+
+'
+email:
+- mrykov@gmail
+- contato@umanni.com.br
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- cassilds-connection-pool.gemspec
+- lib/cassandra/pooled.rb
+- lib/pools.rb
+- lib/pools/connection_pool.rb
+- lib/pools/engine.rb
+- lib/pools/handler.rb
+- lib/pools/middleware.rb
+- lib/pools/pooled.rb
+- lib/pools/version.rb
+- lib/redis/pooled.rb
+- lib/redis/pooled_store.rb
+- spec/pooled_spec.rb
+- spec/redis_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/umanni/cassilds-connection-pool
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Generalized connection pooling
+test_files: []