hot_tub 0.2.0 → 0.2.1

data/.travis.yml

@@ -6,3 +6,6 @@ rvm:
   - rbx-19mode
   - ruby-head
   - jruby-head
+matrix:
+  allow_failures:
+    - rvm: 1.9.2

data/Gemfile

@@ -5,7 +5,6 @@ gemspec
 gem 'rake'
 
 group :development do
-	gem 'excon'
   platform :ruby do
     gem 'eventmachine'
     gem 'em-http-request', '~> 1.0', :require => 'em-http'

data/README.md

@@ -1,8 +1,23 @@
 # HotTub [![Build Status](https://travis-ci.org/JoshMcKin/hot_tub.png?branch=master)](https://travis-ci.org/JoshMcKin/hot_tub)
-A simple thread-safe connection pooling gem. Out-of-the-box support for [Excon](https://github.com/geemus/excon) and
+A simple thread-safe connection pool and sessions gem. Out-of-the-box support for [Excon](https://github.com/geemus/excon) and
 [EM-Http-Requests](https://github.com/igrigorik/em-http-request) via [EM-Synchrony](https://github.com/igrigorik/em-synchrony). 
-There are a couple Ruby connection pool libraries out there but HotTub differs from most in that its connections are lazy 
-(created only when necessary), accomidates libraries that do not clean their dirty connections automatically, and manages unexpected usage increases by opening new connections rather than just blocking or throwing exceptions (never_block), although never_block can be disabled. 
+There are a couple Ruby connection pooling libraries out there but HotTub differs from most with all its features.
+
+## Features
+
+### HotTub::Pool
+* Thread safe
+* Lazy clients/connections (created only when necessary)
+* Can be used with any client library
+* Support for cleaning dirty resources
+* Set to expand pool under load that is eventually reaped back down to set size (never_block), can be disabled
+* Attempts to close clients/connections at_exit
+
+### HotTub::Sessions
+* Thread safe
+* The same api as HotTub::Pool
+* Can be used with HotTub::Pool or any client library 
+* Attempts to close clients/connections at_exit
 
 ## Installation
 
@@ -10,105 +25,93 @@ HotTub is available through [Rubygems](https://rubygems.org/gems/hot_tub) and ca
 
     $ gem install hot_tub
 
-## Usage 
+## Rails setup
 
-### Excon
+Add hot_tub to your gemfile:
+    
+    gem 'hot_tub'
 
-    require 'excon'
-    class MyClass
-      @@url = "http://test12345.com"
-      @@pool = HotTub::Pool.new({:size => 10}) { Excon.new("http://somewebservice.com") }
-      def self.fetch_results(url,query={})
-        @@pool.run |connection|
-          connection.get(:query => query).body
-        end
-      end
-    end
-    MyClass.fetch_results({:foo => "goo"}) # => "Some reponse"
+Run bundle:
+    
+    bundle install
 
-### EM-Http-Request
+Configure Logger by creating a hot_tub.rb initializer and adding the following:
+    
+    HotTub.logger = Rails.logger
 
-    require "em-synchrony"
-    require "em-synchrony/em-http"
-    class EMClass
-      @@pool = HotTub::Pool.new(:size => 12) { EM::HttpRequest.new("http://somewebservice.com") }
-      def async_post_results(query = {})
-        @@pool.run do |connection|    
-          connection.aget(:query => results, :keepalive => true)
-        end
-      end
-    end
+# Usage 
+
+## HotTub::Pool
 
+### EM-Http-Request
+    require 'hot_tub'
+    require 'em-synchrony'
+    require 'em-synchrony/em-http'
     EM.synchrony do {
-      EMClass.async_fetch_results({:foo => "goo"})
+      pool = HotTub::Pool.new(:size => 12) { EM::HttpRequest.new("http://somewebservice.com") }
+      pool.run { |clnt| clnt.aget(:query => results, :keepalive => true) }
       EM.stop
     }
 
 ### Other
- You can use any libary you want. Close and clean can be defined at initialization with
- lambdas, if they are not defined they are ignored.
+You can use any library you want with HotTub::Pool, regardless of that clients thread-safety status.
+Close and clean can be defined at initialization with lambdas, if they are not defined they are ignored.
 
+    url = "http://test12345.com"
+    pool = HotTub::Pool.new({:size => 10, :close => lambda {|clnt| clnt.close}}) { MyHttpLib.new }
+    pool.run { |clnt| clnt.get(@@url,query).body }
+ 
+## HotTub::Sessions Usage 
+HotTub::Sessions are a synchronized hash of clients/pools and are implemented similar HotTub::Pool. 
+For example, Excon is thread safe but you set a single url at the client level so sessions 
+are handy if you need to access multiple urls but would prefer a single object.
+    
+    require 'hot_tub'
     require 'excon'
-    class MyClass
-      @@url = "http://test12345.com"
-      @@pool = HotTub::Pool.new({:size => 10, :close => lambda {|clnt| clnt.close}}) { MyHttpLib.new }
-      def self.fetch_results(url,query={})
-        @@pool.run |connection|
-          connection.get(@@url,query).body
-        end
-      end
+    # Our client block must accept the url argument
+    sessions = HotTub::Sessions.new {|url| Excon.new(url) }
+
+    sessions.run("http://somewebservice.com") do |clnt|    
+      puts clnt.get(:query => {:some => 'stuff'}).response_header.status
+    end
+    sessions.run("https://someotherwebservice.com") do |clnt|    
+      puts clnt.get(:query => {:other => 'stuff'}).response_header.status
+    end
+    sessions.run("https://127.0.0.1:5252") do |clnt|    
+      puts clnt.get.response_header.status
     end
 
-    MyClass.fetch_results({:foo => "goo"}) # => "Some reponse"
+### HotTub::Sessions with HotTub::Pool
+Suppose you have a client that is not thread safe, you can use HotTub::Pool with HotTub::Sessions to get what you need.
+    
+    require 'hot_tub'
+    require "em-synchrony"
+    require "em-synchrony/em-http"
+    # Our client block must accept the url argument
 
-## Sessions with Pool
-Not all clients have a sessions feature, Excon and Em-Http-Request clients are initialized to a single domain and while you
-can change paths the client domain cannot change. HotTub::Session allows you create a session object that initializes
-seperate pools for your various domains based on URI. Options are passed to the pool when each pool is initialized.
+    EM.synchrony do {
+      sessions = HotTub::Sessions.new {|url| HotTub::Pool.new(:size => 12) { EM::HttpRequest.new(url, :inactivity_timeout => 0) }}
 
-    require 'excon'
-    class MyClass
-      # Our client block must accept the url argument
-      @@sessons = HotTub::Sessions.new(:size => 10) {|url| { Excon.new(url) } 
-      def async_post_results(query = {})
-        @@sessons.run("http://somewebservice.com") do |connection|    
-          puts connection.run(:query => results).response_header.status
-        end
-        @@sessons.run("https://someotherwebservice.com") do |connection|    
-          puts connection.get(:query => results).response_header.status
-        end
+      sessions.run("http://somewebservice.com") do |clnt|    
+        puts clnt.get(:query => results).response_header.status
       end
-    end
-
-## Sessions without Pool
-If you have a client that is thread safe but does not support sessions you can implement sessions similarly. Excon
-is thread safe but you are using a single client, so you may loose preformance with multithreading.
-    
-    require 'excon'
-    class MyClass
-      # Our client block must accept the url argument
-      @@sessons = HotTub::Sessions.new(:with_pool => false) {|url| Excon.new(url) }
-      def async_post_results(query = {})
-        @@sessons.run("http://somewebservice.com") do |connection|    
-          puts connection.get(:query => results).response_header.status
-        end
-        @@sessons.run("https://someotherwebservice.com") do |connection|    
-          puts connection.get(:query => results).response_header.status
-        end
+      sessions.run("https://someotherwebservice.com") do |clnt|    
+        puts clnt.get(:query => results).response_header.status
       end
-    end
+      EM.stop
+    }
 
 ## Related
 
 * [EM-Http-Request](https://github.com/igrigorik/em-http-request)
 * [EM-Synchrony](https://github.com/igrigorik/em-synchrony)
-* [Excon](https://github.com/geemus/excon)
-* [HTTPClient](https://github.com/nahi/httpclient) A thread safe http client that supports sessions all by itself.
+* [Excon](https://github.com/geemus/excon) Thread safe with its own built in pool.
+* [HTTPClient](https://github.com/nahi/httpclient) A thread safe http client that supports pools and sessions all by itself.
 
 ## Other Pooling Gem
 
 * [ConnectionPool](https://github.com/mperham/connection_pool)
-* [EM-Synchrony](https://github.com/igrigorik/em-synchrony) has a connection pool feature
+* [EM-Synchrony](https://github.com/igrigorik/em-synchrony) has a pool feature
 
 ## Contributing to HotTub
  

data/hot_tub.gemspec

@@ -13,7 +13,11 @@ Gem::Specification.new do |s|
   s.description = %q{A simple thread-safe http connection pooling gem. Http client options include HTTPClient and EM-Http-Request}
 
   s.rubyforge_project = "hot_tub"
+  
   s.add_development_dependency "rspec"
+  s.add_development_dependency "sinatra"
+  s.add_development_dependency "puma"
+  s.add_development_dependency "excon"
   
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/hot_tub/known_clients.rb

@@ -0,0 +1,47 @@
+module HotTub
+  module KnownClients
+    KNOWN_CLIENTS = {
+      "Excon::Connection" => {
+        :close => lambda { |clnt| clnt.reset }
+      },
+      'EventMachine::HttpConnection' => {
+        :close => lambda { |clnt|
+          if clnt.conn
+            clnt.conn.close_connection
+            clnt.instance_variable_set(:@deferred, true)
+          end
+        },
+        :clean => lambda { |clnt|
+          if clnt.conn && clnt.conn.error?
+            HotTub.logger.info "Sanitizing connection : #{EventMachine::report_connection_error_status(clnt.conn.instance_variable_get(:@signature))}"
+            clnt.conn.close_connection
+            clnt.instance_variable_set(:@deferred, true)
+          end
+          clnt
+        }
+      }
+    }
+    attr_accessor :options
+    # Attempts to clean the provided client, checking the options first for a clean block
+    # then checking the known clients
+    def clean_client(clnt)
+      return @options[:clean].call(clnt) if @options && @options[:clean] && @options[:clean].is_a?(Proc)
+      if settings = KNOWN_CLIENTS[clnt.class.name]
+        settings[:clean].call(clnt) if settings[:clean].is_a?(Proc)
+      end
+    end
+
+    # Attempts to close the provided client, checking the options first for a close block
+    # then checking the known clients
+    def close_client(clnt)
+      return @options[:close].call(clnt) if @options && @options[:close] && @options[:close].is_a?(Proc)
+      if settings = KNOWN_CLIENTS[clnt.class.name]
+        begin
+          settings[:close].call(clnt) if settings[:close].is_a?(Proc)
+        rescue => e
+          HotTub.logger.error "There was an error close one of your #{self.class.name} connections: #{e}"
+        end
+      end
+    end
+  end
+end

data/lib/hot_tub/pool.rb

@@ -1,49 +1,25 @@
 module HotTub
   class Pool
-    attr_reader :current_size
-    KNOWN_CLIENTS = {
-      "Excon::Connection" => {
-        :close => lambda { |clnt| clnt.reset }
-      },
-      'EventMachine::HttpConnection' => {
-        :close => lambda { |clnt|
-          if clnt.conn
-            clnt.conn.close_connection
-            clnt.instance_variable_set(:@deferred, true)
-          end
-        },
-        :clean => lambda { |clnt|
-          if clnt.conn && clnt.conn.error?
-            HotTub.logger.info "Sanitizing connection : #{EventMachine::report_connection_error_status(clnt.conn.instance_variable_get(:@signature))}"
-            clnt.conn.close_connection
-            clnt.instance_variable_set(:@deferred, true)
-          end
-          clnt
-        }
-      }
-    }
-
+    include HotTub::KnownClients
+    attr_reader :current_size, :fetching_client, :last_activity
+    
     # Thread-safe lazy connection pool
     #
-    # == Example Excon
-    #     pool = HotTub::Pool.new(:size => 25)  { Excon.new('http://test.com') }
-    #     pool.run {|clnt| clnt.get.body }
-    #
     # == Example EM-Http-Request
     #     pool = HotTub::Pool.new { EM::HttpRequest.new("http://somewebservice.com") }
     #     pool.run {|clnt| clnt.get(:keepalive => true).body }
     #
-    # HotTub::Pool defaults never_block to true, which means if run out of
+    # HotTub::Pool defaults never_block to true, which means if we run out of
     # connections simply create a new client to continue operations.
-    # The pool size will remain consistent and extra connections will be closed
-    # as they are pushed back. If you would like to throw an exception rather than
-    # add new connections set :never_block to false; blocking_timeout defaults to 10 seconds.
+    # The pool will grow and extra connections will be resued until activity dies down. 
+    # If you would like to block and possibly throw an exception rather than temporarily 
+    # grow the set :size, set :never_block to false; blocking_timeout defaults to 10 seconds.
     #
     # == Example without #never_block (will BlockingTimeout exception)
-    #     pool = HotTub::Pool.new(:size => 1, :never_block => false, :blocking_timeout => 0.5) { Excon.new('http://test.com') }
+    #     pool = HotTub::Pool.new(:size => 1, :never_block => false, :blocking_timeout => 0.5) { EM::HttpRequest.new("http://somewebservice.com") }
     #
     #     begin
-    #       pool.run {|clnt| clnt.get.body }
+    #       pool.run {|clnt| clnt.get(:keepalive => true).body }
     #     rescue HotTub::BlockingTimeout => e
     #       puts "Our pool ran out: {e}"
     #     end
@@ -61,8 +37,9 @@ module HotTub
       }.merge(options)
       @pool = []
       @current_size = 0
-      @clients = []
-      @mutex = (HotTub.em? ? EM::Synchrony::Thread::Mutex.new : Mutex.new)
+      @mutex = (HotTub.em_synchrony? ? EM::Synchrony::Thread::Mutex.new : Mutex.new)
+      @last_activity = Time.now
+      @fetching_client = false
     end
 
     # Hand off to client.run
@@ -80,13 +57,12 @@ module HotTub
     # Calls close on all connections and reset the pools
     def close_all
       @mutex.synchronize do
-        while clnt = @clients.pop
+        while clnt = @pool.pop
           begin
             close_client(clnt)
           rescue => e
             HotTub.logger.error "There was an error close one of your HotTub::Pool connections: #{e}"
           end
-          @pool.delete(clnt)
         end
         @current_size = 0
       end
@@ -107,26 +83,8 @@ module HotTub
       clnt
     end
 
-    # Attempts to clean the provided client, checking the options first for a clean block
-    # then checking the known clients
-    def clean_client(clnt)
-      return @options[:clean].call(clnt) if @options[:clean] if @options[:clean].is_a?(Proc)
-      if settings = KNOWN_CLIENTS[clnt.class.name]
-        settings[:clean].call(clnt) if settings[:clean].is_a?(Proc)
-      end
-    end
-
-    # Attempts to close the provided client, checking the options first for a close block
-    # then checking the known clients
-    def close_client(clnt)
-      return @options[:close].call(clnt) if @options[:close] if @options[:close].is_a?(Proc)
-      if settings = KNOWN_CLIENTS[clnt.class.name]
-        settings[:close].call(clnt) if settings[:close].is_a?(Proc)
-      end
-    end
-
     def raise_alarm
-      message = "Could not fetch a free client in time. Consider increasing your pool size for #{@client.class.name}."
+      message = "Could not fetch a free client in time. Consider increasing your pool size."
       HotTub.logger.error message
       raise BlockingTimeout, message
     end
@@ -134,47 +92,59 @@ module HotTub
     # Safely add client back to pool
     def push(clnt)
       @mutex.synchronize do
-        if @pool.length < @options[:size]
-          @pool << clnt
-        else
-          @clients.delete(clnt)
-          close_client(clnt)
-        end
+        @pool << clnt
       end
       nil # make sure never return the pool
     end
 
     # Safely pull client from pool, adding if allowed
     def pop
+      @fetching_client = true # kill reap_pool
       @mutex.synchronize do
         add if add?
-        clnt = @pool.pop
+        clnt = @pool.pop # get warm connection
         if (clnt.nil? && @options[:never_block])
-          HotTub.logger.info "Adding never_block client for #{@client.class.name}."
-          clnt = new_client
+          add
+          clnt = @pool.pop
         end
+        @fetching_client = false
         clnt
       end
+    ensure 
+      reap_pool if reap_pool?
     end
 
     # create a new client from base client
     def new_client
-      clnt = @client_block.call
-      @clients << clnt
-      clnt
+      @client_block.call
     end
 
     # Only want to add a client if the pool is empty in keeping with
     # a lazy model.
     def add?
-      (@pool.length == 0 && @current_size <= @options[:size])
+      (@pool.length == 0 && (@options[:size] > @current_size))
     end
 
     def add
       HotTub.logger.info "Adding HotTub client: #{@client.class.name} to pool"
+      @last_activity = Time.now
       @current_size += 1
       @pool << new_client
     end
+
+    def reap_pool?
+      (!@fetching_client && (@current_size > @options[:size]) && ((@last_activity + (600)) < Time.now))
+    end
+
+    # Remove extra connections from front of pool
+    def reap_pool
+      @mutex.synchronize do
+        if reap_pool? && clnt = @pool.shift
+          @current_size -= 1
+          close_client(clnt)
+        end
+      end
+    end
   end
   class BlockingTimeout < StandardError;end
 end

data/lib/hot_tub/session.rb

@@ -1,42 +1,42 @@
 require 'uri'
 module HotTub
   class Session
-
+    include HotTub::KnownClients
     # A HotTub::Session is a synchronized hash used to separate pools/clients by their domain.
     # Excon and EmHttpRequest clients are initialized to a specific domain, so we sometimes need a way to
-    # manage multiple pools like when a process need to connect to various AWS resources.
+    # manage multiple pools like when a process need to connect to various AWS resources. You can use any client
+    # you choose, but make sure you client is threadsafe.
     # Example:
     #
-    #   sessions = HotTub::Session.new(:client_options => {:connect_timeout => 10}) { |url| Excon.new(url) }
+    #   sessions = HotTub::Session.new { |url| Excon.new(url) }
     #
     #   sessions.run("http://wwww.yahoo.com") do |conn|
-    #     p conn.head.response_header.status
+    #     p conn.head.status
     #   end
     #
     #   sessions.run("https://wwww.google.com") do |conn|
-    #     p conn.head.response_header.status
+    #     p conn.head.status
     #   end
     #
-    # Other client classes
-    # If you have your own client class you can use sessions but your client class must initialize similar to
-    # EmHttpRequest, accepting a URI and options see: hot_tub/clients/em_http_request_client.rb
-    # Example Custom Client:
+    # Example with Pool:
     #
-    #   sessions = HotTub::Session.new({:never_block => false})  { |url| Excon.new(url) }
+    #   sessions = HotTub::Pool.new(:size => 12) { EM::HttpRequest.new("http://somewebservice.com") }
     #
-    #   sessions.run("https://wwww.yahoo.com") do |conn|
-    #     p conn.head.response_header.status # => create pool for "https://wwww.yahoo.com"
+    #   sessions.run("http://wwww.yahoo.com") do |conn|
+    #     p conn.head.response_header.status
     #   end
     #
     #   sessions.run("https://wwww.google.com") do |conn|
-    #     p conn.head.response_header.status # => create separate pool for "https://wwww.google.com"
+    #     p conn.head.response_header.status
     #   end
+    #
     def initialize(options={},&client_block)
       raise ArgumentError, "HotTub::Sessions requre a block on initialization that accepts a single argument" unless block_given?
-      @options = {:with_pool => true}.merge(options)
+      at_exit { close_all } # close connections at exit
+      @options = options || {}
       @client_block = client_block
       @sessions = Hash.new
-      @mutex = (HotTub.em? ? EM::Synchrony::Thread::Mutex.new : Mutex.new)
+      @mutex = (HotTub.em_synchrony? ? EM::Synchrony::Thread::Mutex.new : Mutex.new)
     end
 
     # Synchronizes initialization of our sessions
@@ -45,20 +45,35 @@ module HotTub
       key = to_key(url)
       return @sessions[key] if @sessions[key]
       @mutex.synchronize do
-        if @options[:with_pool]
-          @sessions[key] ||= HotTub::Pool.new(@options) { @client_block.call(url) } 
-        else
-          @sessions[key] ||= @client_block.call(url)
-        end
+        @sessions[key] = @client_block.call(url) if @sessions[key].nil?
+        @sessions[key]
       end
     end
 
     def run(url,&block)
       session = sessions(url)
-      return session.run(&block) if @options[:with_pool]
+      return session.run(&block) if session.is_a?(HotTub::Pool)
       block.call(sessions(url))
     end
 
+    # Calls close on all pools/clients in sessions
+    def close_all
+      @sessions.each do |key,clnt|
+        if clnt.is_a?(HotTub::Pool)
+          clnt.close_all
+        else
+          begin
+            close_client(clnt)
+          rescue => e
+            HotTub.logger.error "There was an error close one of your HotTub::Session clients: #{e}"
+          end
+        end
+        @mutex.synchronize do
+          @sessions[key] = nil
+        end
+      end
+    end
+
     private
 
     def to_key(url)

data/lib/hot_tub/version.rb

@@ -1,3 +1,3 @@
 module HotTub
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/lib/hot_tub.rb

@@ -1,7 +1,7 @@
 require 'thread'
-require 'timeout'
 require 'logger'
 require "hot_tub/version"
+require "hot_tub/known_clients"
 require "hot_tub/pool"
 require "hot_tub/session"
 
@@ -19,6 +19,10 @@ module HotTub
     (defined?(EM) && EM::reactor_running?)
   end
 
+  def self.em_synchrony?
+    (self.em? && defined?(EM::Synchrony))
+  end
+
   def self.jruby?
     (defined?(JRUBY_VERSION))
   end

data/spec/helpers/moc_client.rb

@@ -0,0 +1,33 @@
+class MocClient
+  def initialize(url=nil,options={})
+    @close = false
+    @clean = false
+  end
+
+  # Perform an IO
+  def get
+    return `sleep #{self.class.sleep_time}; echo "that was slow IO"`
+  end
+
+  def close
+    @close = true
+  end
+
+  def closed?
+    @close == true
+  end
+
+  def clean
+    @clean = true
+  end
+
+  def cleaned?
+    @clean == true
+  end
+
+  class << self
+    def sleep_time
+      0.2
+    end
+  end
+end

data/spec/helpers/server.rb

@@ -0,0 +1,38 @@
+require 'sinatra'
+require 'puma'
+module HotTub
+  class Server < Sinatra::Base
+
+    def self.run
+      @events = Puma::Events.new STDOUT, STDERR
+      @server = Puma::Server.new HotTub::Server.new, @events
+      @server.min_threads = 10
+      @server.max_threads = 100
+      @server.add_tcp_listener '127.0.0.1', 9595
+      @server.run
+    end
+
+    set :server, 'puma'
+    set :port, 9595
+
+    get '/data/:amount' do |amount|
+      (('x' * amount.to_i ) << Random.new.rand(0..999999).to_s)
+    end
+
+    def self.teardown
+      @server.stop(true) if @server
+    end
+
+    def self.size
+      10_000
+    end
+
+    def self.path
+      '/data/' << size.to_s
+    end
+
+    def self.url
+      'http://127.0.0.1:9595' << path
+    end
+  end
+end

data/spec/pool_spec.rb

@@ -87,10 +87,8 @@ describe HotTub::Pool do
     end
     it "should reset pool" do
       @pool.current_size.should eql(5)
-      @pool.instance_variable_get(:@clients).length.should eql(5)
       @pool.instance_variable_get(:@pool).length.should eql(5)
       @pool.close_all
-      @pool.instance_variable_get(:@clients).length.should eql(0)
       @pool.instance_variable_get(:@pool).length.should eql(0)
       @pool.current_size.should eql(0)
     end
@@ -136,9 +134,57 @@ describe HotTub::Pool do
     end
   end
 
+  context ':never_block' do
+    context 'is true' do
+      it "should add connections to pool as necessary" do
+        pool = HotTub::Pool.new({:size => 1}) { MocClient.new }
+        threads = []
+        5.times.each do
+          threads << Thread.new do
+            pool.run{|connection| connection.get }
+          end
+        end
+        sleep(0.01)
+        threads.each do |t|
+          t.join
+        end
+        (pool.current_size > 1).should be_true
+      end
+    end
+    context 'is false' do
+      it "should not add connections to pool beyond specified size" do
+        pool = HotTub::Pool.new({:size => 1, :never_block => false, :blocking_timeout => 10}) { MocClient.new }
+        threads = []
+        3.times.each do
+          threads << Thread.new do
+            pool.run{|connection| connection.get }
+          end
+        end
+        sleep(0.01)
+        threads.each do |t|
+          t.join
+        end
+        pool.current_size.should eql(1)
+      end
+    end
+  end
+
+  describe '#reap_pool' do
+    context 'current_size is greater than :size' do
+      it "should remove a connection from the pool" do
+        pool = HotTub::Pool.new({:size => 1}) { MocClient.new }
+        pool.instance_variable_set(:@last_activity,(Time.now - 601))
+        pool.instance_variable_set(:@pool, [MocClient.new,MocClient.new])
+        pool.instance_variable_set(:@current_size,2)
+        pool.send(:reap_pool)
+        pool.current_size.should eql(1)
+        pool.instance_variable_get(:@pool).length.should eql(1)
+      end
+    end
+  end
+
   context 'thread safety' do
     it "should work" do
-      url = "https://www.google.com/"
       pool = HotTub::Pool.new({:size => 10}) { MocClient.new }
       failed = false
       lambda {
@@ -153,7 +199,7 @@ describe HotTub::Pool do
           t.join
         end
       }.should_not raise_error
-      pool.instance_variable_get(:@pool).length.should eql(10) # make sure work got done
+      (pool.instance_variable_get(:@pool).length >= 10).should be_true # make sure work got done
     end
   end
 
@@ -169,9 +215,9 @@ describe HotTub::Pool do
     end
   end
 
-  context 'Excon' do
+  context 'Excon' do # Excon has its own pool, but just need to test with a real non-EM library
     before(:each) do
-      @pool = HotTub::Pool.new(:size => 10) { Excon.new('https://www.google.com')}
+      @pool = HotTub::Pool.new(:size => 10) { Excon.new(HotTub::Server.url)}
     end
     it "should work" do
       result = nil
@@ -180,11 +226,23 @@ describe HotTub::Pool do
     end
     context 'threads' do
       it "should work" do
-        url = "https://www.google.com/"
         failed = false
         threads = []
         lambda {
-          20.times.each do
+          15.times.each do
+            threads << Thread.new do
+              @pool.run{|connection| Thread.current[:status] = connection.head.status }
+            end
+          end
+          sleep(0.01)
+          threads.each do |t|
+            t.join
+          end
+        }.should_not raise_error
+        # Reuse and run reaper
+        @pool.instance_variable_set(:@last_activity,(Time.now - 601))
+        lambda {
+          10.times.each do
             threads << Thread.new do
               @pool.run{|connection| Thread.current[:status] = connection.head.status }
             end
@@ -194,9 +252,9 @@ describe HotTub::Pool do
             t.join
           end
         }.should_not raise_error
-        @pool.instance_variable_get(:@pool).length.should eql(10) # make sure work got done
+        (@pool.instance_variable_get(:@pool).length == 10).should be_true # make sure work got done
         results = threads.collect{ |t| t[:status]}
-        results.length.should eql(20) # make sure all threads are present
+        results.length.should eql(25) # make sure all threads are present
         results.uniq.should eql([200]) # make sure all returned status 200
       end
     end
@@ -205,7 +263,7 @@ describe HotTub::Pool do
   unless HotTub.jruby?
     context 'EM:HTTPRequest' do
       before(:each) do
-        @url = "https://www.google.com"
+        @url = HotTub::Server.url
       end
 
       it "should work" do
@@ -216,6 +274,7 @@ describe HotTub::Pool do
           c.run { |conn| status << conn.ahead(:keepalive => true).response_header.status}
           c.run { |conn| status << conn.head(:keepalive => true).response_header.status}
           status.should eql([200,0,200])
+          c.close_all
           EM.stop
         end
       end
@@ -223,14 +282,15 @@ describe HotTub::Pool do
       context 'fibers' do
         it "should work" do
           EM.synchrony do
-            url = "https://www.google.com/"
             pool = HotTub::Pool.new({:size => 5}) {EM::HttpRequest.new(@url)}
             failed = false
             fibers = []
             lambda {
               10.times.each do
                 fibers << Fiber.new do
-                  pool.run{|connection| failed = true unless connection.head(:keepalive => true).response_header.status == 200}
+                  pool.run{|connection| 
+                    s = connection.head(:keepalive => true).response_header.status
+                    failed = true unless s == 200}
                 end
               end
               fibers.each do |f|
@@ -248,8 +308,9 @@ describe HotTub::Pool do
                 end
               end
             }.should_not raise_error
-            pool.instance_variable_get(:@pool).length.should eql(5) #make sure work got done
+            (pool.instance_variable_get(:@pool).length >= 5).should be_true #make sure work got done
             failed.should be_false # Make sure our requests worked
+            pool.close_all
             EM.stop
           end
         end

data/spec/session_spec.rb

@@ -2,6 +2,10 @@ require 'spec_helper'
 require 'hot_tub/session'
 require 'uri'
 require 'time'
+unless HotTub.jruby?
+  require "em-synchrony"
+  require "em-synchrony/em-http"
+end
 describe HotTub::Session do
 
   context 'initialized without a block' do
@@ -16,14 +20,6 @@ describe HotTub::Session do
       @sessions = HotTub::Session.new { |url| MocClient.new(url) }
     end
 
-    context 'default options' do
-      describe ':with_pool' do
-        it "with_pool should be true" do
-          @sessions.instance_variable_get(:@options)[:with_pool].should be_true
-        end
-      end
-    end
-
     describe '#to_url' do
       context "passed URL string" do
         it "should return key with URI scheme-domain" do
@@ -48,32 +44,23 @@ describe HotTub::Session do
     end
 
     describe '#sessions' do
-
-      context ':with_pool is true (default)' do
-        it "should add a new pool for the url" do
-          @sessions.sessions(@url)
-          sessions = @sessions.instance_variable_get(:@sessions)
-          sessions.length.should eql(1)
-          sessions.first[1].should be_a(HotTub::Pool)
-        end
-
-        it "should pass options to pool" do
-          with_pool_options = HotTub::Session.new(:size => 13, :never_block => false) { |url| MocClient.new(url) }
+      context 'HotTub::Pool as client' do
+        it "should add a new client for the url" do
+          with_pool_options = HotTub::Session.new { |url| HotTub::Pool.new(:size => 13) { MocClient.new(url) } }
           with_pool_options.sessions(@url)
           sessions = with_pool_options.instance_variable_get(:@sessions)
-          pool_options = sessions.first[1].instance_variable_get(:@options)
-          pool_options[:size].should eql(13)
-          pool_options[:never_block].should be_false
+          sessions.length.should eql(1)
+          sessions.first[1].should be_a(HotTub::Pool)
         end
       end
 
-      context ':with_pool is false' do
+      context 'other clients' do
         it "should add a new client for the url" do
-          no_pool = HotTub::Session.new(:with_pool => false) { |url| MocClient.new(url) }
+          no_pool = HotTub::Session.new { |url| Excon.new(url) }
           no_pool.sessions(@url)
           sessions = no_pool.instance_variable_get(:@sessions)
           sessions.length.should eql(1)
-          sessions.first[1].should be_a(MocClient)
+          sessions.first[1].should be_a(Excon::Connection)
         end
       end
 
@@ -81,14 +68,14 @@ describe HotTub::Session do
         it "should set key with URI scheme-domain" do
           @sessions.sessions(@url)
           sessions = @sessions.instance_variable_get(:@sessions)
-          sessions["#{@uri.scheme}-#{@uri.host}"].should be_a(HotTub::Pool)
+          sessions["#{@uri.scheme}-#{@uri.host}"].should be_a(MocClient)
         end
       end
       context "passed URI" do
         it "should set key with URI scheme-domain" do
           @sessions.sessions(@uri)
           sessions = @sessions.instance_variable_get(:@sessions)
-          sessions["#{@uri.scheme}-#{@uri.host}"].should be_a(HotTub::Pool)
+          sessions["#{@uri.scheme}-#{@uri.host}"].should be_a(MocClient)
         end
       end
     end
@@ -105,11 +92,11 @@ describe HotTub::Session do
       end
     end
 
-    context 'thread safety' do
+    context 'threads' do
       it "should work" do
-        url = "https://www.somewebsite.com/"
-        url2 = "http://www.someotherwebsit.com/"
-        session = HotTub::Session.new { |url| MocClient.new(url)}
+        url = HotTub::Server.url
+        url2 = "http://www.yahoo.com/"
+        session = HotTub::Session.new { |url| Excon.new(url)}
         failed = false
         start_time = Time.now
         stop_time = nil
@@ -136,5 +123,45 @@ describe HotTub::Session do
         session.instance_variable_get(:@sessions).keys.length.should eql(2) # make sure sessions were created
       end
     end
+
+    unless HotTub.jruby?
+      context 'fibers' do
+        it "should work" do
+          EM.synchrony do
+            sessions = HotTub::Session.new {|url| HotTub::Pool.new({:size => 5}) {EM::HttpRequest.new(url)}}
+            failed = false
+            fibers = []
+            lambda {
+              10.times.each do
+                fibers << Fiber.new do
+                  sessions.run(@url) {|connection|
+                    s = connection.head(:keepalive => true).response_header.status
+                  failed = true unless s == 200}
+                end
+              end
+              fibers.each do |f|
+                f.resume
+              end
+              loop do
+                done = true
+                fibers.each do |f|
+                  done = false if f.alive?
+                end
+                if done
+                  break
+                else
+                  EM::Synchrony.sleep(0.01)
+                end
+              end
+            }.should_not raise_error
+            sessions.instance_variable_get(:@sessions).keys.length.should eql(1)
+            (sessions.sessions(@url).instance_variable_get(:@pool).length >= 5).should be_true #make sure work got done
+            failed.should be_false # Make sure our requests worked
+            sessions.close_all
+            EM.stop
+          end
+        end
+      end
+    end
   end
 end

data/spec/spec_helper.rb

@@ -3,45 +3,20 @@ require 'rspec'
 require 'bundler/setup'
 require 'logger'
 require 'excon'
+require 'helpers/moc_client'
+require 'helpers/server'
+require 'net/https'
+
 # Requires supporting files with custom matchers and macros, etc,
 # in ./support/ and its subdirectories.
 #Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 HotTub.logger.level = Logger::ERROR
 
 RSpec.configure do |config|
-
-end
-
-class MocClient
-  def initialize(url=nil,options={})
-    @close = false
-    @clean = false
-  end
-
-  # Perform an IO
-  def get
-    return `sleep #{self.class.sleep_time}; echo "that was slow IO"`
-  end
-
-  def close
-    @close = true
-  end
-
-  def closed?
-    @close == true
-  end
-
-  def clean
-    @clean = true
-  end
-
-  def cleaned?
-    @clean == true
-  end
-
-  class << self
-    def sleep_time
-      0.5
-    end
-  end
-end
+ config.before(:suite) do
+  HotTub::Server.run
+ end
+ config.after(:suite) do
+  HotTub::Server.teardown
+ end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hot_tub
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-03 00:00:00.000000000 Z
+date: 2013-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -27,6 +27,54 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A simple thread-safe http connection pooling gem. Http client options
   include HTTPClient and EM-Http-Request
 email:
@@ -44,9 +92,12 @@ files:
 - Rakefile
 - hot_tub.gemspec
 - lib/hot_tub.rb
+- lib/hot_tub/known_clients.rb
 - lib/hot_tub/pool.rb
 - lib/hot_tub/session.rb
 - lib/hot_tub/version.rb
+- spec/helpers/moc_client.rb
+- spec/helpers/server.rb
 - spec/pool_spec.rb
 - spec/session_spec.rb
 - spec/spec_helper.rb
@@ -65,7 +116,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1359205392366777656
+      hash: -1949508601036359576
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -74,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1359205392366777656
+      hash: -1949508601036359576
 requirements: []
 rubyforge_project: hot_tub
 rubygems_version: 1.8.25
@@ -82,6 +133,8 @@ signing_key:
 specification_version: 3
 summary: A simple thread-safe http connection pooling gem.
 test_files:
+- spec/helpers/moc_client.rb
+- spec/helpers/server.rb
 - spec/pool_spec.rb
 - spec/session_spec.rb
 - spec/spec_helper.rb