hot_tub 0.3.0 → 0.4.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YThjNDQ4Y2Q0YTg2NGNmY2RhMTVhZjg1NzNiMmM1NjZjNmE2NDUyNw==
-  data.tar.gz: !binary |-
-    ZjAwZWMwNWJkNzE4ZDhlYTg2MzIyYjdlMGM1YTIxY2JkZWQ1ZGY3ZA==
+SHA1:
+  metadata.gz: 814f65fdb0c6f97026ed4dcabbe50d8deaab6a4c
+  data.tar.gz: 4c9744264dae35c80d089194de51e8c445193cdd
 SHA512:
-  metadata.gz: !binary |-
-    YjIyMTkxZDZkNDc2Nzc2OGVlMGI5YTgzODAxZWYwZGIzOWIxNzRkOGQ5NTM4
-    ODQ2ZTBkMThmZmU4YjIxNTg3YWM1OGNlZWRmYTExOTFlY2JkOTYyMzM0MThm
-    M2U4ODI2MmE0NWI3ZmFiZmEwMzU0ZTdlZTY2NjIyMTMyMDdjMzM=
-  data.tar.gz: !binary |-
-    M2QyMzI2OWY0MDBlZWYzYWYwYmVmNmIzMGMyZWVhOWZmYzk4NDEyNGYzYWIz
-    OWZkNmQwMDFmOTFhOTEzNDgwYTVmYzBlMTFjNjk0MTg4YzVmNzk2NjlkY2E3
-    YmNiOTUyYWE2OTNhYzFiY2EwYTc4MzhlZDg2OGYwMWU5NGE2Y2M=
+  metadata.gz: b343c114ffc19c435e44d981eebc68f85d31fa6f7f82461c75e95f292993bc6cf312a4172666b1aa85b1b4bb83be90002d5a347ac8bafd763d3511f0c57eaedd
+  data.tar.gz: 33e1b92fc75d10504679660ed36618d25dbe302e9229b0afba10a585fc5de9b3b4904088aed630f82bfb1eed11804573c6c7fefcdc73bcdc3f0a96be8ff75130

data/.travis.yml

@@ -1,13 +1,10 @@
+sudo: false
+cache: bundler
 language: ruby
 rvm:
-  - 2.1.1
-  - 2.1.0
+  - 2.2
+  - 2.1
   - 2.0.0
-  - 1.9.3
-  - rbx-2
-  - rbx
   - ruby-head
-  - jruby-head
-matrix:
-  allow_failures:
-    - rvm: rbx
+  - rbx-2
+  - jruby

data/HISTORY.md

@@ -4,7 +4,14 @@ HotTub Changelog
 Head
 =======
 
-- Nothing yet
+0.4.0
+=======
+- Hide HotTub::Sessions, should only be used with HotTub::Pool, otherwise just use ThreadSafe::Cache directly
+- Reaper is now just a thread, and make sure we abort on exception
+- add #reset! to Pool and Session for use after forking
+- Test slow shutdowns
+- Move integration tests and isolate
+- General refactoring
 
 0.3.0
 =======

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2014 Joshua T. Mckinney
+Copyright (c) 2010-2015 Joshua T. Mckinney
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -15,7 +15,7 @@ A thread safe, lazy pool.
 * Support for closing resources on shutdown
 
 ### HotTub::Sessions
