hot_tub 0.5.3 → 1.0.0

data/benchmarks/hot_tub.rb

@@ -1,5 +1,5 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'benchmark'
+require 'benchmark/ips'
 require 'hot_tub'
 
 class MocClient
@@ -18,26 +18,37 @@ end
 
 puts `ruby -v`
 
-Benchmark.bmbm do |b|
+s1 = HotTub::Pool.new(:size => 1, :max_size => 1, :clean => lambda {|clnt| clnt.clean}) { MocClient.new }
+s5 = HotTub::Pool.new(:size => 5, :max_size => 5, :clean => lambda {|clnt| clnt.clean}) { MocClient.new }
+s10 = HotTub::Pool.new(:size => 5, :max_size => 10, :clean => lambda {|clnt| clnt.clean}) { MocClient.new }
+s0 = HotTub::Pool.new(:size => 5, :clean => lambda {|clnt| clnt.clean}) { MocClient.new }
 
-  b.report("single thread") do
-    hot_tub = HotTub.new(:size => 1, :max_size => 1, :clean => lambda {|clnt| clnt.clean}) { MocClient.new }
-    1000.times.each  do
-      hot_tub.run do |conn|
-        conn.get
+url = 'http://foo.com'
+HotTub.add(url, {:size => 5, :clean => lambda {|clnt| clnt.clean}}) { MocClient.new }
+
+Benchmark.ips do |b|
+
+  b.report("blocking") do
+    threads = []
+    20.times do
+      threads << Thread.new do
+        s1.run do |conn|
+          conn.get
+        end
       end
     end
+    threads.each do |t|
+      t.join
+    end
   end
 
-  b.report("threaded size 5") do
-    hot_tub = HotTub.new(:size => 5, :max_size => 5, :clean => lambda {|clnt| clnt.clean}) { MocClient.new }
+  b.report("max 5") do
     threads = []
-    50.times.each do
+    20.times do
       threads << Thread.new do
-        20.times do
-          hot_tub.run do |conn|
-            conn.get
-          end
+
+        s5.run do |conn|
+          conn.get
         end
       end
     end
@@ -46,15 +57,12 @@ Benchmark.bmbm do |b|
     end
   end
 
-  b.report("threaded size 5, max 10") do
-    hot_tub = HotTub.new(:size => 5, :max_size => 10, :clean => lambda {|clnt| clnt.clean}) { MocClient.new }
+  b.report("max 10") do
     threads = []
-    50.times.each do
+    20.times do
       threads << Thread.new do
-        20.times do
-          hot_tub.run do |conn|
-            conn.get
-          end
+        s10.run do |conn|
+          conn.get
         end
       end
     end
@@ -63,15 +71,12 @@ Benchmark.bmbm do |b|
     end
   end
 
-  b.report("threaded, size 5, no max") do
-    hot_tub = HotTub.new(:size => 5, :clean => lambda {|clnt| clnt.clean}) { MocClient.new }
+  b.report("no max") do
     threads = []
-    50.times.each do
+    20.times do
       threads << Thread.new do
-        20.times do
-          hot_tub.run do |conn|
-            conn.get
-          end
+        s0.run do |conn|
+          conn.get
         end
       end
     end
@@ -80,21 +85,12 @@ Benchmark.bmbm do |b|
     end
   end
 
-
-  b.report("threaded, HotTub.run ") do
-    urls = ['http://foo.com','http://bar.com','http://zap.com']
-    urls.each do |url|
-      HotTub.add(url, {:clean => lambda {|clnt| clnt.clean}}) { MocClient.new }
-    end
+  b.report("HotTub.run") do
     threads = []
-    50.times.each do
+    20.times do
       threads << Thread.new do
-        20.times do
-          urls.each do |url|
-            HotTub.run(url) do |conn|
-              conn.get
-            end
-          end
+        HotTub.run(url) do |conn|
+          conn.get
         end
       end
     end
@@ -103,54 +99,70 @@ Benchmark.bmbm do |b|
     end
   end
 
+  b.compare!
 end
 
 # ruby 2.2.3p173 (2015-08-18 revision 51636) [x86_64-darwin14]
