hot_tub 0.2.6 → 0.3.0

data/lib/hot_tub/reaper.rb

@@ -0,0 +1,37 @@
+module HotTub
+  class Reaper < Thread
+
+    # Creates a new Reaper thread for work.
+    # Expects an object that responses to: :reap!
+    # :shutdown and :reap_timeout
+    # Threads swallow exceptions until they are joined,
+    # so we rescue, log, and kill the reaper when an exception occurs
+    # https://bugs.ruby-lang.org/issues/6647
+    def self.spawn(obj)
+      th = new {
+        loop do
+          begin
+            obj.reap!
+            break if obj.shutdown
+            sleep(obj.reap_timeout || 600)
+          rescue Exception => e
+            HotTub.logger.error "HotTub::Reaper for #{obj.class.name} terminated with exception: #{e.message}"
+            HotTub.logger.error e.backtrace.map {|line| " #{line}"}
+            break
+          end
+        end
+      }
+      th[:name] = "HotTub::Reaper"
+      th
+    end
+
+    # Mixin to dry up Reaper usage
+    module Mixin
+      attr_reader :reap_timeout, :reaper, :shutdown
+
+      def reap!
+        raise NoMethodError.new(':reap! must be redefined in your class')
+      end
+    end
+  end
+end

data/lib/hot_tub/sessions.rb

