hot_tub 0.4.0 → 0.5.0

data/lib/hot_tub.rb

@@ -1,6 +1,4 @@
 require 'thread'
-require 'thread_safe'
-require 'logger'
 require "hot_tub/version"
 require "hot_tub/known_clients"
 require "hot_tub/reaper"
@@ -8,7 +6,11 @@ require "hot_tub/pool"
 require "hot_tub/sessions"
 
 module HotTub
-  @@logger = nil
+  GLOBAL_SESSIONS = Sessions.new(:name => "Global Sessions")
+
+  @@logger    = nil
+  @@trace     = false
+  @@log_trace = false
 
   def self.logger
     @@logger
@@ -16,6 +18,25 @@ module HotTub
 
   def self.logger=logger
     @@logger = logger
+    set_log_trace
+  end
+
+  # Set to true for more detail logs
+  def self.trace=trace
+    @@trace = trace
+    set_log_trace
+  end
+
+  def self.set_log_trace
+    @@log_trace = (!@@logger.nil? && @@trace)
+  end
+
+  def self.log_trace?
+    @@log_trace
+  end
+
+  def self.sessions
+    GLOBAL_SESSIONS
   end
 
   def self.jruby?
@@ -26,12 +47,29 @@ module HotTub
     (defined?(RUBY_ENGINE) and RUBY_ENGINE == 'rbx')
   end
 
-  def self.new(opts={},&client_block)
-    if opts[:sessions] == true
-      opts[:with_pool] = true
-      Sessions.new(opts,&client_block)
-    else
-      Pool.new(opts,&client_block)
-    end
+  # Resets global sessions, useful in forked environments
+  # Does not reset one-off pools or one-off sessions
+  def self.reset!
+    GLOBAL_SESSIONS.reset!
+  end
+
+  # Shuts down global sessions, useful in forked environments
+  # Does not shutdown one-off pools or one-off sessions
+  def self.shutdown!
+    GLOBAL_SESSIONS.shutdown!
+  end
+
+  # Adds a new Pool to the global sessions
+  def self.add(url,opts={}, &client_block)
+    GLOBAL_SESSIONS.add(url, opts, &client_block)
+  end
+
+  def self.run(url ,&run_block)
+    pool = GLOBAL_SESSIONS.fetch(url)
+    pool.run &run_block
+  end
+
+  def self.new(opts={}, &client_block)
+    Pool.new(opts,&client_block)
   end
 end

data/spec/hot_tub/integration/excon_spec.rb

@@ -12,17 +12,17 @@ describe HotTub do
     let(:threads) { [] }
 
     before(:each) do
-      5.times do
-        excon_thread_work(pool, 30, threads)
+      20.times do
+        excon_thread_work(pool, 10, threads)
       end
     end
 
-    it { expect(pool.current_size).to eql(4) }# make sure the pool grew beyond size
+    it { expect(pool.current_size).to eql(4) }
 
     it "should work" do
       results = threads.collect{ |t| t[:status]}
-      expect(results.length).to eql(150) # make sure all threads are present
-      expect(results.uniq).to eql([200]) # make sure all returned status 200
+      expect(results.length).to eql(200)
+      expect(results.uniq).to eql([200])
     end
 
     it "should shutdown" do
@@ -41,8 +41,8 @@ describe HotTub do
     let(:threads) { [] }
 
     before(:each) do
-      5.times do
-        excon_thread_work(pool, 30, threads)
+      20.times do
+        excon_thread_work(pool, 10, threads)
       end
     end
 
@@ -52,13 +52,13 @@ describe HotTub do
 
     it "should reap" do
       pool.reap!
-      expect(pool.current_size).to eql(4)
+      expect(pool.current_size).to be <= 4 
     end
 
     it "should work" do
       results = threads.collect{ |t| t[:status]}
-      expect(results.length).to eql(150) # make sure all threads are present
-      expect(results.uniq).to eql([200]) # make sure all returned status 200
+      expect(results.length).to eql(200)
+      expect(results.uniq).to eql([200])
     end
   end
 
@@ -72,12 +72,12 @@ describe HotTub do
     let(:threads) { [] }
 
     before(:each) do
-      5.times do
-        excon_thread_work(pool, 30, threads)
+      20.times do
+        excon_thread_work(pool, 10, threads)
       end
     end
 
-    it { expect(pool.current_size).to be > 4 }# make sure the pool grew beyond size
+    it { expect(pool.current_size).to be > 4 }
 
     it "should reap" do
       pool.reap!
