hot_tub 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 74ee741ed84ebe1bfdc105cea7cd6ea36d110069
-  data.tar.gz: 213604cfc56cffe9fa593f4a4fe30bd139dafdcd
+  metadata.gz: b7eacafcd3cdc2be1e1f0b27ed6c6c4d351e8858
+  data.tar.gz: 6b0d4c6305a8a5779b5f736e9c1c489328b8f8dd
 SHA512:
-  metadata.gz: 847dc6a4bd53ed60cddcd7103f341ec3b2f8e1c2fad9f380fd614ee7291cc850d0eb56fe44d8ad85e8f209f4566547fbd4b13225fadb9c8ba9f6159dbbd2056d
-  data.tar.gz: a82fd572a976426711af212b2d5123432883abadea80f75940097b44c1cc7755cefca6659f151c37fb569f5ec1a04fccb51143fc137aa34490b85ea418665e00
+  metadata.gz: 339f265c1f55963cc9981ba58cd466ac6af16ccf15ef72af5e3c703f6a316cb405c3f8d63d91cf8633cdd92c2d5529e34e27f27c4e2def3b321a457bb75dbb42
+  data.tar.gz: eebf1efe482e2a84bdd6ddd1d6523d46657f43d684922b14e7850b0eb9d88d94733c09278bf7389f6267209cb354fc8b1be70d744546e49a0875b51e99bb693c

data/.travis.yml

@@ -2,9 +2,10 @@ sudo: false
 cache: bundler
 language: ruby
 rvm:
+  - 2.3.0
   - 2.2.4
   - 2.1.8
   - 2.0.0-p648
   - ruby-head
   - rbx-2
-  - jruby-head
+  - jruby

data/HISTORY.md

@@ -5,6 +5,13 @@ Head
 =======
 - None yet.
 
+1.1.0
+=======
+- Close orphan clients outside of synchonize
+- Freeze alarm message
+- Detect dead resources and reap
+- Detect fork
+
 1.0.0
 =======
 - Allow setting a default client for HotTub::Sessions

data/README.md

@@ -140,35 +140,8 @@ a lambda that accepts the client as an argument or symbol representing a method
 
 ## 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.
+HotTub::Pool automatically detects forks and drains the pool, so no additional "after fork" code is required.
 
-    # 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
-
-    # Unicorn
-    before_fork do |server, worker|
-
-      # 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
 
 
 ## Contributing to HotTub

data/hot_tub.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "hot_tub"
   
-  s.add_development_dependency "rspec"
+  s.add_development_dependency "rspec", "~> 3.0"
   s.add_development_dependency "rspec-autotest"
   s.add_development_dependency "autotest"
   s.add_development_dependency "sinatra"

data/lib/hot_tub/pool.rb

@@ -87,10 +87,13 @@ module HotTub
     # [:reap_timeout]
     #   Default is 600 seconds. An integer that represents the timeout for reaping the pool in seconds.
     #
+    # [:detect_fork]
+    #   Set to false to disable fork detection
+    #
     def initialize(opts={},&client_block)
       raise ArgumentError, 'a block that initializes a new client is required' unless block_given?
       @name             = (opts[:name] || self.class.name)
-      @size             = (opts[:size] || 5)            # in seconds
+      @size             = (opts[:size] || 5)
       @wait_timeout     = (opts[:wait_timeout] || 10)   # in seconds
       @reap_timeout     = (opts[:reap_timeout] || 600)  # the interval to reap connections in seconds
       @max_size         = (opts[:max_size] || 0)        # maximum size of pool when non-blocking, 0 means no limit
@@ -102,7 +105,7 @@ module HotTub
 
       @_pool            = []    # stores available clients
       @_pool.taint
-      @_out             = []    # stores all checked out clients
+      @_out             = {}    # stores all checked out clients
       @_out.taint
 
       @mutex            = Mutex.new
@@ -116,12 +119,15 @@ module HotTub
 
       @never_block      = (@max_size == 0)
 
+      @pid              = Process.pid unless opts[:detect_fork] == false
+
       at_exit {shutdown!} unless @sessions_key
     end
 
     # Preform an operations with a client/connection.
     # Requires a block that receives the client.
     def run
+      drain! if forked?
       clnt = pop
       yield clnt
     ensure
@@ -133,10 +139,15 @@ module HotTub
     def clean!
       HotTub.logger.info "[HotTub] Cleaning pool #{@name}!" if HotTub.logger
       @mutex.synchronize do
-        @_pool.each do |clnt|
-          clean_client(clnt)
+        begin
+          @_pool.each do |clnt|
+            clean_client(clnt)
+          end
+        ensure
+          @cond.signal
         end
       end
+      nil
     end
 
     # Drain the pool of all clients currently checked into the pool.
@@ -153,47 +164,22 @@ module HotTub
         ensure
           @_out.clear
           @_pool.clear