-# Rehearsal ------------------------------------------------------------
-# single thread              0.090000   0.050000   0.140000 ( 11.056805)
-# threaded size 5            0.110000   0.130000   0.240000 (  2.323854)
-# threaded size 5, max 10    0.080000   0.100000   0.180000 (  1.162047)
-# threaded, size 5, no max   0.030000   0.040000   0.070000 (  0.229230)
-# threaded, HotTub.run       0.130000   0.120000   0.250000 (  0.673286)
-# --------------------------------------------------- total: 0.880000sec
-
-#                                user     system      total        real
-# single thread              0.080000   0.040000   0.120000 ( 10.908496)
-# threaded size 5            0.110000   0.130000   0.240000 (  2.314875)
-# threaded size 5, max 10    0.080000   0.100000   0.180000 (  1.202064)
-# threaded, size 5, no max   0.040000   0.040000   0.080000 (  0.224133)
-# threaded, HotTub.run       0.120000   0.120000   0.240000 (  0.670526)
+# Calculating -------------------------------------
+#             blocking     1.000  i/100ms
+#                max 5     2.000  i/100ms
+#               max 10     4.000  i/100ms
+#               no max     8.000  i/100ms
+#           HotTub.run     8.000  i/100ms
+# -------------------------------------------------
+#             blocking      4.605  (± 0.0%) i/s -     24.000 
+#                max 5     22.610  (± 0.0%) i/s -    114.000 
+#               max 10     43.922  (± 0.0%) i/s -    220.000 
+#               no max     83.448  (± 1.2%) i/s -    424.000 
+#           HotTub.run     82.757  (± 2.4%) i/s -    416.000 
+
+# Comparison:
+#               no max:       83.4 i/s
+#           HotTub.run:       82.8 i/s - 1.01x slower
+#               max 10:       43.9 i/s - 1.90x slower
+#                max 5:       22.6 i/s - 3.69x slower
+#             blocking:        4.6 i/s - 18.12x slower
 
 
 # rubinius 2.5.8 (2.1.0 bef51ae3 2015-07-14 3.5.1 JI) [x86_64-darwin14.4.0]
-# Rehearsal ------------------------------------------------------------
-# single thread              0.427639   0.053404   0.481043 ( 11.049242)
-# threaded size 5            0.214155   0.201618   0.415773 (  2.255010)
-# threaded size 5, max 10    0.170088   0.158815   0.328903 (  1.159579)
-# threaded, size 5, no max   0.132440   0.046240   0.178680 (  0.240322)
-# threaded, HotTub.run       0.169417   0.123085   0.292502 (  0.676492)
-# --------------------------------------------------- total: 1.696901sec
-
-#                                user     system      total        real
-# single thread              0.155789   0.054654   0.210443 ( 11.052989)
-# threaded size 5            0.253045   0.209961   0.463006 (  2.276732)
-# threaded size 5, max 10    0.149159   0.138857   0.288016 (  1.171204)
-# threaded, size 5, no max   0.216853   0.033597   0.250450 (  0.224729)
-# threaded, HotTub.run       0.626503   0.080910   0.707413 (  0.664893)
+# Calculating -------------------------------------
+#             blocking     1.000  i/100ms
+#                max 5     2.000  i/100ms
+#               max 10     4.000  i/100ms
+#               no max     8.000  i/100ms
+#           HotTub.run     8.000  i/100ms
+# -------------------------------------------------
+#             blocking      4.619  (± 0.0%) i/s -     24.000 
+#                max 5     22.758  (± 0.0%) i/s -    114.000 
+#               max 10     44.336  (± 2.3%) i/s -    224.000 
+#               no max     85.267  (± 3.5%) i/s -    432.000 
+#           HotTub.run     85.012  (± 3.5%) i/s -    424.000 
+
+# Comparison:
+#               no max:       85.3 i/s
+#           HotTub.run:       85.0 i/s - 1.00x slower
+#               max 10:       44.3 i/s - 1.92x slower
+#                max 5:       22.8 i/s - 3.75x slower
+#             blocking:        4.6 i/s - 18.46x slower
 
 
 # jruby 9.0.3.0 (2.2.2) 2015-10-21 633c9aa Java HotSpot(TM) 64-Bit Server VM 23.5-b02 on 1.7.0_09-b05 +jit [darwin-x86_64]