@@ -0,0 +1,157 @@
+require 'uri'
+module HotTub
+  class Sessions
+    include HotTub::KnownClients
+    include HotTub::Reaper::Mixin
+
+    # HotTub::Session is a ThreadSafe::Cache where URLs are mapped to clients or pools.
+    # 
+    #
+    # == Example with Pool:
+    # You can initialize a HotTub::Pool with each client by passing :with_pool as true and any pool options
+    #   sessions = HotTub::Sessions.new(:with_pool => true, :size => 12) {
+    #       uri = URI.parse("http://somewebservice.com")
+    #       http = Net::HTTP.new(uri.host, uri.port)
+    #       http.use_ssl = false
+    #       http.start
+    #       http
+    #     }
+    #
+    #   sessions.run("http://wwww.yahoo.com") do |conn|
+    #     p conn.head('/').code
+    #   end
+    #
+    #   sessions.run("https://wwww.google.com") do |conn|
+    #     p conn.head('/').code
+    #   end
+    #
+    # == Excon clients are initialized to a specific domain. Its sometimes useful
+    # to have the options of initializing Excon connections after startup, in 
+    # a thread safe manner for multiple urls with a single object.
+    # Example:
+    #
+    #   sessions = HotTub::Sessions.new { |url| Excon.new(url) }
+    #
+    #   sessions.run("http://wwww.yahoo.com") do |conn|
+    #     p conn.head.status
+    #   end
+    #
+    #   sessions.run("https://wwww.google.com") do |conn|
+    #     p conn.head.status
+    #   end
+    #
+    #
+    # === OPTIONS
+    # [:with_pool]
+    #   Default is false. A boolean that if true, wraps the new_client block in HotTub::Pool.new. All options
+    #   are passed to the new HotTub::Pool object. See HotTub::Pool for options
+    # [:close]
+    #   Default is nil. Can be a symbol representing an method to call on a client to close the client or a lambda
+    #   that accepts the client as a parameter that will close a client. The close option is performed on clients
+    #   on reaping and shutdown after the client has been removed from the pool.  When nil, as is the default, no
+    #   action is performed.
+    # [:clean]
+    #   Default is nil. Can be a symbol representing an method to call on a client to clean the client or a lambda
+    #   that accepts the client as a parameter that will clean a client. When nil, as is the default, no action is
+    #   performed.
+    # [:reap]
+    #   Default is nil. Can be a symbol representing an method to call on a client that returns a boolean marking
+    #   a client for reaping, or a lambda that accepts the client as a parameter that returns a boolean boolean
+    #   marking a  client for reaping. When nil, as is the default, no action is performed.
+    # [:no_reaper]
+    #   Default is nil. A boolean like value that if true prevents the reaper from initializing
+    #
+    def initialize(opts={},&new_client)
+      raise ArgumentError, "HotTub::Sessions require a block on initialization that accepts a single argument" unless block_given?
+      @with_pool        = opts[:with_pool]        # Set to true to use HotTub::Pool with supplied new_client block
+      @close_client     = opts[:close]            # => lambda {|clnt| clnt.close}
+      @clean_client     = opts[:clean]            # => lambda {|clnt| clnt.clean}
+      @reap_client      = opts[:reap]             # => lambda {|clnt| clnt.reap?}  # should return boolean
+      @new_client       = new_client              # => { |url| MyClient.new(url) } # block that accepts a url param
+      @sessions         = ThreadSafe::Cache.new
+      @shutdown         = false
+      @reap_timeout     = (opts[:reap_timeout] || 600)      # the interval to reap connections in seconds
+      @reaper           = Reaper.spawn(self) unless opts[:no_reaper]
+      @pool_options     = {:no_reaper => true}.merge(opts) if @with_pool
+      at_exit {drain!}
+    end
+
+    # Safely initializes of sessions
+    # expects a url string or URI
+    def session(url)
+      key = to_key(url)
+      return @sessions.get(key) if @sessions.get(key)
+      if @with_pool
+        @sessions.compute_if_absent(key) {
+          HotTub::Pool.new(@pool_options) { @new_client.call(url) }
+        }
+      else
+        @sessions.compute_if_absent(key) {@new_client.call(url)}
+      end
+      @sessions.get(key)
+    end
+    alias :sessions :session
+
+    def run(url,&block)
+      session = sessions(url)
+      return session.run(&block) if session.is_a?(HotTub::Pool)
+      block.call(sessions(url))
+    end
+
+    def clean!
+      @sessions.each_pair do |key,clnt|
+        if clnt.is_a?(HotTub::Pool)
+          clnt.clean!
+        else
+          clean_client(clnt)
+        end
+      end
+    end
+
+    def drain!
+      @sessions.each_pair do |key,clnt|
+        if clnt.is_a?(HotTub::Pool)
+          clnt.drain!
+        else
+          close_client(clnt)
+        end
+      end
+      @sessions.clear
+    end
+
+    def shutdown!
+      @sessions.each_pair do |key,clnt|
+        if clnt.is_a?(HotTub::Pool)
+          clnt.shutdown!
+        else
+          close_client(clnt)
+        end
+      end
+      @sessions.clear
+    end
+
+    # Remove and close extra clients
+    def reap!
+      @sessions.each_pair do |key,clnt|
+        if clnt.is_a?(HotTub::Pool)
+          clnt.reap!
+        else
+          close_client(clnt) if reap_client?(clnt)
+        end
+      end
+    end
+
+    private
+
+    def to_key(url)
+      if url.is_a?(String)
+        uri = URI(url)
+      elsif url.is_a?(URI)
+        uri = url
+      else
+        raise ArgumentError, "you must pass a string or a URI object"
+      end
+      "#{uri.scheme}://#{uri.host}:#{uri.port}"
+    end
+  end
+end

data/lib/hot_tub/version.rb

@@ -1,3 +1,3 @@
 module HotTub
-  VERSION = "0.2.6"
+  VERSION = "0.3.0"
 end

data/spec/helpers/moc_client.rb

@@ -1,13 +1,15 @@
 class MocClient
   def initialize(url=nil,options={})
+    @reaped = false
     @close = false
     @clean = false
   end
 
   # Perform an IO
   def get
-    sleep(self.class.sleep_time)
-    "that was slow IO"
+    prng = Random.new()
+    t_s = "0.0#{prng.rand(1..9)}".to_f
+    sleep(t_s)
   end
 
   def close
@@ -26,9 +28,11 @@ class MocClient
     @clean == true
   end
 
-  class << self
-    def sleep_time
-      0.2
-    end
+  def reap
+    @reaped = true
+  end
+
+  def reaped?
+    @reaped
   end
 end

data/spec/helpers/moc_pool.rb

@@ -0,0 +1,23 @@
+class MocMixinPool
+  include HotTub::Reaper::Mixin
+end
+
+class MocPool < MocMixinPool
+  attr_accessor :reaped, :lets_reap
+
+  def initialize
+  	@reaped = false
+  	@lets_reap = false
+  end
+
+  def reap!
+	@reaped = true if @lets_reap
+  end
+end
+
+class MocReaperPool < MocPool
+  def initialize
+  	super
+    @reaper = HotTub::Reaper.spawn(self)
+  end
+end

