hot_tub 0.3.0 → 0.4.0

data/lib/hot_tub/sessions.rb

@@ -4,12 +4,12 @@ module HotTub
     include HotTub::KnownClients
     include HotTub::Reaper::Mixin
 
-    # HotTub::Session is a ThreadSafe::Cache where URLs are mapped to clients or pools.
-    # 
+    # HotTub::Session is a ThreadSafe::Cache where URLs are mapped HotTub::Pools.
     #
-    # == Example with Pool:
+    #
+    # == Example:
     # 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) {
+    #   sessions = HotTub::Sessions.new(:size => 12) {
     #       uri = URI.parse("http://somewebservice.com")
     #       http = Net::HTTP.new(uri.host, uri.port)
     #       http.use_ssl = false
@@ -25,26 +25,7 @@ module HotTub
     #     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
@@ -63,7 +44,6 @@ module HotTub
     #
     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
@@ -72,72 +52,65 @@ module HotTub
       @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
+      @pool_options     = {:no_reaper => true}.merge(opts)
       at_exit {drain!}
     end
 
-    # Safely initializes of sessions
+    # Safely initializes 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.compute_if_absent(key) {
+        HotTub::Pool.new(@pool_options) { @new_client.call(url) }
+      }
       @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))
+      session.run(&block) if session
     end
 
     def clean!
-      @sessions.each_pair do |key,clnt|
-        if clnt.is_a?(HotTub::Pool)
-          clnt.clean!
-        else
-          clean_client(clnt)
-        end
+      @sessions.each_pair do |key,pool|
+        pool.clean!
       end
+      @sessions
     end
 
     def drain!
-      @sessions.each_pair do |key,clnt|
-        if clnt.is_a?(HotTub::Pool)
-          clnt.drain!
-        else
-          close_client(clnt)
-        end
+      @sessions.each_pair do |key,pool|
+        pool.drain!
+      end
+      @sessions
+    end
+
+    def reset!
+      @sessions.each_pair do |key,pool|
+        pool.reset!
       end
       @sessions.clear
+      @sessions = ThreadSafe::Cache.new
+      @sessions
     end
 
     def shutdown!
-      @sessions.each_pair do |key,clnt|
-        if clnt.is_a?(HotTub::Pool)
-          clnt.shutdown!
-        else
-          close_client(clnt)
-        end
+      @shutdown = true
+      begin
+        kill_reaper
+      ensure
+        drain!
+        @sessions = nil
       end
-      @sessions.clear
+      nil
     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
+      @sessions.each_pair do |key,pool|
+        pool.reap!
       end
     end
 

data/lib/hot_tub/version.rb

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

data/lib/hot_tub.rb

@@ -8,7 +8,8 @@ require "hot_tub/pool"
 require "hot_tub/sessions"
 
 module HotTub
-  @@logger = Logger.new(STDOUT)
+  @@logger = nil
+
   def self.logger
     @@logger
   end
@@ -22,7 +23,7 @@ module HotTub
   end
 
   def self.rbx?
-    defined?(RUBY_ENGINE) and RUBY_ENGINE == 'rbx'
+    (defined?(RUBY_ENGINE) and RUBY_ENGINE == 'rbx')
   end
 
   def self.new(opts={},&client_block)

data/spec/helpers/moc_pool.rb

@@ -18,6 +18,7 @@ end
 class MocReaperPool < MocPool
   def initialize
   	super
+    @reap_timeout = 1
     @reaper = HotTub::Reaper.spawn(self)
   end
 end

data/spec/helpers/server.rb

@@ -15,24 +15,26 @@ module HotTub
     set :server, 'puma'
     set :port, 9595
 
-    get '/data/:amount' do |amount|
-      (('x' * amount.to_i ) << Random.new.rand(0..999999).to_s)
+    get '/fast' do
+      sleep(0.01)
+      "foo"
     end
 
-    def self.teardown
-      @server.stop(true) if @server
+    get '/slow' do
+      sleep(1)
+      "foooooooooooo"
     end
 
-    def self.size
-      10_000
+    def self.teardown
+      @server.stop(true) if @server
     end
 
-    def self.path
-      '/data/' << size.to_s
+    def self.url
+      'http://127.0.0.1:9595/fast'
     end
 
-    def self.url
-      'http://127.0.0.1:9595' << path
+    def self.slow_url
+      'http://127.0.0.1:9595/slow'
     end
   end
 
@@ -50,9 +52,9 @@ module HotTub
     set :server, 'puma'
     set :port, 9393
 
-
-    get '/quick' do
-      (Random.new.rand(0..999999).to_s)
+    get '/fast' do
+      sleep(0.01)
+      "foo"
     end
 
     def self.teardown
@@ -60,7 +62,7 @@ module HotTub
     end
 
     def self.url
-      'http://127.0.0.1:9393/quick' 
+      'http://127.0.0.1:9393/fast' 
     end
   end
 end