-# Rehearsal ------------------------------------------------------------
-# single thread              0.890000   0.070000   0.960000 ( 11.343993)
-# threaded size 5            0.850000   0.130000   0.980000 (  2.324202)
-# threaded size 5, max 10    0.710000   0.110000   0.820000 (  1.178593)
-# threaded, size 5, no max   0.320000   0.050000   0.370000 (  0.233405)
-# threaded, HotTub.run       1.190000   0.100000   1.290000 (  0.683554)
-# --------------------------------------------------- total: 4.420000sec
-
-#                                user     system      total        real
-# single thread              0.350000   0.060000   0.410000 ( 11.156489)
-# threaded size 5            0.540000   0.130000   0.670000 (  2.251505)
-# threaded size 5, max 10    0.300000   0.100000   0.400000 (  1.153055)
-# threaded, size 5, no max   0.270000   0.050000   0.320000 (  0.230043)
-# threaded, HotTub.run       0.360000   0.110000   0.470000 (  0.674920)
+# Calculating -------------------------------------
+#             blocking     1.000  i/100ms
+#                max 5     2.000  i/100ms
+#               max 10     4.000  i/100ms
+#               no max     6.000  i/100ms
+#           HotTub.run     7.000  i/100ms
+# -------------------------------------------------
+#             blocking      4.580  (± 0.0%) i/s -     23.000 
+#                max 5     22.514  (± 4.4%) i/s -    114.000 
+#               max 10     43.620  (± 2.3%) i/s -    220.000 
+#               no max     72.260  (± 6.9%) i/s -    360.000 
+#           HotTub.run     66.509  (±10.5%) i/s -    329.000 
+
+# Comparison:
+#               no max:       72.3 i/s
+#           HotTub.run:       66.5 i/s - 1.09x slower
+#               max 10:       43.6 i/s - 1.66x slower
+#                max 5:       22.5 i/s - 3.21x slower
+#             blocking:        4.6 i/s - 15.78x slower

data/lib/hot_tub.rb

@@ -64,16 +64,22 @@ module HotTub
     GLOBAL_SESSIONS.get_or_set(url, opts, &client_block)
   end
   
+ # Sets a options for new pool for lazy loading
+  def self.stage(url,opts={}, &client_block)
+    GLOBAL_SESSIONS.stage(url, opts, &client_block)
+  end
+
   def self.add(url,opts={}, &client_block)
     self.get_or_set(url,opts, &client_block)
   end
 
   def self.run(url ,&run_block)
     pool = GLOBAL_SESSIONS.fetch(url)
-    pool.run &run_block
+    pool.run(&run_block)
   end
 
   def self.new(opts={}, &client_block)
+    warn "[DEPRECATION] `HotTub.new` is deprecated.  Please use `HotTub::Pool.new` instead."
     Pool.new(opts,&client_block)
   end
 end

data/lib/hot_tub/pool.rb

@@ -11,7 +11,6 @@ module HotTub
     #     pool = HotTub::Pool.new(:size => 10) {
     #       uri = URI.parse("http://somewebservice.com")
     #       http = Net::HTTP.new(uri.host, uri.port)
-    #       http.use_ssl = false
     #       http.start
     #       http
     #     }
@@ -44,7 +43,7 @@ module HotTub
     #     begin
     #       pool.run { |clnt| s clnt.head('/').code }
     #     rescue HotTub::Pool::Timeout => e
-    #       puts "Waited too long for a client: {e}"
+    #       puts "Waited too long for a client: #{e}"
     #     end
     #
     #
@@ -110,12 +109,14 @@ module HotTub
       @cond             = ConditionVariable.new
 
       @shutdown         = false
-      @blocking_reap    = (opts[:reaper] == false && !opts[:sessions])
-      @reaper           = ((opts[:sessions] || (opts[:reaper] == false)) ? false : spawn_reaper)
+
+      @sessions_key     = opts[:sessions_key]
+      @blocking_reap    = (opts[:reaper] == false && !@sessions_key)
+      @reaper           = ((@sessions_key || (opts[:reaper] == false)) ? false : spawn_reaper)
 
       @never_block      = (@max_size == 0)
 
-      at_exit {shutdown!} unless opts[:sessions]
+      at_exit {shutdown!} unless @sessions_key
     end
 
     # Preform an operations with a client/connection.
@@ -297,9 +298,13 @@ module HotTub
     # Returns a new client if its allowed.
     # _add is volatile; and may cause threading issues
     # if called outside @mutex.synchronize {}
-    def _fetch_new
+    def _fetch_new(&client_block)
       if (@never_block || (_total_current_size < @max_size))
-        nc = yield
+        if client_block.arity == 0
+          nc = yield
+        else
+          nc = yield @sessions_key
+        end
         HotTub.logger.info "[HotTub] Adding client: #{nc.class.name} to #{@name}." if HotTub.log_trace?
         nc
       end