-          @cond.broadcast
-        end
-      end
-    end
-    alias :close! :drain!
-
-    # Reset the pool.
-    # or if shutdown allow threads to quickly finish their work
-    # Clients from the previous pool will not return to pool.
-    def reset!
-      HotTub.logger.info "[HotTub] Resetting pool #{@name}!" if HotTub.logger
-      @mutex.synchronize do
-        begin
-          while clnt = @_pool.pop
-            close_client(clnt)
-          end
-        ensure
-          @_out.clear
-          @_pool.clear
+          @pid = Process.pid
           @cond.broadcast
         end
       end
       nil
     end
+    alias :close! :drain!
+    alias :reset! :drain!
 
     # Kills the reaper and drains the pool.
     def shutdown!
       HotTub.logger.info "[HotTub] Shutting down pool #{@name}!" if HotTub.logger
       @shutdown = true
       kill_reaper if @reaper
-      @mutex.synchronize do
-        begin
-          while clnt = @_pool.pop
-            close_client(clnt)
-          end
-        ensure
-          @_out.clear
-          @_pool.clear
-          @cond.broadcast
-        end
-      end
+      drain!
+      @shutdown = false
       nil
     end
 
@@ -202,21 +188,33 @@ module HotTub
     # reaping is a low priority action
     def reap!
       HotTub.logger.info "[HotTub] Reaping pool #{@name}!" if HotTub.log_trace?
-      reaped = nil
       while !@shutdown
+        reaped = nil
         @mutex.synchronize do
-          if _reap?
-            reaped = @_pool.shift
-          else
-            reaped = nil
+          begin
+            if _reap?
+              if _dead_clients?
+                reaped = @_out.select { |clnt, thrd| !thrd.alive? }.keys
+                @_out.delete_if { |k,v| reaped.include? k }
+              else
+                reaped = [@_pool.shift]
+              end
+            else
+              reaped = nil
+            end
+          ensure
+            @cond.signal
           end
         end
         if reaped
-          close_client(reaped)
+          reaped.each do |clnt|
+            close_client(clnt)
+          end
         else
           break
         end
       end
+      nil
     end
 
     def current_size
@@ -232,9 +230,13 @@ module HotTub
       @max_size = max_size
     end
 
+    def forked?
+      (@pid && (@pid != Process.pid))
+    end
+
     private
 
-    ALARM_MESSAGE = "Could not fetch a free client in time. Consider increasing your pool size."
+    ALARM_MESSAGE = "Could not fetch a free client in time. Consider increasing your pool size.".freeze
 
     def raise_alarm
       message = ALARM_MESSAGE
@@ -242,28 +244,36 @@ module HotTub
       raise Timeout, message
     end
 
+    def close_orphan(clnt)
+      HotTub.logger.info "[HotTub] An orphaned client attempted to return to #{@name}." if HotTub.log_trace?
+      close_client(clnt)
+    end
+
     # Safely add client back to pool, only if
     # that client is registered
     def push(clnt)
       if clnt
+        orphaned = false
         @mutex.synchronize do
           begin
             if !@shutdown && @_out.delete(clnt)
               @_pool << clnt
             else
-              close_client(clnt)
-              HotTub.logger.info "[HotTub] An orphaned client attempted to return to #{@name}." if HotTub.log_trace?
+              orphaned = true
             end
           ensure
             @cond.signal
           end
         end
+        close_orphan(clnt) if orphaned
         reap! if @blocking_reap
       end
       nil
     end
 
     # Safely pull client from pool, adding if allowed
+    # If a client is not available, check for dead
+    # resources and schedule reap if nesseccary
     def pop
       alarm = (Time.now + @wait_timeout)
       clnt = nil
@@ -271,13 +281,20 @@ module HotTub
       while !@shutdown
         raise_alarm if (Time.now > alarm)
         @mutex.synchronize do
-          if clnt = @_pool.pop
-            dirty = true
-            @_out << clnt
-          elsif clnt = _fetch_new(&@client_block)
-            @_out << clnt
-          else
-            @cond.wait(@mutex,@wait_timeout)
+          begin
+            if clnt = @_pool.pop
+              dirty = true
+            else
+              clnt = _fetch_new(&@client_block)
+            end
+          ensure
+            if clnt
+              _checkout(clnt)
+              @cond.signal
+            else
+              @reaper.wakeup if @reaper && _dead_clients?
+              @cond.wait(@mutex,@wait_timeout)
+            end
           end
         end
         break if clnt
@@ -288,6 +305,10 @@ module HotTub
 
     ### START VOLATILE METHODS ###
 
+    def _checkout(clnt)
+      @_out[clnt] = Thread.current
+    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 {}
@@ -316,7 +337,14 @@ module HotTub
     # volatile; and may be inaccurate if called outside
     # @mutex.synchronize {}
     def _reap?
