hot_tub 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 814f65fdb0c6f97026ed4dcabbe50d8deaab6a4c
-  data.tar.gz: 4c9744264dae35c80d089194de51e8c445193cdd
+  metadata.gz: 78df9f4441ecfb13b4eb6de670d8384c140c3b4d
+  data.tar.gz: 345d9409cd6e30bbfff90bea8cc9bef734dbe062
 SHA512:
-  metadata.gz: b343c114ffc19c435e44d981eebc68f85d31fa6f7f82461c75e95f292993bc6cf312a4172666b1aa85b1b4bb83be90002d5a347ac8bafd763d3511f0c57eaedd
-  data.tar.gz: 33e1b92fc75d10504679660ed36618d25dbe302e9229b0afba10a585fc5de9b3b4904088aed630f82bfb1eed11804573c6c7fefcdc73bcdc3f0a96be8ff75130
+  metadata.gz: 56004ba7b29c84e4633cdf22dd88701bd2ecfa02980e146cf2358bb4cf0f6fc6fd044d7df998359f4f3fcb3988f9583ef7b78121726b58fa31bf25a2ab9177ed
+  data.tar.gz: c18c797037130388cdd8e3faa094b592702811364d726bac1ef5f0b57d4ef38576e0c504da8371b66864b6ca27cff80b3b7a16e0e8d749dc770be6deaed935b0

data/.travis.yml

@@ -7,4 +7,4 @@ rvm:
   - 2.0.0
   - ruby-head
   - rbx-2
-  - jruby
+  - jruby-head

data/HISTORY.md

@@ -3,6 +3,12 @@ HotTub Changelog
 
 Head
 =======
+- Drop Thread::Safe dependency
+- Make Sessions useful, complete re-write and provide global sessions support
+- Refactor and clean up Pool
+- Improve logging and add HotTub.trace for more detailed logs
+- Name your pools and sessions for better logging
+- Remove :on_reaper in favor of setting :reaper to false
 
 0.4.0
 =======
@@ -15,7 +21,6 @@ Head
 
 0.3.0
 =======
-
 - Drop EM support, will move to separate gem
 - Simplify API with HotTub.new
 - Use ThreadSafe::Cache for sessions

data/README.md

@@ -1,25 +1,34 @@
 # HotTub [![Build Status](https://travis-ci.org/JoshMcKin/hot_tub.png?branch=master)](https://travis-ci.org/JoshMcKin/hot_tub) [![Coverage Status](https://coveralls.io/repos/JoshMcKin/hot_tub/badge.png?branch=master)](https://coveralls.io/r/JoshMcKin/hot_tub)
 