@@ -86,8 +86,8 @@ describe HotTub do
 
     it "should work" do
       results = threads.collect{ |t| t[:status]}
-      expect(results.length).to eql(150) # make sure all threads are present
-      expect(results.uniq).to eql([200]) # make sure all returned status 200
+      expect(results.length).to eql(200)
+      expect(results.uniq).to eql([200])
     end
   end
 
@@ -99,13 +99,10 @@ describe HotTub do
     end
 
     it "should work" do
-      conn = nil
-
       begin
         th = Thread.new do
           uri = URI.parse(HotTub::Server.slow_url)
           pool.run do |connection|
-            conn = connection
             connection.get(:path => uri.path).status
           end
         end
@@ -118,14 +115,11 @@ describe HotTub do
 
       expect(pool.shutdown).to eql(true)
       expect(pool.current_size).to eql(0)
-      expect(conn.send(:sockets)).to be_empty
     end
   end
 
 end
 
-
-
 def excon_thread_work(pool,thread_count=0, threads=[])
   thread_count.times.each do
     threads << Thread.new do

data/spec/hot_tub/integration/net_http_spec.rb

@@ -15,17 +15,17 @@ describe HotTub do
     let(:threads) { [] }
 
     before(:each) do
-      5.times do
-        net_http_thread_work(pool, 30, threads)
+      20.times do
+        net_http_thread_work(pool, 10, threads)
       end
     end
 
-    it { expect(pool.current_size).to eql(4) } # make sure the pool grew beyond size
+    it { expect(pool.current_size).to eql(4) }
 
     it "should work" do
       results = threads.collect{ |t| t[:status]}
-      expect(results.length).to eql(150) # make sure all threads are present
-      expect(results.uniq).to eql(['200']) # make sure all returned status 200
+      expect(results.length).to eql(200)
+      expect(results.uniq).to eql(['200'])
     end
 
     it "should shutdown" do
@@ -48,8 +48,8 @@ describe HotTub do
     let(:threads) { [] }
 
     before(:each) do
-      5.times do
-        net_http_thread_work(pool, 30, threads)
+      20.times do
+        net_http_thread_work(pool, 10, threads)
       end
     end
 
@@ -57,8 +57,8 @@ describe HotTub do
     it { expect(pool.current_size).to be <= 8 }
     it "should work" do
       results = threads.collect{ |t| t[:status]}
-      expect(results.length).to eql(150) # make sure all threads are present
-      expect(results.uniq).to eql(['200']) # make sure all returned status 200
+      expect(results.length).to eql(200)
+      expect(results.uniq).to eql(['200'])
     end
   end
 
@@ -76,17 +76,17 @@ describe HotTub do
     let(:threads) { [] }
 
     before(:each) do
-      5.times do
-        net_http_thread_work(pool, 30, threads)
+      20.times do
+        net_http_thread_work(pool, 10, threads)
       end
     end
 
-    it { expect(pool.current_size).to be > 4 } # make sure the pool grew beyond size
+    it { expect(pool.current_size).to be > 4 }
 
     it "should work" do
       results = threads.collect{ |t| t[:status]}
-      expect(results.length).to eql(150) # make sure all threads are present
-      expect(results.uniq).to eql(['200']) # make sure all returned status 200
+      expect(results.length).to eql(200)
+      expect(results.uniq).to eql(['200'])
     end
   end
 end

data/spec/hot_tub/integration/sessions_spec.rb

@@ -4,23 +4,30 @@ describe HotTub, 'with sessions' do
 
   let(:url) { HotTub::Server.url }
   let(:url2) { HotTub::Server2.url }