-      (!@shutdown && ((@_pool.length > @size) || reap_client?(@_pool[0])))
+      (!@shutdown && ((@_pool.length > @size) || _dead_clients? || reap_client?(@_pool[0])))
+    end
+
+    # Returns true if we have checked out clients whose resource is dead.
+    # _dead_clients? is volatile; and may be inaccurate if called outside
+    # @mutex.synchronize {}
+    def _dead_clients?
+      @_out.detect { |clnt, thrd| !thrd.alive? }
     end
 
     ### END VOLATILE METHODS ###

data/lib/hot_tub/version.rb

@@ -1,3 +1,3 @@
 module HotTub
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/spec/hot_tub/integration/net_http_spec.rb

@@ -1,104 +1,107 @@
 require 'spec_helper'
 
+
 describe HotTub do
-  context "blocking (size equals max_size)" do
-    let(:pool) do
-      HotTub::Pool.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
+  unless HotTub.jruby?
+    context "blocking (size equals max_size)" do
+      let(:pool) do
+        HotTub::Pool.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) { [] }
+      let(:threads) { [] }
 
-    before(:each) do
-      20.times do
-        net_http_thread_work(pool, 10, threads)
+      before(:each) do
+        20.times do
+          net_http_thread_work(pool, 10, threads)
+        end
       end
-    end
 
-    it { expect(pool.current_size).to eql(4) }
+      it { expect(pool.current_size).to eql(4) }
 
-    it "should work" do
-      results = threads.collect{ |t| t[:status]}
-      expect(results.length).to eql(200)
-      expect(results.uniq).to eql(['200'])
-    end
+      it "should work" do
+        results = threads.collect{ |t| t[:status]}
+        expect(results.length).to eql(200)
+        expect(results.uniq).to eql(['200'])
+      end
 
-    it "should shutdown" do
-      pool.shutdown!
-      expect(pool.current_size).to eql(0)
+      it "should shutdown" do
+        pool.shutdown!
+        expect(pool.current_size).to eql(0)
+      end
     end
-  end
 
-  context "with larger max" do
-    let(:pool) do
-      HotTub::Pool.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
+    context "with larger max" do
+      let(:pool) do
+        HotTub::Pool.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) { [] }
+      let(:threads) { [] }
 
-    before(:each) do
-      20.times do
-        net_http_thread_work(pool, 10, threads)
+      before(:each) do
+        20.times do
+          net_http_thread_work(pool, 10, threads)
+        end
       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(200)
-      expect(results.uniq).to eql(['200'])
+      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(200)
+        expect(results.uniq).to eql(['200'])
+      end
     end
-  end
 
-  context "sized without max" do
-    let(:pool) do
-      HotTub::Pool.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
+    context "sized without max" do
+      let(:pool) do
+        HotTub::Pool.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) { [] }
+      let(:threads) { [] }
 
-    before(:each) do
-      20.times do
-        net_http_thread_work(pool, 10, threads)
+      before(:each) do
+        20.times do
+          net_http_thread_work(pool, 10, threads)
+        end
       end
-    end
 
-    it { expect(pool.current_size).to be > 4 }
+      it { expect(pool.current_size).to be > 4 }
 
-    it "should work" do
-      results = threads.collect{ |t| t[:status]}
-      expect(results.length).to eql(200)
-      expect(results.uniq).to eql(['200'])
+      it "should work" do
+        results = threads.collect{ |t| t[:status]}
+        expect(results.length).to eql(200)
+        expect(results.uniq).to eql(['200'])
+      end
     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 }
+  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
-  threads.each do |t|
-    t.join
   end
 end

data/spec/hot_tub/pool_spec.rb

@@ -169,10 +169,22 @@ describe HotTub::Pool do
       expect(pool.current_size).to eql(1)
       expect(old_client).to be_closed
     end
+
+    context "when client is lost with dead thread" do
+      it "should close dead client" do
+        pool = HotTub::Pool.new({ :size => 1, :close => :close }) { MocClient.new }
+        thread = Thread.new {}
+        thread.join
+        client = MocClient.new
+        pool.instance_variable_set(:@_out, {client => thread})
+        pool.reap!
+        expect(client).to be_closed
+      end
+    end
   end
 
   context 'private methods' do
-    let(:pool) { HotTub::Pool.new(:close => :close) { MocClient.new}  }
+    let(:pool) { HotTub::Pool.new( :close => :close) { MocClient.new}  }
 
     describe '#pop' do
       context "is allowed" do
@@ -180,6 +192,16 @@ describe HotTub::Pool do
           expect(pool.send(:pop)).to be_a(MocClient)
         end
       end
+      context "has dead client" do
+        it "should return new client" do
+          pool.max_size = 1
+          thread = Thread.new {}
+          thread.join
+          client = MocClient.new
+          pool.instance_variable_set(:@_out, {client => thread})
+          expect(pool.send(:pop)).to be_a(MocClient)
+        end
+      end
     end
 
     describe '#push' do

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: hot_tub
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Joshua Mckinney
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-24 00:00:00.000000000 Z
+date: 2016-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rspec-autotest
   requirement: !ruby/object:Gem::Requirement
@@ -152,7 +152,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: hot_tub
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Flexible connection pooling for Ruby.