data/lib/hot_tub/reaper.rb

@@ -1,5 +1,10 @@
 module HotTub
   class Reaper
+    attr_reader :thread
+
+    def self.spawn(obj)
+      self.new(obj)
+    end
 
     # Creates a new Reaper thread for work.
     # Expects an object that responses to: :reap!
@@ -7,8 +12,8 @@ module HotTub
     # 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 = Thread.new {
+    def initialize(obj)
+      @thread = Thread.new {
         loop do
           begin
             break if obj.shutdown
@@ -21,21 +26,38 @@ module HotTub
           end
         end
       }
-      th[:name] = "HotTub::Reaper"
-      th.abort_on_exception = true
-      th
+      @thread[:name] = "HotTub::Reaper"
+      @thread.abort_on_exception = true
+      @thread
+    end
+
+    def status
+      @thread.status
+    end
+
+    def wakeup
+      @thread.wakeup
+    end
+
+    def shutdown
+      @thread.kill
+      @thread.join
+    end
+
+    def alive?
+      @thread.alive?
     end
 
     # Mixin to dry up Reaper usage
     module Mixin
       attr_reader :reap_timeout, :shutdown, :reaper
 
-      # Setting reaper kills the current reaper. 
+      # Setting reaper kills the current reaper.
       # If the values is truthy a new HotTub::Reaper
       # is created.
       def reaper=reaper
         kill_reaper
-        if reaper 
+        if reaper
           @reaper = HotTub::Reaper.new(self)
         else
           @reaper = false
@@ -48,8 +70,7 @@ module HotTub
 
       def kill_reaper
         if @reaper
-          @reaper.kill
-          @reaper.join
+          @reaper.shutdown
           @reaper = nil if @shutdown
         end
       end

data/lib/hot_tub/sessions.rb

@@ -3,72 +3,141 @@ module HotTub
   class Sessions
     include HotTub::KnownClients
     include HotTub::Reaper::Mixin
-    attr_accessor :name
+    attr_accessor :name,
+      :default_client
 
     # HotTub::Sessions simplifies managing multiple Pools in a single object
     # and using a single Reaper.
     #
     # == Example:
     #
-    #   url  = "http://somewebservice.com"
-    #   url2 = "http://somewebservice2.com"
-    #
-    #   sessions = HotTub::Sessions
-    #   sessions.add(url,{:size => 12}) {
+    #   sessions = HotTub::Sessions(:size => 10) do |url|
     #     uri = URI.parse(url)
     #     http = Net::HTTP.new(uri.host, uri.port)
-    #     http.use_ssl = false
     #     http.start
     #     http
-    #    }
-    #   sessions.add(url2,{:size => 5}) {
-    #     Excon.new(url2)
+    #   end
+    #
+    #   # Every time we pass a url that lacks a entry in our
+    #   # sessions, a new HotTub::Pool is added for that url
+    #   # using the &default_client.
+    #   #
+    #   sessions.run("https://www.google.com"") do |conn|
+    #     p conn.get('/').code
+    #   end
+    #
+    #   sessions.run("https://www.yahoo.com"") do |conn|
+    #     p conn.get('/').code
+    #   end
+    #
+    #   # Lazy load a non-default connection
+    #
+    #   excon_url = "http://somewebservice2.com"
+    #
+    #   sessions.stage(excon_url,{:size => 5}) {
+    #     Excon.new(excon_url, :thread_safe_socket => false)
     #    }
     #
-    #   sessions.run(url) do |conn|
-    #     p conn.head('/').code
+    #   # Excon connection is created on the first call to `.run`
+    #   sessions.run(excon_url) do |conn|
+    #     p conn.head.code
     #   end
     #
-    #   sessions.run(url2) do |conn|
-    #     p conn.head('/').code
+    #
+    #   # Add a connection, which returns a HotTub::Pool instance
+    #
+    #   excon_url2 = "http://somewebservice2.com"
+    #
+    #   MY_CON = sessions.add(excon_url2,{:size => 5}) {
+    #     Excon.new(excon_url2, :thread_safe_socket => false)
+    #    }
+    #
+    #   # Uses Excon
+    #   MY_CON.run(excon_url) do |conn|
+    #     p conn.head.code
     #   end
     #
     # === OPTIONS