data/spec/hot_tub_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+describe HotTub do
+
+  context "helpers" do
+    describe '#new' do
+
+      it "should return a HotTub::Pool" do
+        (HotTub.new { |url| MocClient.new(url) }).should be_a(HotTub::Pool)
+      end
+
+      context ':sessions => true' do
+        it "should be a HotTub::Sessions with HotTub::Pool as client" do
+          session_with_pool = HotTub.new(:sessions => true)  { |url| MocClient.new(url) }
+          pool = session_with_pool.sessions("http://test.com")
+          pool.should be_a(HotTub::Pool)
+        end
+      end
+    end
+  end
+end

data/spec/pool_spec.rb

@@ -1,8 +1,4 @@
 require 'spec_helper'
-unless HotTub.jruby?
-  require "em-synchrony"
-  require "em-synchrony/em-http"
-end
 describe HotTub::Pool do
 
   context 'default settings' do
@@ -11,37 +7,41 @@ describe HotTub::Pool do
     end
 
     it "should have :size of 5" do
-      @pool.instance_variable_get(:@options)[:size].should eql(5)
+      @pool.instance_variable_get(:@size).should eql(5)
     end
 
-    it "should have :blocking_timeout of 0.5" do
-      @pool.instance_variable_get(:@options)[:blocking_timeout].should eql(10)
+    it "should have :wait_timeout of 0.5" do
+      @pool.instance_variable_get(:@wait_timeout).should eql(10)
     end
 
     it "should have set the client" do
-      @pool.instance_variable_get(:@client_block).call.should be_a(MocClient)
+      @pool.instance_variable_get(:@new_client).call.should be_a(MocClient)
     end
 
     it "should be true" do
-      @pool.instance_variable_get(:@options)[:never_block].should be_true
+      @pool.instance_variable_get(:@max_size).should eql(0)
+    end
+
+    it "should have a HotTub::Reaper" do
+      @pool.reaper.should be_a(HotTub::Reaper)
     end
   end
 
   context 'custom settings' do
     before(:each) do
-      @pool = HotTub::Pool.new(:size => 10, :blocking_timeout => 1.0, :never_block => false) { MocClient.new }
+      @pool = HotTub::Pool.new(:size => 10, :wait_timeout => 1.0, :max_size => 20) { MocClient.new }
     end
 
     it "should have :size of 5" do
-      @pool.instance_variable_get(:@options)[:size].should eql(10)
+      @pool.instance_variable_get(:@size).should eql(10)
     end
 
-    it "should have :blocking_timeout of 0.5" do
-      @pool.instance_variable_get(:@options)[:blocking_timeout].should eql(1.0)
+    it "should have :wait_timeout of 0.5" do
+      @pool.instance_variable_get(:@wait_timeout).should eql(1.0)
     end
 
     it "should be true" do
-      @pool.instance_variable_get(:@options)[:never_block].should be_false
+      @pool.instance_variable_get(:@max_size).should eql(20)
     end
   end
 
@@ -58,11 +58,12 @@ describe HotTub::Pool do
     end
 
     it "should return the connection after use" do
+      @connection = nil
       @pool.run do |connection|
         @connection = connection
       end
       # returned to pool after work was done
-      @pool.instance_variable_get(:@pool).select{|c| c.object_id == @connection.object_id}.length.should eql(1)
+      @pool.instance_variable_get(:@pool).pop.should eql(@connection)
     end
 
     it "should work" do
@@ -78,28 +79,60 @@ describe HotTub::Pool do
     end
   end
 
-  describe '#close_all' do
+  describe '#drain!' do
     before(:each) do
       @pool = HotTub::Pool.new(:size => 5) { MocClient.new }