-  let(:sessions) do
-    HotTub.new(:sessions => true) { |url|
+
+
+  let(:threads) { [] }
+
+  let(:sessions) { HotTub::Sessions.new(:name => "intText") }
+
+  before(:each) do
+    sessions.add(url) {
       uri = URI.parse(url)
       http = Net::HTTP.new(uri.host, uri.port)
       http.use_ssl = false
       http.start
       http
     }
-  end
 
-  let(:threads) { [] }
+    sessions.add(url2) {
+      Excon.new(url2)
+    }
 
-  before(:each) do
-    10.times.each do
+
+    5.times.each do
       threads << Thread.new do
-        sessions.run(url)  { |clnt| Thread.current[:result] = clnt.get(URI.parse(url).path).code }
-        sessions.run(url2) { |clnt| Thread.current[:result] = clnt.get(URI.parse(url).path).code }
+        sessions.run(url) { |clnt| Thread.current[:result1] = clnt.get(URI.parse(url).path).code }
+        sessions.run(url2) { |clnt| Thread.current[:result2] = clnt.get(:path => URI.parse(url2).path).status }
       end
     end
     threads.each do |t|
@@ -28,13 +35,17 @@ describe HotTub, 'with sessions' do
     end
   end
 
-  it "should work" do
-    results = threads.collect{ |t| t[:result]}
-    expect(results.length).to eql(10)
-    expect(results.uniq).to eql([results.first])
+  it "should create sessions" do
+    expect(sessions.instance_variable_get(:@_sessions).keys.length).to eql(2)
   end
-  
-  it "should work" do
-    expect(sessions.instance_variable_get(:@sessions).keys.length).to eql(2)
+
+  it "should do work" do
+    results = threads.collect{ |t| t[:result1]}
+    expect(results.length).to eql(5)
+    expect(results.uniq).to eql([results.first])
+    results = threads.collect{ |t| t[:result2]}
+    expect(results.length).to eql(5)
+    expect(results.uniq).to eql([results.first])
   end
+
 end

data/spec/hot_tub/pool_spec.rb

@@ -13,7 +13,7 @@ describe HotTub::Pool do
     end
 
     it "should have set the client" do
-      expect(pool.instance_variable_get(:@new_client).call).to be_a(MocClient)
+      expect(pool.instance_variable_get(:@client_block).call).to be_a(MocClient)
     end
 
     it "should be true" do
@@ -61,11 +61,6 @@ describe HotTub::Pool do
       expect(result).to_not be_nil
     end
 
-    context 'block not given' do
-      it "should raise ArgumentError" do
-        expect { pool.run }.to raise_error(ArgumentError)
-      end
-    end
   end
 
   describe ':max_size option' do
@@ -123,8 +118,8 @@ describe HotTub::Pool do
     let(:client) { MocClient.new }
 
     before(:each) do
-      pool.instance_variable_set(:@_out, [client,MocClient.new,MocClient.new])
-      pool.instance_variable_set(:@_pool, [MocClient.new,MocClient.new,MocClient.new])
+      pool.instance_variable_set(:@_out, [MocClient.new,MocClient.new])
+      pool.instance_variable_set(:@_pool, [client,MocClient.new,MocClient.new])
     end
 
     it "should reset pool" do
@@ -178,20 +173,7 @@ describe HotTub::Pool do
   end
 
   context 'private methods' do
-    let(:pool) { HotTub::Pool.new { MocClient.new}  }
-
-    describe '#client' do
-      it "should raise HotTub::BlockingTimeout if an available is not found in time"do
-        pool.instance_variable_set(:@non_blocking,false)
-        pool.instance_variable_set(:@wait_timeout, 0.1)
-        allow(pool).to receive(:raise_alarm?).and_return(true)
-        expect { puts pool.send(:pop) }.to raise_error(HotTub::Pool::Timeout)
-      end
-
-      it "should return an instance of the client" do
-        expect(pool.send(:client)).to be_instance_of(MocClient)
-      end
-    end
+    let(:pool) { HotTub::Pool.new(:close => :close) { MocClient.new}  }
 
     describe '#pop' do
       context "is allowed" do
@@ -211,10 +193,10 @@ describe HotTub::Pool do
       end
       context "client is not registered" do
         it "should push client back to pool" do
-          clnt = pool.send(:pop)
-          pool.instance_variable_get(:@_out).delete(clnt)
+          clnt = MocClient.new
           pool.send(:push,clnt)
           expect(pool.instance_variable_get(:@_pool).include?(clnt)).to eql(false)
+          expect(clnt).to be_closed
         end
       end
       context "client is nil" do
@@ -230,17 +212,16 @@ describe HotTub::Pool do
     it "should grow" do
       pool = HotTub::Pool.new({:size => 4}) { MocClient.new }
       failed = false
-      expect {
-        threads = []
-        20.times.each do
-          threads << Thread.new do
-            pool.run{|connection| connection.get }
-          end
-        end
-        threads.each do |t|
-          t.join
+      threads = []
+      20.times.each do
+        threads << Thread.new do
+          pool.run{|connection| connection.get }
         end
-      }.to_not raise_error
+      end
+      sleep(0.01)
+      threads.each do |t|
+        t.join
+      end
       expect(pool.current_size).to be >= 4
     end
   end

data/spec/hot_tub/sessions_spec.rb

@@ -4,82 +4,60 @@ require 'uri'
 require 'time'
 describe HotTub::Sessions do
 
-  context 'initialized without a block' do
-    it "should raise error if block is not supplied" do
-      expect { HotTub::Sessions.new }.to raise_error(ArgumentError)
-    end
-  end
 
   context 'initialized with a block' do
 
-    let(:url) { "https://www.somewebsite.com" }
-    let(:uri) { URI(url) }
-
-    let(:sessions) { HotTub::Sessions.new { |url| MocClient.new(url) } }
+    let(:key) { "https://www.somewebsite.com" }
 
+    let(:sessions) { HotTub::Sessions.new }
 
-    describe '#to_url' do
-      context "passed URL string" do
-        it "should return key with URI scheme-domain" do
-          expect(sessions.send(:to_key,url)).to eql("#{uri.scheme}://#{uri.host}:#{uri.port}")
+    describe '#sessions' do
+      context 'HotTub::Pool as client' do
+        it "should add a new client for the key" do
+          sessions = HotTub::Sessions.new
+          sessions.add(key) { MocClient.new } 
+          sns = sessions.instance_variable_get(:@_sessions)
+          expect(sns.size).to eql(1)
+          sns.each_value {|v| expect(v).to be_a( HotTub::Pool)}
         end
       end
+    end
+  end
 
-      context "passed URI" do
-        it "should return key with URI scheme-domain" do
-          expect(sessions.send(:to_key,uri)).to eql("#{uri.scheme}://#{uri.host}:#{uri.port}")
-        end
-      end
+  describe '#reaper' do
+    let(:url) { "https://www.somewebsite.com" }
 
-      context "invalid argument" do
-        it "should raise an ArgumentError" do
-          expect { sessions.send(:to_key, nil) }.to raise_error(ArgumentError)
-        end
-        it  "should raise URI::InvalidURIError with bad url" do
-          expect { sessions.send(:to_key,"bad url") }.to raise_error(URI::InvalidURIError)
-        end
-      end
+    let(:sessions) { HotTub::Sessions.new }
+
+    it "should start reaper after add" do
+      expect(sessions.reaper).to be_nil
+      sessions.add("https://www.somewebsite.com") { MocClient.new } 
+      expect(sessions.reaper).to be_a(Thread)
     end
 
-    describe '#sessions' do
-      context 'HotTub::Pool as client' do
-        it "should add a new client for the url" do
-          with_pool_options = HotTub::Sessions.new { |url| HotTub::Pool.new(:size => 13) { MocClient.new(url) } }
-          with_pool_options.sessions(url)
-          sessions = with_pool_options.instance_variable_get(:@sessions)
-          expect(sessions.size).to eql(1)
-          sessions.each_value {|v| expect(v).to be_a( HotTub::Pool)}
-        end
-      end
-      context "passed URL string" do
-        it "should set key with URI scheme-domain" do
-          sessions.sessions(url)
-          sns = sessions.instance_variable_get(:@sessions)
-          expect(sns["#{uri.scheme}://#{uri.host}:#{uri.port}"]).to be_a(HotTub::Pool)
-        end
-      end
-      context "passed URI" do
-        it "should set key with URI scheme-domain" do
-          sessions.sessions(uri)
-          sns = sessions.instance_variable_get(:@sessions)
-          expect(sns["#{uri.scheme}://#{uri.host}:#{uri.port}"]).to be_a(HotTub::Pool)
-        end
-      end
+    it "should disable pool based reaper" do
+      sessions.add("https://www.somewebsite.com") { MocClient.new } 
+      sessions.add("https://www.someOtherwebsite.com") { MocClient.new } 
+      sessions.add("https://www.someOtherwebsiteToo.com") { MocClient.new } 
+      session = sessions.instance_variable_get(:@_sessions)
+      session.each_value {|v| expect(v.reaper).to be_nil}
     end
+
   end
 
   describe '#run' do
     it "should pass run to pool" do
       url = HotTub::Server.url
-      session_with_pool = HotTub::Sessions.new({:with_pool => true})  { |url|
+      sessions = HotTub::Sessions.new
+      sessions.add(url) do
         uri = URI.parse(url)
         http = Net::HTTP.new(uri.host, uri.port)
         http.use_ssl = false
         http.start
         http
-      }
+      end
       result = nil
-      session_with_pool.run(url) do |conn|
+      sessions.run(url) do |conn|
         uri = URI.parse(url)
         result = conn.get(uri.path).code
       end
@@ -89,11 +67,11 @@ describe HotTub::Sessions do
 
   describe '#clean!' do
     it "should clean all pools in sessions" do
-      sessions = HotTub::Sessions.new(:with_pool => true, :clean => lambda { |clnt| clnt.clean}) { |url| MocClient.new(url) }
-      sessions.sessions('foo')
-      sessions.sessions('bar')
+      sessions = HotTub::Sessions.new
+      sessions.add('foo') { |url| MocClient.new(url) }
+      sessions.add('bar') { |url| MocClient.new(url) }
       sessions.clean!
-      sessions.instance_variable_get(:@sessions).each_pair do |k,v|
+      sessions.instance_variable_get(:@_sessions).each_pair do |k,v|
         v.instance_variable_get(:@_pool).each do |c|
           expect(c).to be_cleaned
         end
@@ -103,21 +81,21 @@ describe HotTub::Sessions do
 
   describe '#drain!' do
     it "should drain all pools in sessions" do
-      sessions = HotTub::Sessions.new(:with_pool => true) { |url| MocClient.new(url) }
-      sessions.sessions('foo')
-      sessions.sessions('bar')
+      sessions = HotTub::Sessions.new
+      sessions.add('foo') { |url| MocClient.new(url) }
+      sessions.add('bar') { |url| MocClient.new(url) }
       sessions.drain!
-      expect(sessions.instance_variable_get(:@sessions)).to_not be_empty
+      expect(sessions.instance_variable_get(:@_sessions)).to_not be_empty
     end
   end
 
   describe '#reap!' do
     it "should clean all pools in sessions" do
-      sessions = HotTub::Sessions.new(:with_pool => true, :reap => lambda { |clnt| clnt.reap}) { |url| MocClient.new(url) }
-      sessions.sessions('foo')
-      sessions.sessions('bar')
+      sessions = HotTub::Sessions.new
+      sessions.add('foo') { |url| MocClient.new(url) }
+      sessions.add('bar') { |url| MocClient.new(url) }
       sessions.reap!
-      sessions.instance_variable_get(:@sessions).each_pair do |k,v|
+      sessions.instance_variable_get(:@_sessions).each_pair do |k,v|
         v.instance_variable_get(:@_pool).each do |c|
           expect(c).to be_reaped
         end
@@ -127,11 +105,14 @@ describe HotTub::Sessions do
 
   describe '#reset!' do
     it "should reset all pools in sessions" do
-      sessions = HotTub::Sessions.new(:with_pool => true) { |url| MocClient.new(url) }
-      sessions.sessions('foo')
-      sessions.sessions('bar')
+      sessions = HotTub::Sessions.new
+      sessions.add('foo') { |url| MocClient.new(url) }
+      sessions.add('bar') { |url| MocClient.new(url) }
       sessions.reset!
-      expect(sessions.instance_variable_get(:@sessions)).to be_empty
+      sessions.instance_variable_get(:@_sessions).each_pair do |k,v|
+        expect(v.instance_variable_get(:@_pool)).to be_empty
+        expect(v.instance_variable_get(:@_out)).to be_empty
+      end
     end
   end
 end

data/spec/hot_tub_spec.rb

@@ -3,17 +3,22 @@ describe HotTub do
 
   context "helpers" do
     describe '#new' do
-
       it "should return a HotTub::Pool" do
         expect(HotTub.new { |url| MocClient.new(url) }).to be_a(HotTub::Pool)
       end
+    end
+
+    describe '#sessions' do
+      it {expect(HotTub.sessions).to be_a(HotTub::Sessions) }
+    end
+
+    describe '#add' do
+      it "should add a HotTub::Pool to Sessions" do
+        HotTub.add("http://test.com") { MocClient.new }
+
+        pool = HotTub.sessions.fetch("http://test.com")
 
-      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")
-          expect(pool).to be_a(HotTub::Pool)
-        end
+        expect(pool).to be_a(HotTub::Pool)
       end
     end
   end

data/spec/spec_helper.rb

@@ -17,6 +17,8 @@ end
 # in ./support/ and its subdirectories.
 # Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 # HotTub.logger = Logger.new(STDOUT)
+# HotTub.trace = true
+
 RSpec.configure do |config|
   config.before(:suite) do
     HotTub::Server.run