+    #
+    #   &default_client
+    #     An optional block for a default client for your pools. If your block accepts a
+    #     parameters, they session key is passed to the block. Your default client
+    #     block will be overridden if you pass a client block to get_or_set
+    #
+    #   [:pool_options]
+    #     Default options for your HotTub::Pools. If you pass options to #get_or_set those options
+    #     override :pool_options.
+    #
     #   [:name]
     #     A string representing the name of your sessions used for logging.
     #
     #   [:reaper]
-    #     If set to false prevents a HotTub::Reaper from initializing.
+    #     If set to false prevents a HotTub::Reaper from initializing for these sessions.
     #
     #   [:reap_timeout]
     #     Default is 600 seconds. An integer that represents the timeout for reaping the pool in seconds.
     #
-    def initialize(opts={})
-      @name             = (opts[:name] || self.class.name)
-      @reaper           = opts[:reaper]
-      @reap_timeout     = (opts[:reap_timeout] || 600)
+    def initialize(opts={}, &default_client)
+      @name                 = (opts[:name] || self.class.name)
+      @reaper               = opts[:reaper]
+      @reap_timeout         = (opts[:reap_timeout] || 600)
+      @default_client       = default_client
+      @pool_options         = (opts[:pool_options] || {})
+
+      @_staged              = {}
+      @_staged.taint
+      
+      @_sessions            = {}
+      @_sessions.taint
 
-      @_sessions        = {}
-      @mutex            = Mutex.new
-      @shutdown         = false
+      @mutex                = Mutex.new
+      @shutdown             = false
 
       at_exit {shutdown!}
     end
 
-    # Adds a new HotTub::Pool for the given key unless
-    # one already exists.
-    def get_or_set(key, pool_options={}, &client_block)
-      raise ArgumentError, 'a block that initializes a new client is required.' unless block_given?
-      pool = nil
-      return pool if pool = @_sessions[key]
-      pool_options[:sessions] = true
-      pool_options[:name] = "#{@name} - #{key}"
+    # Sets arguments / settings for a session that will be 
+    # lazy loaded, returns nil because pool is not created
+    def stage(key, pool_options={}, &client_block)
       @mutex.synchronize do
-        @reaper ||= spawn_reaper if @reaper.nil?
-        pool = @_sessions[key] ||= HotTub::Pool.new(pool_options, &client_block) unless @shutdown
+        @_staged[key] = [pool_options,client_block]
+      end
+      nil
+    end
+
+    # Returns a HotTub::Pool for the given key. If a session
+    # is not found and the is a default_client set, a session will
+    # be created for the key using the default_client.
+    def get(key)
+      pool = @_sessions[key]
+      unless pool
+        @mutex.synchronize do
+          unless @shutdown
+            @reaper = spawn_reaper if @reaper.nil?
+            unless pool = @_sessions[key]
+              settings = @_staged[key]
+              clnt_blk = (settings[1] || @default_client)
+              op = @pool_options.merge(settings[0])
+              op[:sessions_key] = key
+              op[:name] = "#{@name} - #{key}"
+              pool = @_sessions[key] = HotTub::Pool.new(op, &clnt_blk)
+            end
+          end
+        end
       end
       pool
     end
+
+    # Adds session unless it already exists and returns
+    # the session
+    def get_or_set(key, pool_options={}, &client_block)
+      unless @_staged[key]
+        @mutex.synchronize do
+          @_staged[key] ||= [pool_options,client_block]
+        end
+      end
+      get(key)
+    end
     alias :add :get_or_set
 
     # Deletes and shutdowns the pool if its found.
@@ -79,7 +148,7 @@ module HotTub
         pool = @_sessions.delete(key)
       end
       if pool
-        pool.reset!
+        pool.shutdown!
         deleted = true
         HotTub.logger.info "[HotTub] #{key} was deleted from #{@name}." if HotTub.logger
       end
@@ -87,8 +156,9 @@ module HotTub
     end
 
     def fetch(key)
-      pool = @_sessions[key]
-      raise MissingSession, "A session could not be found for #{key.inspect} #{@name}" unless pool
+      unless pool = get(key, &@default_client)
+        raise MissingSession, "A session could not be found for #{key.inspect} #{@name}"
+      end
       pool
     end
 
@@ -96,7 +166,7 @@ module HotTub
 
     def run(key, &run_block)
       pool = fetch(key)
-      pool.run &run_block
+      pool.run(&run_block)
     end
 
     def clean!