-      5.times do
-        @pool.send(:_add)
+      @pool.instance_variable_set(:@out, [MocClient.new,MocClient.new,MocClient.new])
+      @pool.instance_variable_set(:@pool, [MocClient.new,MocClient.new,MocClient.new])
+    end
+
+    context ":close_out" do
+      it "should reset out" do
+        @pool.instance_variable_set(:@close_out, true)
+        @pool.drain!
+        @pool.instance_variable_get(:@out).length.should eql(0)
+      end
+    end
+
+    it "should reset pool" do
+      @pool.drain!
+      @pool.instance_variable_get(:@pool).length.should eql(0)
+      @pool.send(:_total_current_size).should eql(3)
+      @pool.instance_variable_get(:@out).length.should eql(3)
+    end
+  end
+
+  describe '#clean!' do
+    before(:each) do
+      @pool = HotTub::Pool.new(:size => 3, :clean => lambda { |clnt| clnt.clean}) { MocClient.new }
+    end
+
+    it "should clean pool" do
+      @pool.instance_variable_set(:@pool, [MocClient.new,MocClient.new,MocClient.new])
+      @pool.instance_variable_get(:@pool).first.cleaned?.should be_false
+      @pool.clean!
+      @pool.instance_variable_get(:@pool).each do |clnt|
+        clnt.cleaned?.should be_true
       end
     end
+  end
 
-    it "should reset register" do
-      @pool.current_size.should eql(5)
-      @pool.instance_variable_get(:@register).length.should eql(5)
-      @pool.close_all
-      @pool.instance_variable_get(:@register).length.should eql(0)
-      @pool.current_size.should eql(0)
+  describe '#shutdown!' do
+    before(:each) do
+      @pool = HotTub::Pool.new(:size => 5) { MocClient.new }
+    end
+
+    it "should kill reaper" do
+      @pool.shutdown!
+      sleep(0.01)
+      @pool.instance_variable_get(:@reaper).status.should be_false
     end
 
     it "should reset pool" do
-      @pool.current_size.should eql(5)
-      @pool.instance_variable_get(:@pool).length.should eql(5)
-      @pool.close_all
+      @pool.instance_variable_set(:@pool, [MocClient.new,MocClient.new,MocClient.new])
+      @pool.shutdown!
       @pool.instance_variable_get(:@pool).length.should eql(0)
-      @pool.current_size.should eql(0)
+      @pool.send(:_total_current_size).should eql(0)
     end
   end
 
@@ -111,9 +144,10 @@ describe HotTub::Pool do
 
     describe '#client' do
       it "should raise HotTub::BlockingTimeout if an available is not found in time"do
-        @pool.instance_variable_set(:@options, {:never_block => false, :blocking_timeout => 0.1})
-        @pool.stub(:pop).and_return(nil)
-        lambda { puts @pool.send(:client) }.should raise_error(HotTub::BlockingTimeout)
+        @pool.instance_variable_set(:@non_blocking,false)
+        @pool.instance_variable_set(:@wait_timeout, 0.1)
+        @pool.stub(:raise_alarm?).and_return(true)
+        lambda { puts @pool.send(:pop) }.should raise_error(HotTub::Pool::Timeout)
       end
 
       it "should return an instance of the client" do
@@ -125,18 +159,18 @@ describe HotTub::Pool do
       it "should be true if @pool_data[:length] is less than desired pool size and
     the pool is empty?"do
         @pool.instance_variable_set(:@pool,[])
-        @pool.send(:add?).should be_true
+        @pool.send(:_add?).should be_true
       end
 
       it "should be false pool has reached pool_size" do
-        @pool.instance_variable_set(:@options,{:size => 5})
-        @pool.instance_variable_set(:@pool,["connection","connection","connection","connection","connection"])
-        @pool.send(:add?).should be_false
+        @pool.instance_variable_set(:@size, 5)
+        @pool.instance_variable_set(:@pool,[1,1,1,1,1])
+        @pool.send(:_add?).should be_false
       end
     end
 
     describe '#_add' do
-      it "should add connections for supplied url"do
+      it "should add client for supplied url"do
         pre_add_length = @pool.instance_variable_get(:@pool).length
         @pool.send(:_add)
         @pool.instance_variable_get(:@pool).length.should be > pre_add_length
@@ -144,70 +178,66 @@ describe HotTub::Pool do
     end
 
     describe '#push' do