-A dynamic thread-safe pooling gem, when you need more than a standard static pool.
+Flexible, thread-safe, connection pooling for Ruby. Configurable for any client you desire. Built in reaper th built in support for Net::HTTP and [Excon](https://github.com/excon/excon).
 
 ## Features
 
 ### HotTub::Pool
-A thread safe, lazy pool.
 
 * Thread safe
 * Lazy, pool starts off at 0 and grows as necessary.
-* Non-Blocking, can be configured to always return a client if your pool runs out under load. Overflow clients are returned to the pool for reuse. Once load dies, the pool is reaped down to size.
-* Can be used with any client library instance.
+* Non-Blocking, can be configured to always return a connection if your pool runs out under load. Overflow connections are returned to the pool for reuse. Once load dies, the pool is reaped down to size.
 * Support for cleaning dirty resources, no one likes a dirty `HotTub`
 * Support for closing resources on shutdown
+* Support for process forking
+
 
 ### HotTub::Sessions
-A [ThreadSafe::Cache](https://github.com/headius/thread_safe) where URLs are mapped to a HotTub::Pool
+
+A synchronized hash where keys are mapped to a HotTub::Pools that are managed by a single HotTub::Reaper.
+
+
+### HotTub::Reaper
+
+A separate thread thats manages your pool(s). All HotTub::Pools managed by HotTub::Sessions share a single reaper. One-off HotTub::Pools have their own reaper. The reaper periodically checks pool(s) based on the `:reap_timeout` set for the pool or session. Over-flow connections or connections deemed reap-able ready are pulled from the pool and closed.
+
 
 ### Requirements
+
 HotTub is tested on MRI, JRUBY and Rubinius
-* Ruby >= 1.9
+* Ruby >= 2.0 # Although older versions may work
+
 
 ## Installation
 
@@ -27,6 +36,7 @@ HotTub is available through [Rubygems](https://rubygems.org/gems/hot_tub) and ca
 
     $ gem install hot_tub
 
+
 ### Rails setup
 
 Add hot_tub to your gemfile:
@@ -41,95 +51,131 @@ Configure Logger by creating `config\initializers\hot_tub.rb` and adding the fol
     
     HotTub.logger = Rails.logger
 
-# Usage 
-
-For convenience you can initialize a new HotTub::Pool by calling HotTub.new or HotTub::Pool.new directly.
-Returns an instance of HotTub::Pool.
 
-### Redis
-    # We don't want too many connections so we set our :max_size. Under load our pool
-    # can grow to 30 connections. Once load dies down our pool can be reaped back down to 5
-    pool = HotTub::Pool.new(:size => 5, :max_size => 30, :reap_timeout => 60) { Redis.new }
-    pool.set('hot', 'stuff')
-    pool.get('hot')
-    # => 'stuff'
+# Usage 
 
-### Net::HTTP
+## Pools Managed by HotTub
 
+HotTub::Sessions are used to manage multiple pools with a single object and using a single reaper. 
+A global Sessions object is available from the HotTub module and has several helper methods.
+  
     require 'hot_tub'
     require 'net/http'
+    require 'excon'
+    require 'redis'
 
-    pool = HotTub.new(:size => 10) { 
-      uri = URI.parse("http://somewebservice.com")
+    # Add a HotTub::Pool of Net::HTTP connections to our sessions with a size of 12.
+    # We are using the url as the key but could use anything.
+    # we are not setting :max_size so our connections will grow to match our currency.
+    # Once load dies down our pool will be reaped back down to 12 connections
+
+    url = "https://google.com"
+    HotTub.add(url, { :size => 12 }) do 
+      uri = URI.parse(url)
       http = Net::HTTP.new(uri.host, uri.port)
       http.use_ssl = false
       http.start
-      http
-      }
-    pool.run {|clnt| puts clnt.head('/').code }
+      http 
+    end
 
-### Excon
+    # A separate HotTub::Pool of Excon connections.
 
-    require 'hot_tub'
-    require 'excon'
+    url2 = "http://someOtherServices.com"
+    HotTub.add(url2, { :size => 5 }) { Excon.new }
 
-    pool = HotTub.new(:size => 10) { 
-      Excon.new("http://somewebservice.com", :thread_safe_sockets => false)
-      }
-    pool.run {|clnt| puts clnt.head('/').status }
+    # Lets add Redis too.
+    # We don't want too many connections so we set our :max_size. Under load our pool
+    # can grow to 30 connections. Once load dies down our pool can be reaped back down to 5
 
-### 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.
+    HotTub.add("redis", :size => 5, :max_size => 30) { Redis.new } 
+      
+    # Now we can call any of our pools using the key we set any where in our code.
 
-**max_size**: Default is 0. An integer that represents the maximum number of connections allowed when :non_blocking is true. If set to 0, which is the default, there is no limit; connections will continue to open until load subsides long enough for reaping to occur.
+    HotTub.run(url) do |clnt|    
+      puts clnt.head('/').code
+    end
 
-**wait_timeout**: Default is 10 seconds. An integer that represents the timeout when waiting for a client from the pool in seconds. After said time a HotTub::Pool::Timeout exception will be thrown
+    HotTub.run(url2) do |clnt|    
+      puts clnt.get(:path => "/some_stuff", :query => {:foo => 'bar'}).body
+    end
 
-**reap_timeout**: Default is 600 seconds. An integer that represents the timeout for reaping the pool in seconds.
+    HotTub.run('redis') do |clnt|
+      clnt.set('hot', 'stuff')
+    end
 
-**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.
+## Single Pool
+    
+    pool = HotTub::Pool.new(:size => 5, :max_size => 30, :reap_timeout => 60) { Redis.new }
 
-**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  marking a client for reaping. When nil, as is the default, no action is performed.
+    pool.run |clnt|
+     clnt.set('hot', 'stuff')
+    end
 
-**no_reaper**: Default is nil. A boolean like value that if true prevents the reaper from initializing
+    pool.run |clnt|
+      pool.get('hot')
+    end
 
-**sessions**: Default is false. Returns an instance of `HotTub::Sessions.new` that wraps clients in `HotTub::Pool.new`
 
-### With sessions
-Available via `HotTub.new(:sessions => true)` or `HotTub::Sessions.new`
+## Connection Life Cycles
 
-    require 'hot_tub'
-    require 'net/http'
+HotTub has built in support for closing NetHTTP and Excon. If you need more control or have 
+a different library you would like to use, HotTub can be configured to support your needs 
+using `:close`, `:clean`, and `:reap?` options in a pools settings.
 
-    # We must pass any pool options in our options hash, and our client block 
-    # must accept the a single argument which is normally the url
+`:close` is used to define how a connections should be closed at shutdown and upon reaping.
+reaped.
 
-    hot_tub = HotTub.new(:size => 12, :sessions => true) { |url| 
-      uri = URI.parse(url)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = false
-      http.start
-      http 
+`:clean` is called on each existing connection as its pulled from the pool.
+
+`:reap?` is used to determine if a connection in the pool is ready for reaping.
+
+EX:
+    pool_options = {
+      :size     => 5
+      :max_size => 10
+      :close    => lambda { |clnt| clnt.close_it }, # could also use :close_id symbol instead of a lambda
+      :clean    => lambda { |clnt| clnt.reconnect if clnt.dirty? },
+      :reap?    => lambda { |clnt| clnt.stail? }
     }
-    hot_tub.run("http://somewebservice.com") do |clnt|    
-      puts clnt.head('/').code
-    end
-    hot_tub.run("https://someotherwebservice.com") do |clnt|    
-      puts clnt.head('/').code
+
+    HotTub.add('offBrand', pool_options) { MyCoolClient.new }
+    # or
+    HotTub::Pool.new(pool_options){ MyCoolClient.new }
+
+
+## Forking
+
+HotTub's `#reset!` methods close all idle connections, prevents connections in use from returning
+to the pool and attempts to close orphaned connections as they attempt to return.
+
+    # Puma
+    on_worker_boot do
+
+      # If you let HotTub manage all your connections
+      HotTub.reset!
+
+      # If you have your own HotTub::Sessions
+      MY_SESSIONS.reset!
+
+      # If you have any one-off pools
+      MY_POOL.reset!
+
     end
 
-### Other
-You can use any library you want with `HotTub::Pool`.
+    # Unicorn
+    before_fork do |server, worker|
+
+      # If you let HotTub manage all your connections
+      HotTub.reset!
 
-    url = "http://test12345.com"
-    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 }
+      # If you have your own HotTub::Sessions
+      MY_SESSIONS.reset!
 
-## Dependencies
+      # If you have any one-off pools
+      MY_POOL.reset!
+    end
 
-* [ThreadSafe](https://github.com/headius/thread_safe)
 
 ## Contributing to HotTub
  

data/benchmarks/block_passing.rb

@@ -0,0 +1,96 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'benchmark'
+
+puts `ruby -v`
+
+
+# HotTub uses persisted blocks in several places.
+
+# Tests performance of passing a known block to block call or yield.
+
+class BlockTest
+  class << self
+    def block_to_yield &block
+      block_yield &block
+    end
+
+    def block_to_call &block
+      block_call &block
+    end
+
+    def block_yield
+      yield
+    end
+
+    def block_call &block
+      block.call
+    end
+  end
+end
+
+
+n = 1_000_000
+Benchmark.bmbm do |x|
+  x.report("block yield") do
+    n.times do
+      BlockTest.block_yield { "foo" }
+    end
+  end
+  x.report("block call") do
+    n.times do
+      BlockTest.block_call { "foo" }
+    end
+  end
+  x.report("block to yield") do
+    n.times do
+      BlockTest.block_yield { "foo" }
+    end
+  end
+  x.report("block to call") do
+    n.times do
+      BlockTest.block_call { "foo" }
+    end
+  end
+end
+
+# ruby 2.2.3p173 (2015-08-18 revision 51636) [x86_64-darwin14]
+# Rehearsal --------------------------------------------------
+# block yield      0.160000   0.000000   0.160000 (  0.166351)
+# block call       0.690000   0.000000   0.690000 (  0.684485)
+# block to yield   0.160000   0.000000   0.160000 (  0.166744)
+# block to call    0.680000   0.000000   0.680000 (  0.677085)
+# ----------------------------------------- total: 1.690000sec
+
+#                      user     system      total        real
+# block yield      0.160000   0.000000   0.160000 (  0.165289)
+# block call       0.690000   0.010000   0.700000 (  0.699424)
+# block to yield   0.180000   0.000000   0.180000 (  0.172781)
+# block to call    0.700000   0.010000   0.710000 (  0.702157)
+
+# rubinius 2.5.8 (2.1.0 bef51ae3 2015-07-14 3.5.1 JI) [x86_64-darwin14.4.0]
+# Rehearsal --------------------------------------------------
+# block yield      0.164459   0.009985   0.174444 (  0.136798)
+# block call       0.396599   0.001442   0.398041 (  0.374256)
+# block to yield   0.095014   0.000532   0.095546 (  0.068005)
+# block to call    0.386417   0.001135   0.387552 (  0.370419)
+# ----------------------------------------- total: 1.055583sec
+
+#                      user     system      total        real
+# block yield      0.050738   0.000172   0.050910 (  0.050869)
+# block call       0.359893   0.000935   0.360828 (  0.360429)
+# block to yield   0.050676   0.000181   0.050857 (  0.050787)
+# block to call    0.360640   0.001018   0.361658 (  0.361311)
+
+# 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 --------------------------------------------------
+# block yield      0.410000   0.010000   0.420000 (  0.260548)
+# block call       0.420000   0.000000   0.420000 (  0.356582)
+# block to yield   0.220000   0.000000   0.220000 (  0.189081)
+# block to call    0.360000   0.010000   0.370000 (  0.266201)
+# ----------------------------------------- total: 1.430000sec
+
+#                      user     system      total        real
+# block yield      0.170000   0.000000   0.170000 (  0.173698)
+# block call       0.220000   0.000000   0.220000 (  0.222841)
+# block to yield   0.180000   0.000000   0.180000 (  0.172968)
+# block to call    0.220000   0.000000   0.220000 (  0.224151)

data/benchmarks/hot_tub.rb

@@ -12,10 +12,11 @@ class MocClient
 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 }
+    hot_tub = HotTub.new(:size => 1, :max_size => 1) { MocClient.new }
     1000.times.each  do
       hot_tub.run do |conn|
         conn.get
@@ -24,12 +25,14 @@ Benchmark.bmbm do |b|
   end
 
   b.report("threaded size 5") do
-    hot_tub = HotTub::Pool.new(:size => 5, :max_size => 5) { MocClient.new }
+    hot_tub = HotTub.new(:size => 5, :max_size => 5) { MocClient.new }
     threads = []
-    1000.times.each do
+    50.times.each do
       threads << Thread.new do
-        hot_tub.run do |conn|
-          conn.get
+        20.times do
+          hot_tub.run do |conn|
+            conn.get
+          end
         end
       end
     end
@@ -39,12 +42,14 @@ Benchmark.bmbm do |b|
   end
 
   b.report("threaded size 5, max 10") do
-    hot_tub = HotTub::Pool.new(:size => 5, :max_size => 10) { MocClient.new }
+    hot_tub = HotTub.new(:size => 5, :max_size => 10) { MocClient.new }
     threads = []
-    1000.times.each do
+    50.times.each do
       threads << Thread.new do
-        hot_tub.run do |conn|
-          conn.get
+        20.times do
+          hot_tub.run do |conn|
+            conn.get
+          end
         end
       end
     end
@@ -54,12 +59,37 @@ Benchmark.bmbm do |b|
   end
 
   b.report("threaded, size 5, no max") do
-    hot_tub = HotTub::Pool.new(:size => 5) { MocClient.new }
+    hot_tub = HotTub.new(:size => 5) { MocClient.new }
+    threads = []
+    50.times.each do
+      threads << Thread.new do
+        20.times do
+          hot_tub.run do |conn|
+            conn.get
+          end
+        end
+      end
+    end
+    threads.each do |t|
+      t.join
+    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) { MocClient.new }
+    end
     threads = []
-    1000.times.each do
+    50.times.each do
       threads << Thread.new do
-        hot_tub.run do |conn|
-          conn.get
+        20.times do
+          urls.each do |url|
+            HotTub.run(url) do |conn|
+              conn.get
+            end
+          end
         end
       end
     end
@@ -72,45 +102,50 @@ 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
+# single thread              0.070000   0.040000   0.110000 ( 10.859963)
+# threaded size 5            0.080000   0.090000   0.170000 (  2.288797)
+# threaded size 5, max 10    0.060000   0.060000   0.120000 (  1.197574)
+# threaded, size 5, no max   0.030000   0.030000   0.060000 (  0.222523)
+# threaded, HotTub.run       0.090000   0.090000   0.180000 (  0.659862)
+# --------------------------------------------------- total: 0.640000sec
 
 #                                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)
+# single thread              0.080000   0.030000   0.110000 ( 10.871813)
+# threaded size 5            0.080000   0.090000   0.170000 (  2.228075)
+# threaded size 5, max 10    0.060000   0.070000   0.130000 (  1.204607)
+# threaded, size 5, no max   0.030000   0.020000   0.050000 (  0.220836)
+# threaded, HotTub.run       0.090000   0.080000   0.170000 (  0.670364)
 
 
 # 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
+# single thread              0.152422   0.059901   0.212323 ( 11.104594)
+# threaded size 5            0.204700   0.192881   0.397581 (  2.273955)
+# threaded size 5, max 10    0.166915   0.155789   0.322704 (  1.161038)
+# threaded, size 5, no max   0.143544   0.055138   0.198682 (  0.233619)
+# threaded, HotTub.run       0.184800   0.143068   0.327868 (  0.699002)
+# --------------------------------------------------- total: 1.459158sec
 
 #                                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)
+# single thread              0.146872   0.053339   0.200211 ( 11.129070)
+# threaded size 5            0.206160   0.199475   0.405635 (  2.270780)
+# threaded size 5, max 10    0.201255   0.163359   0.364614 (  1.205708)
+# threaded, size 5, no max   0.066599   0.067142   0.133741 (  0.237895)
+# threaded, HotTub.run       0.533596   0.093450   0.627046 (  0.670178)
 
 
 # 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
+# single thread              0.760000   0.050000   0.810000 ( 11.191212)
+# threaded size 5            0.790000   0.120000   0.910000 (  2.262856)
+# threaded size 5, max 10    0.600000   0.080000   0.680000 (  1.160630)
+# threaded, size 5, no max   0.360000   0.040000   0.400000 (  0.228086)
+# threaded, HotTub.run       0.860000   0.100000   0.960000 (  0.673639)
+# --------------------------------------------------- total: 3.760000sec
 
 #                                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)
-
+# single thread              0.520000   0.060000   0.580000 ( 11.079422)
+# threaded size 5            0.390000   0.100000   0.490000 (  2.235107)
+# threaded size 5, max 10    0.290000   0.080000   0.370000 (  1.171805)
+# threaded, size 5, no max   0.300000   0.030000   0.330000 (  0.265258)
+# threaded, HotTub.run       0.580000   0.090000   0.670000 (  0.672435)

data/hot_tub.gemspec

@@ -9,12 +9,10 @@ Gem::Specification.new do |s|
   s.email       = ["joshmckin@gmail.com"]
   s.homepage    = "https://github.com/JoshMcKin/hot_tub"
   s.license     = "MIT"
-  s.summary     = %q{A dynamic thread-safe pooling gem.}
-  s.description = %q{A dynamic thread-safe pooling gem, when you need more than a standard static pool.}
+  s.summary     = %q{Flexible connection pooling for Ruby.}
+  s.description = %q{Flexible connection pooling for Ruby.}
 
   s.rubyforge_project = "hot_tub"
-
-  s.add_runtime_dependency "thread_safe"
   
   s.add_development_dependency "rspec"
   s.add_development_dependency "rspec-autotest"

data/lib/hot_tub/known_clients.rb

@@ -14,14 +14,20 @@ module HotTub
         }
       }
     }