-A [ThreadSafe::Cache](https://github.com/headius/thread_safe) where URLs are mapped to a pool or client instance.
+A [ThreadSafe::Cache](https://github.com/headius/thread_safe) where URLs are mapped to a HotTub::Pool
 
 ### Requirements
 HotTub is tested on MRI, JRUBY and Rubinius
@@ -43,7 +43,6 @@ Configure Logger by creating `config\initializers\hot_tub.rb` and adding the fol
 
 # Usage 
 
-## HotTub
 For convenience you can initialize a new HotTub::Pool by calling HotTub.new or HotTub::Pool.new directly.
 Returns an instance of HotTub::Pool.
 
@@ -69,6 +68,16 @@ Returns an instance of HotTub::Pool.
       }
     pool.run {|clnt| puts clnt.head('/').code }
 
+### Excon
+
+    require 'hot_tub'
+    require 'excon'
+
+    pool = HotTub.new(:size => 10) { 
+      Excon.new("http://somewebservice.com", :thread_safe_sockets => false)
+      }
+    pool.run {|clnt| puts clnt.head('/').status }
+
 ### HotTub Options    
 **size**: Default is 5. An integer that sets the size of the pool. Could be describe as minimum size the pool should grow to.
 
@@ -78,8 +87,6 @@ Returns an instance of HotTub::Pool.
 
 **reap_timeout**: Default is 600 seconds. An integer that represents the timeout for reaping the pool in seconds.
 
-**close_out**: Default is false. A boolean value that if true force close_client to be called on checkout clients when #drain! is called
-
 **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.
@@ -120,25 +127,6 @@ You can use any library you want with `HotTub::Pool`.
     hot_tub = HotTub.new({:size => 10, :close => lambda {|clnt| clnt.close}, :clean => :clean, :reap => :reap?}) { MyHttpLib.new }
     hot_tub.run { |clnt| clnt.get(url,query).body }
 
-## Sessions only
-Returns a `HotTub::Sessions` instance. 
-
-[Excon](https://github.com/geemus/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 from a single instances
-    
-    require 'hot_tub'
-    require 'excon'
-    # 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
-
 ## Dependencies
 
 * [ThreadSafe](https://github.com/headius/thread_safe)

data/benchmarks/hot_tub.rb

@@ -0,0 +1,116 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'benchmark'
+require 'hot_tub'
+
+class MocClient
+  def initialize(url=nil,options={})
+  end
+
+  def get
+    sleep(0.01)
+  end
+end
+
+puts `ruby -v`
+Benchmark.bmbm do |b|
+
+  b.report("single thread") do
+    hot_tub = HotTub::Pool.new(:size => 1, :max_size => 1, :no_reaper => true) { MocClient.new }
+    1000.times.each  do
+      hot_tub.run do |conn|
+        conn.get
+      end
+    end
+  end
+
+  b.report("threaded size 5") do
+    hot_tub = HotTub::Pool.new(:size => 5, :max_size => 5) { MocClient.new }
+    threads = []
+    1000.times.each do
+      threads << Thread.new do
+        hot_tub.run do |conn|
+          conn.get
+        end
+      end
+    end
+    threads.each do |t|
+      t.join
+    end
+  end
+
+  b.report("threaded size 5, max 10") do
+    hot_tub = HotTub::Pool.new(:size => 5, :max_size => 10) { MocClient.new }
+    threads = []
+    1000.times.each do
+      threads << Thread.new do
+        hot_tub.run do |conn|
+          conn.get
+        end
+      end
+    end
+    threads.each do |t|
+      t.join
+    end
+  end
+
+  b.report("threaded, size 5, no max") do
+    hot_tub = HotTub::Pool.new(:size => 5) { MocClient.new }
+    threads = []
+    1000.times.each do
+      threads << Thread.new do
+        hot_tub.run do |conn|
+          conn.get
+        end
+      end
+    end
+    threads.each do |t|
+      t.join
+    end
+  end
+
+end
+
+# ruby 2.2.3p173 (2015-08-18 revision 51636) [x86_64-darwin14]
+# Rehearsal ------------------------------------------------------------
+# single thread              0.110000   0.040000   0.150000 ( 10.998645)
+# threaded size 5            0.250000   0.320000   0.570000 (  2.490553)
+# threaded size 5, max 10    0.220000   0.290000   0.510000 (  1.372965)
+# threaded, size 5, no max   0.140000   0.130000   0.270000 (  0.240067)
+# --------------------------------------------------- total: 1.500000sec
+
+#                                user     system      total        real
+# single thread              0.110000   0.050000   0.160000 ( 11.009793)
+# threaded size 5            0.320000   0.320000   0.640000 (  2.559244)
+# threaded size 5, max 10    0.300000   0.270000   0.570000 (  1.454562)
+# threaded, size 5, no max   0.200000   0.130000   0.330000 (  0.280806)
+
+
+# rubinius 2.5.8 (2.1.0 bef51ae3 2015-07-14 3.5.1 JI) [x86_64-darwin14.4.0]
+# Rehearsal ------------------------------------------------------------
+# single thread              0.182959   0.057407   0.240366 ( 11.014685)
+# threaded size 5            0.374537   0.274944   0.649481 (  2.251464)
+# threaded size 5, max 10    0.216058   0.215593   0.431651 (  1.137440)
+# threaded, size 5, no max   0.173595   0.120422   0.294017 (  0.086586)
+# --------------------------------------------------- total: 1.615515sec
+
+#                                user     system      total        real
+# single thread              0.177439   0.056605   0.234044 ( 11.031641)
+# threaded size 5            0.273678   0.302949   0.576627 (  2.274915)
+# threaded size 5, max 10    0.212687   0.204235   0.416922 (  1.130088)
+# threaded, size 5, no max   0.138528   0.095331   0.233859 (  0.065469)
+
+
+# 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              1.160000   0.070000   1.230000 ( 11.521177)
+# threaded size 5            1.280000   0.370000   1.650000 (  2.450701)
+# threaded size 5, max 10    0.840000   0.310000   1.150000 (  1.167782)
+# threaded, size 5, no max   0.600000   0.160000   0.760000 (  0.173616)
+# --------------------------------------------------- total: 4.790000sec
+
+#                                user     system      total        real
+# single thread              0.780000   0.080000   0.860000 ( 11.264802)
+# threaded size 5            0.560000   0.340000   0.900000 (  2.269302)
+# threaded size 5, max 10    0.610000   0.320000   0.930000 (  1.168468)
+# threaded, size 5, no max   0.300000   0.150000   0.450000 (  0.150489)
+

data/hot_tub.gemspec

@@ -17,8 +17,10 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "thread_safe"
   
   s.add_development_dependency "rspec"
+  s.add_development_dependency "rspec-autotest"
+  s.add_development_dependency "autotest"
   s.add_development_dependency "sinatra"
-  s.add_development_dependency "puma", "~> 2.0.0"
+  s.add_development_dependency "puma", "~> 2.0"
   s.add_development_dependency "excon"
   
   s.files         = `git ls-files`.split("\n")

data/lib/hot_tub/known_clients.rb

@@ -21,8 +21,9 @@ module HotTub
         action = (@clean_client || known_client_action(clnt,:clean))
         preform_client_action(clnt,action) if action
       rescue => e
-        HotTub.logger.error "There was an error cleaning one of your #{self.class.name} clients: #{e}"
+        HotTub.logger.error "There was an error cleaning one of your #{self.class.name} clients: #{e}" if HotTub.logger
       end
+      clnt
     end
 
     # Attempts to close the provided client, checking the options first for a close block
@@ -32,8 +33,9 @@ module HotTub
         action = (@close_client || known_client_action(clnt,:close))
         preform_client_action(clnt,action) if action
       rescue => e
-        HotTub.logger.error "There was an error closing one of your #{self.class.name} clients: #{e}"
+        HotTub.logger.error "There was an error closing one of your #{self.class.name} clients: #{e}" if HotTub.logger
       end
+      nil
     end
 
     # Attempts to determine if a client should be reaped, block should return a boolean
@@ -42,9 +44,9 @@ module HotTub
         action = (@reap_client || known_client_action(clnt,:reap))
         return preform_client_action(clnt,action) if action
       rescue => e
-        HotTub.logger.error "There was an error reaping one of your #{self.class.name} clients: #{e}"
+        HotTub.logger.error "There was an error reaping one of your #{self.class.name} clients: #{e}" if HotTub.logger
       end
-      return false
+      false
     end
 
     private

data/lib/hot_tub/pool.rb

@@ -61,9 +61,6 @@ module HotTub
     #   in seconds. After said time a HotTub::Pool::Timeout exception will be thrown
     # [:reap_timeout]
     #   Default is 600 seconds. An integer that represents the timeout for reaping the pool in seconds.
-    # [:close_out]
-    #   Default is nil. A boolean like value that if it can be interpreted as true force close_client to be called
-    #   on checkout clients when #drain! is called
     # [: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
@@ -84,9 +81,8 @@ module HotTub
       raise ArgumentError, 'a block that initializes a new client is required' unless block_given?
 
       @size             = (opts[:size] || 5)                # in seconds
-      @wait_timeout     = (opts[:wait_timeout] || 10)   # in seconds
+      @wait_timeout     = (opts[:wait_timeout] || 10)       # in seconds
       @reap_timeout     = (opts[:reap_timeout] || 600)      # the interval to reap connections in seconds
-      @close_out        = opts[:close_out]                  # if true on drain! call close_client block on checked out clients
       @max_size         = (opts[:max_size] || 0)            # maximum size of pool when non-blocking, 0 means no limit
 
       @close_client     = opts[:close]                    # => lambda {|clnt| clnt.close} or :close
@@ -94,10 +90,10 @@ module HotTub
       @reap_client      = opts[:reap]                     # => lambda {|clnt| clnt.reap?} or :reap? # should return boolean
       @new_client       = new_client
 
-      @pool             = []    # stores available clients
-      @pool.taint
-      @out              = []    # stores all checked out clients
-      @out.taint
+      @_pool             = []    # stores available clients
+      @_pool.taint
+      @_out              = []    # stores all checked out clients
+      @_out.taint
 
       @mutex            = Mutex.new
       @cond             = ConditionVariable.new
@@ -109,10 +105,10 @@ module HotTub
     end
 
     # Hand off to client.run
-    def run(&block)
+    def run
       if block_given?
         clnt = client
-        return block.call(clnt) if clnt
+        return yield clnt if clnt
       else
         raise ArgumentError, 'Run requires a block.'
       end
@@ -124,7 +120,7 @@ module HotTub
     # Its possible clients may be returned to the pool after cleaning
     def clean!
       @mutex.synchronize do
-        @pool.each do |clnt|
+        @_pool.each do |clnt|
           clean_client(clnt)
         end
       end
@@ -136,30 +132,54 @@ module HotTub
     # Its possible clients may be returned to the pool after cleaning
     def drain!
       @mutex.synchronize do
-        while clnt = (@pool.pop || (@close_out && @out.pop))
-          close_client(clnt)
+        begin
+          while clnt = (@_pool.pop || @_out.pop)
+            close_client(clnt)
+          end
+        ensure
+          @cond.broadcast
         end
-        @cond.broadcast
       end
     end
     alias :close! :drain!
-    alias :close_all! :drain!
+
+    # Reset the pool and re-spawn reaper.
+    # or if shutdown allow threads to quickly finish their work
+    # Clients from the previous pool will not return to pool.
+    def reset!
+      @mutex.synchronize do
+        begin
+          while clnt = (@_pool.pop || @_out.pop)
+            close_client(clnt)
+          end
+          if @reaper
+            kill_reaper
+            @reaper = Reaper.spawn(self)
+          end
+        ensure
+          @cond.broadcast
+        end
+      end
+      nil
+    end
 
     # Kills the reaper and drains the pool.
     def shutdown!
       @shutdown = true
+      kill_reaper if @reaper
+    ensure
       drain!
     end
 
     # Remove and close extra clients
     # Releases mutex each iteration because
-    # reaping is low priority action
+    # reaping is a low priority action
     def reap!
-      start = Time.now
       loop do
+        break if @shutdown
         reaped = nil
         @mutex.synchronize do
-          reaped = @pool.shift if _reap?
+          reaped = @_pool.shift if _reap?
         end
         if reaped
           close_client(reaped)
@@ -173,6 +193,12 @@ module HotTub
       (@max_size == 0)
     end
 
+    def current_size
+      @mutex.synchronize do
+        _total_current_size
+      end
+    end
+
     private
 
     # Returns an instance of the client for this pool.
@@ -190,9 +216,11 @@ module HotTub
       (time <= Time.now)
     end
 
+    ALARM_MESSAGE = "Could not fetch a free client in time. Consider increasing your pool size."
+
     def raise_alarm
-      message = "Could not fetch a free client in time. Consider increasing your pool size."
-      HotTub.logger.error message
+      message = ALARM_MESSAGE
+      HotTub.logger.error message if HotTub.logger
       raise Timeout, message
     end
 
@@ -201,13 +229,18 @@ module HotTub
     def push(clnt)
       if clnt
         @mutex.synchronize do
-          @out.delete(clnt)
-          unless @shutdown
-            @pool << clnt
+          begin
+            if @_out.delete(clnt)
+              unless @shutdown
+                @_pool << clnt
+              end
+            end
+          ensure
             @cond.signal
           end
         end
         close_client(clnt) if @shutdown
+        reap! unless @reaper
       end
       nil
     end
@@ -220,8 +253,8 @@ module HotTub
         break if @shutdown
         raise_alarm if raise_alarm?(alarm)
         @mutex.synchronize do
-          if (_space? || _add)
-            @out << clnt = @pool.pop
+          if clnt = (@_pool.pop || _fetch_new)
+            @_out << clnt
           else
             @cond.wait(@mutex,@wait_timeout)
           end
@@ -232,23 +265,11 @@ module HotTub
 
     ### START VOLATILE METHODS ###
 
-    # _empty? is volatile; and may cause be inaccurate
-    # if called outside @mutex.synchronize {}
-    def _empty?
-      @pool.empty?
-    end
-
-    # _space? is volatile; and may be inaccurate
-    # if called outside @mutex.synchronize {}
-    def _space?
-      !_empty?
-    end
-
     # Returns the total number of clients in the pool
     # and checked out. _total_current_size is volatile and
     # may be inaccurate if called outside @mutex.synchronize {}
     def _total_current_size
-      (@pool.length + @out.length)
+      (@_pool.length + @_out.length)
     end
 
     # Return true if we have reached our limit set by the :size option
@@ -265,23 +286,14 @@ module HotTub
       (_total_current_size < @max_size)
     end
 
-    # We only want to add a client if the pool is empty in keeping with
-    # a lazy model. If the pool is empty we can only add clients if
-    # never_block? is true or there is room to grow. _add? is volatile;
-    # and may be in accurate if called outside @mutex.synchronize {}
-    def _add?
-      (_empty? && (never_block? || _less_than_size?|| _less_than_max?))
-    end
-
     # Adds a new client to the pool if its allowed
     # _add is volatile; and may cause threading issues
     # if called outside @mutex.synchronize {}
-    def _add
-      return false unless _add?
+    def _fetch_new
+      return nil unless (@_pool.empty? && (never_block? || _less_than_size?|| _less_than_max?))
       nc = @new_client.call
-      HotTub.logger.info "Adding HotTub client: #{nc.class.name} to pool"
-      @pool << nc
-      true
+      HotTub.logger.info "Adding HotTub client: #{nc.class.name} to pool" if HotTub.logger
+      nc
     end
 
     # Returns true if we have clients in the pool, the pool
@@ -290,15 +302,7 @@ module HotTub
     # volatile; and may be inaccurate if called outside
     # @mutex.synchronize {}
     def _reap?
-      (_space? && !@shutdown && (_overflow? || reap_client?(@pool[0])))
-    end
-
-    # Returns true if the pool is greater than the :size option and the
-    # pool has been stagnant long enough to allow for reaping (we don't
-    # want to reap under load). _overflow_expired? is volatile; and may
-    # be inaccurate if called outside @mutex.synchronize {}
-    def _overflow?
-      (@pool.length > @size)
+      ( !@_pool.empty? && !@shutdown && ((@_pool.length > @size) || reap_client?(@_pool[0])))
     end
 
     ### END VOLATILE METHODS ###

data/lib/hot_tub/reaper.rb

@@ -1,5 +1,5 @@
 module HotTub
-  class Reaper < Thread
+  class Reaper
 
     # Creates a new Reaper thread for work.
     # Expects an object that responses to: :reap!
@@ -8,20 +8,21 @@ module HotTub
     # 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 {
+      th = Thread.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}"}
+            HotTub.logger.error "HotTub::Reaper for #{obj.class.name} terminated with exception: #{e.message}" if HotTub.logger
+            HotTub.logger.error e.backtrace.map {|line| " #{line}"} if HotTub.logger
             break
           end
         end
       }
       th[:name] = "HotTub::Reaper"
+      th.abort_on_exception = true
       th
     end
 
@@ -30,7 +31,15 @@ module HotTub
       attr_reader :reap_timeout, :reaper, :shutdown
 
       def reap!
-        raise NoMethodError.new(':reap! must be redefined in your class')
+        raise NoMethodError.new('#reap! must be redefined in your class')
+      end
+
+      def kill_reaper
+        if @reaper
+          @reaper.kill
+          @reaper.join
+          @reaper = nil
+        end
       end
     end
   end