-      context "connection is registered" do
-        it "should push connection back to pool" do
+      context "client is registered" do
+        it "should push client back to pool" do
           @pool.send(:_add)
           clnt = @pool.instance_variable_get(:@pool).pop
           @pool.send(:push,clnt)
           @pool.instance_variable_get(:@pool).include?(clnt).should be_true
         end
       end
-      context "connection is not registered" do
-        it "should not push connection back to pool" do
-          @pool.send(:_add)
-          clnt = @pool.instance_variable_get(:@pool).pop
-          @pool.instance_variable_get(:@register).delete(clnt)
-          @pool.send(:push,clnt)
-          @pool.instance_variable_get(:@pool).include?(clnt).should be_false
+      context "client is nil" do
+        it "should not push client back to pool" do
+          @pool.send(:push,nil)
+          @pool.instance_variable_get(:@pool).include?(nil).should be_false
         end
       end
     end
   end
 
-  context ':never_block' do
-    context 'is true' do
-      it "should add connections to pool as necessary" do
+  context ':max_size' do
+    context 'is default' do
+      it "should add clients 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 }
+            pool.run{|cltn| cltn.get }
           end
         end
-        sleep(1)
         threads.each do |t|
           t.join
         end
-        (pool.current_size > 1).should be_true
+        (pool.send(:_total_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 => 100}) { MocClient.new }
+    context 'is set' do
+      it "should not add clients to pool beyond specified size" do
+        pool = HotTub::Pool.new({:size => 1, :max_size => 1, :wait_timeout => 100}) { MocClient.new }
         threads = []
-        2.times.each do
+        5.times.each do
           threads << Thread.new do
-            pool.run{|connection| connection.get }
+            pool.run{|cltn| cltn.get }
           end
         end
-        sleep(0.2)
         threads.each do |t|
           t.join
         end
-        pool.current_size.should eql(1)
+        pool.send(:_total_current_size).should eql(1)
       end
     end
   end
 
-  describe '#reap_pool' do
+  describe '#reap' do
     context 'current_size is greater than :size' do
-      it "should remove a connection from the pool" do
+      it "should remove a client 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_set(:@pool, [MocClient.new,MocClient.new,MocClient.new])
+        pool.send(:_reap?).should be_true
+        pool.reaper.wakeup # run the reaper thread
+        sleep(0.1) # let results
+        pool.send(:_total_current_size).should eql(1)
         pool.instance_variable_get(:@pool).length.should eql(1)
       end
     end
@@ -224,7 +254,6 @@ describe HotTub::Pool do
             pool.run{|connection| connection.get }
           end
         end
-        sleep(0.01)
         threads.each do |t|
           t.join
         end
@@ -245,131 +274,113 @@ describe HotTub::Pool do
     end
   end
 