data/spec/hot_tub/integration/excon_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe HotTub do
+
+  context "blocking (size equals max_size)" do
+    let(:pool) do
+      HotTub.new(:size => 4, :max_size => 4) {
+        Excon.new(HotTub::Server.url, :thread_safe_sockets => false)
+      }
+    end
+
+    let(:threads) { [] }
+
+    before(:each) do
+      5.times do
+        excon_thread_work(pool, 30, threads)
+      end
+    end
+
+    it { expect(pool.current_size).to eql(4) }# make sure the pool grew beyond size
+
+    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
+    end
+
+    it "should shutdown" do
+      pool.shutdown!
+      expect(pool.current_size).to eql(0)
+    end
+  end
+
+  context "with larger max" do
+    let(:pool) do
+      HotTub.new(:size => 4, :max_size => 8) {
+        Excon.new(HotTub::Server.url, :thread_safe_sockets => false)
+      }
+    end
+
+    let(:threads) { [] }
+
+    before(:each) do
+      5.times do
+        excon_thread_work(pool, 30, threads)
+      end
+    end
+
+    it { expect(pool.current_size).to be >= 4 }
+
+    it { expect(pool.current_size).to be <= 8 }
+
+    it "should reap" do
+      pool.reap!
+      expect(pool.current_size).to eql(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
+    end
+  end
+
+  context "sized without max" do
+    let(:pool) do
+      HotTub.new(:size => 4) {
+        Excon.new(HotTub::Server.url, :thread_safe_sockets => false)
+      }
+    end
+
+    let(:threads) { [] }
+
+    before(:each) do
+      5.times do
+        excon_thread_work(pool, 30, threads)
+      end
+    end
+
+    it { expect(pool.current_size).to be > 4 }# make sure the pool grew beyond size
+
+    it "should reap" do
+      pool.reap!
+      expect(pool.current_size).to eql(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
+    end
+  end
+
+  context "shutdown with slow client" do
+    let(:pool) do
+      HotTub.new(:size => 1) {
+        Excon.new(HotTub::Server.slow_url, :thread_safe_sockets => false, :read_timeout => 2)
+      }
+    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
+        sleep(0.01)
+        pool.shutdown!
+        th.join
+      rescue => e
+        puts e.message
+      end
+
+      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
+      uri = URI.parse(HotTub::Server.url)
+      pool.run{|connection| Thread.current[:status] = connection.get(:path => uri.path).status }
+    end
+  end
+  threads.each do |t|
+    t.join
+  end
+end

data/spec/hot_tub/integration/net_http_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe HotTub do
+  context "blocking (size equals max_size)" do
+    let(:pool) do
+      HotTub.new(:size => 4, :max_size => 4) {
+        uri = URI.parse(HotTub::Server.url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = false
+        http.start
+        http
+      }
+    end
+
+    let(:threads) { [] }
+
+    before(:each) do
+      5.times do
+        net_http_thread_work(pool, 30, threads)
+      end
+    end
+
+    it { expect(pool.current_size).to eql(4) } # make sure the pool grew beyond size
+
+    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
+    end
+
+    it "should shutdown" do
+      pool.shutdown!
+      expect(pool.current_size).to eql(0)
+    end
+  end
+
+  context "with larger max" do
+    let(:pool) do
+      HotTub.new(:size => 4, :max_size => 8) {
+        uri = URI.parse(HotTub::Server.url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = false
+        http.start
+        http
+      }
+    end
+
+    let(:threads) { [] }
+
+    before(:each) do
+      5.times do
+        net_http_thread_work(pool, 30, threads)
+      end
+    end
+
+    it { expect(pool.current_size).to be >= 4 }
+    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
+    end
+  end
+
+  context "sized without max" do
+    let(:pool) do
+      HotTub.new(:size => 4) {
+        uri = URI.parse(HotTub::Server.url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = false
+        http.start
+        http
+      }
+    end
+
+    let(:threads) { [] }
+
+    before(:each) do
+      5.times do
+        net_http_thread_work(pool, 30, threads)
+      end
+    end
+
+    it { expect(pool.current_size).to be > 4 } # make sure the pool grew beyond size
+
+    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
+    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.get(uri.path).code }
+    end
+  end
+  threads.each do |t|
+    t.join
+  end
+end

data/spec/hot_tub/integration/sessions_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe HotTub, 'with sessions' do
+
+  let(:url) { HotTub::Server.url }
+  let(:url2) { HotTub::Server2.url }
+  let(:sessions) do
+    HotTub.new(:sessions => true) { |url|
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = false
+      http.start
+      http
+    }
+  end
+
+  let(:threads) { [] }
+
+  before(:each) do
+    10.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 }
+      end
+    end
+    threads.each do |t|
+      t.join
+    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])
+  end
+  
+  it "should work" do
+    expect(sessions.instance_variable_get(:@sessions).keys.length).to eql(2)
+  end
+end