+
     # Attempts to clean the provided client, checking the options first for a clean block
     # then checking the known clients
     def clean_client(clnt)
-      begin
-        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}" if HotTub.logger
+      if @clean_client
+        begin
+          if @clean_client.is_a?(Proc)
+            preform_client_block(clnt,&@clean_client)
+          else
+            preform_client_method(clnt,@clean_client)
+          end
+        rescue => e
+          HotTub.logger.error "[HotTub] There was an error cleaning one of your #{self.class.name} clients: #{e}" if HotTub.logger
+        end
       end
       clnt
     end
@@ -29,24 +35,36 @@ module HotTub
     # Attempts to close the provided client, checking the options first for a close block
     # then checking the known clients
     def close_client(clnt)
-      begin
-        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}" if HotTub.logger
+      @close_action = (@close_client || known_client_action(clnt,:close) || false) if @close_action.nil?
+      if @close_action
+        begin
+          if @close_action.is_a?(Proc)
+            preform_client_block(clnt,&@close_action)
+          else
+            preform_client_method(clnt,@close_action)
+          end
+        rescue => e
+          HotTub.logger.error "[HotTub] There was an error closing one of your #{self.class.name} clients: #{e}" if HotTub.logger
+        end
       end
       nil
     end
 
     # Attempts to determine if a client should be reaped, block should return a boolean
     def reap_client?(clnt)
-      begin
-        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}" if HotTub.logger
+      rc = false
+      if @reap_client
+        begin
+          if @reap_client.is_a?(Proc)
+            rc = preform_client_block(clnt,&@reap_client)
+          else
+            rc = preform_client_method(clnt,@reap_client)
+          end
+        rescue => e
+          HotTub.logger.error "[HotTub] There was an error reaping one of your #{self.class.name} clients: #{e}" if HotTub.logger
+        end
       end
-      false
+      rc
     end
 
     private
@@ -55,13 +73,12 @@ module HotTub
       (KNOWN_CLIENTS[clnt.class.name] && KNOWN_CLIENTS[clnt.class.name][key])
     end
 
-    def preform_client_action(clnt,action)
-      if action.is_a?(Proc)
-        return action.call(clnt)
-      elsif action.is_a?(Symbol)
-        return clnt.send(action)
-      end
-      false
+    def preform_client_block(clnt,action=nil)
+      yield clnt
+    end
+
+    def preform_client_method(clnt,action=nil)
+      clnt.send(action)
     end
   end
 end