-  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(HotTub::Server.url)}
-    end
-    it "should work" do
-      result = nil
-      @pool.run{|clnt| result = clnt.head.status}
-      result.should eql(200)
-    end
-    context 'threads' do
+  context 'integration tests' do
+    context "blocking" do
+      before(:each) do
+        @pool = HotTub::Pool.new(:size => 5, :max_size => 5) {
+          uri = URI.parse(HotTub::Server.url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = false
+          http.start
+          http
+        }
+      end
       it "should work" do
-        failed = false
-        threads = []
-        lambda {
-          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
-          end
-          sleep(0.01)
-          threads.each do |t|
-            t.join
-          end
-        }.should_not raise_error
-        results = threads.collect{ |t| t[:status]}
-        results.length.should eql(25) # make sure all threads are present
-        results.uniq.should eql([200]) # make sure all returned status 200
+        result = nil
+        @pool.run{|clnt|
+          uri = URI.parse(HotTub::Server.url)
+          result = clnt.head(uri.path).code
+        }
+        result.should eql('200')
       end
-    end
-  end
-
-  unless HotTub.jruby?
-    describe "em_client?" do
-        context 'EM::HttpRequest as client' do
-          before(:each) do
-            @pool = HotTub::Pool.new { EM::HttpRequest.new(HotTub::Server.url) }
-          end
-          context "EM::Synchrony is present" do
-            it "should be true" do
-              HotTub.stub(:em_synchrony?).and_return(true)
-              @pool.send(:em_client?).should be_true
-            end
-          end
-          context "EM::Synchrony is not present" do
-            it "should be false" do
-              HotTub.stub(:em_synchrony?).and_return(false)
-              @pool.send(:em_client?).should be_false
-            end
-          end
-        end
-        context 'client is not EM::HttpRequest' do
-          it "should be false" do
-            pool = HotTub::Pool.new {|url| MocClient.new}
-            pool.send(:em_client?).should be_false
-          end
+      context 'threads' do
+        it "should work" do
+          failed = false
+          threads = []
+          lambda { net_http_thread_work(@pool,10, threads) }.should_not raise_error
+          @pool.reap!
+          lambda { net_http_thread_work(@pool,20, threads) }.should_not raise_error
+          @pool.send(:_total_current_size).should  eql(5) # make sure the pool grew beyond size 
+          results = threads.collect{ |t| t[:status]}
+          results.length.should eql(30) # make sure all threads are present
+          results.uniq.should eql(['200']) # make sure all returned status 200
         end
       end
-
-    context 'EM:HTTPRequest' do
+    end
+    context "never block without max" do
       before(:each) do
-        @url = HotTub::Server.url
+        @pool = HotTub::Pool.new(:size => 5) {
+          uri = URI.parse(HotTub::Server.url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = false
+          http.start
+          http
+        }
       end
-
       it "should work" do
-        EM.synchrony do
-          status = []
-          c = HotTub::Pool.new {EM::HttpRequest.new(@url)}
-          c.run { |conn| status << conn.head(:keepalive => true).response_header.status}
-          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
+        result = nil
+        @pool.run{|clnt|
+          uri = URI.parse(HotTub::Server.url)
+          result = clnt.head(uri.path).code
+        }
+        result.should eql('200')
+      end
+      context 'threads' do
+        it "should work" do
+          failed = false
+          threads = []
+          lambda { net_http_thread_work(@pool,10, threads) }.should_not raise_error
+          @pool.reap! # Force reaping to shrink pool back
+          lambda { net_http_thread_work(@pool,20, threads) }.should_not raise_error
+          @pool.send(:_total_current_size).should  > 5 # make sure the pool grew beyond size 
+          results = threads.collect{ |t| t[:status]}
+          results.length.should eql(30) # make sure all threads are present
+          results.uniq.should eql(['200']) # make sure all returned status 200
         end
       end
-
-      context 'fibers' do
+    end
+    context "never block with max" do
+      before(:each) do
+        @pool = HotTub::Pool.new(:size => 5, :max_size => 10) {
+          uri = URI.parse(HotTub::Server.url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = false
+          http.start
+          http
+        }
+      end
+      it "should work" do
+        result = nil
+        @pool.run{|clnt|
+          uri = URI.parse(HotTub::Server.url)
+          result = clnt.head(uri.path).code
+        }
+        result.should eql('200')
+      end
+      context 'threads' do
         it "should work" do
-          EM.synchrony do
-            pool = HotTub::Pool.new({:size => 5, :fiber_mutex => true}) {EM::HttpRequest.new(@url)}
-            failed = false
-            fibers = []
-            lambda {
-              10.times.each do
-                fibers << Fiber.new do
-                  pool.run{|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
-            (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
+          failed = false
+          threads = []
+          lambda { net_http_thread_work(@pool,10, threads) }.should_not raise_error
+          lambda { net_http_thread_work(@pool,20, threads) }.should_not raise_error
+          @pool.send(:_total_current_size).should  > 5 # make sure pool is at max_size
+          results = threads.collect{ |t| t[:status]}
+          results.length.should eql(30) # make sure all threads are present
+          results.uniq.should eql(['200']) # make sure all returned status 200
         end
       end
     end
   end
+
+  def net_http_thread_work(pool,thread_count=0, threads=[])
+    thread_count.times.each do
+      threads << Thread.new do
+        uri = URI.parse(HotTub::Server.url)
+        pool.run{|connection| Thread.current[:status] = connection.head(uri.path).code }
+      end
+    end
+    threads.each do |t|
+      t.join
+    end
+  end
 end