hot_tub 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store
+nbproject/

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in http_hot_tub.gemspec
+gemspec
+
+group :development do
+  platform :ruby do
+    gem 'eventmachine'
+    gem 'em-http-request', '~> 1.0', :require => 'em-http'
+    gem 'em-synchrony', '~> 1.0', :require => ['em-synchrony', 'em-synchrony/em-http']
+    gem "excon"
+  end
+  platform :jruby do
+    gem 'jruby-openssl'
+    gem 'jruby-httpclient'
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Joshua T. Mckinney
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,30 @@
+# HotTub
+A simple thread-safe pooling gem to use with your preferred http library that support
+keep-alive.
+
+## Installation
+
+HotTub is available through [Rubygems](https://rubygems.org/gems/hot_tub) and can be installed via:
+
+    $ gem install hot_tub
+
+## Setup 
+    class MyClass
+      @@pool = HotTub::Session.new({:size => 2 :client => HotTub::Client::EmSynchronyClient.new('https://google.com'), :never_block => true})
+
+      def self.fetch_results(query)
+        @@pool.get(:query => query) # keepalive has be defaulted to true in the client
+      end
+    end
+
+    MyClass.fetch_results({:foo => "goo"})
+
+## Contributing to HotTub
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/http_hot_tub.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "hot_tub/version"
+
+Gem::Specification.new do |s|
+  s.name        = "hot_tub"
+  s.version     = HotTub::VERSION
+  s.authors     = ["Joshua Mckinney"]
+  s.email       = ["joshmckin@gmail.com"]
+  s.homepage    = "https://github.com/JoshMcKin/hot_tub"
+  s.summary     = %q{A very simple ruby pool gem}
+  s.description = %q{A very simple ruby pool gem}
+
+  s.rubyforge_project = "hot_tub"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.add_development_dependency "rspec"
+end

data/lib/hot_tub/clients/client.rb

@@ -0,0 +1,41 @@
+require "hot_tub"
+require 'thread'
+module HotTub
+  # Super class for all HotTub clients
+  # provides the 4 required methods to ensure compatibility
+  class Client
+    
+    def client
+      @client
+    end
+    
+    def method_missing(method, *args, &blk)
+      @client.send(method,*args,&blk)
+    end
+    
+    def temporary?
+      @temporary == true
+    end
+    
+    def mark_temporary
+      @temporary = true
+    end
+    
+    # Override this method to perform the necessary action for ensure a client
+    # is clean for use.
+    def sanitize_hot_tub_client
+      @client
+    end
+    
+    def close_hot_tub_client
+      @client
+    end
+    
+    class << self
+      def mutex
+        Mutex.new
+      end
+    end
+  end
+end
+

data/lib/hot_tub/clients/em_synchrony_client.rb

@@ -0,0 +1,45 @@
+require "hot_tub"
+require "hot_tub/clients/client"
+module HotTub
+  class EmSynchronyClient < HotTub::Client 
+  
+    def initialize(url,options={})
+      @url = url
+      @options = {:inactivity_timeout => 0}.merge(options)     
+      @client = EM::HttpRequest.new(url,options)
+    end
+    
+    def sanitize_hot_tub_client     
+      if @client.conn && @client.conn.error?
+        HotTub.logger.info "Sanitizing connection : #{EventMachine::report_connection_error_status(@client.conn.instance_variable_get(:@signature))}"
+        @client.conn.close_connection
+        @client.instance_variable_set(:@deferred, true)
+      end
+      @client
+    end
+    
+    def close_hot_tub_client
+      @client.conn.close_connection if @client.conn
+    end
+    
+    # Default keepalive true for HTTP requests
+    [:get,:head,:delete,:put,:post].each do |m|
+      define_method m do |options={},&blk|
+        options ={} if options.nil?
+        options[:keepalive] = true
+        @client.send(m,options,&blk)
+      end
+    end
+    
+    def dup
+      self.class.new(@url,@options)
+    end
+    
+    class << self
+      # Use a fiber safe mutex
+      def mutex
+        EM::Synchrony::Thread::Mutex.new
+      end
+    end
+  end
+end

data/lib/hot_tub/clients/excon_client.rb

@@ -0,0 +1,27 @@
+require "hot_tub"
+require "hot_tub/clients/client"
+require "excon"
+module HotTub
+  class ExconClient < HotTub::Client 
+  
+    def initialize(url,options={})
+      @url = url
+      #make sure we turn on keep-alive
+      @options = {:headers => {"Connection" => "keep-alive"}}.merge(options)
+      @client = Excon.new(url,options)
+    end
+    
+    # pretty sure Excon handles this internally
+    def sanitize_hot_tub_client
+      @client
+    end
+    
+    def close_hot_tub_client
+      @client.socket.close
+    end
+    
+    def dup
+      self.class.new(@url,@options)
+    end
+  end
+end

data/lib/hot_tub/clients/http_client_client.rb

@@ -0,0 +1,38 @@
+require "hot_tub"
+require "hot_tub/clients/client"
+require 'uri'
+require 'http_client'
+module HotTub
+  
+  class HttpClientClient < HotTub::Client 
+  
+    def initialize(options={})
+      options[:default_host] = options[:url] if (options[:url] && options[:default_host].nil?)
+      @options = options
+      @client = HTTP::Client.new(options)
+    end
+    
+    # pretty sure HttpClient handles this internally
+    def sanitize_hot_tub_client
+      @client
+    end
+    
+    def close_hot_tub_client
+      @client.shutdown
+    end
+    
+    def dup
+      self.class.new(@options)
+    end  
+  end
+end
+
+module HTTP
+  class Client
+    def read_response(request)
+      r = execute(request)
+      r.body
+      r
+    end
+  end
+end

data/lib/hot_tub/session.rb

@@ -0,0 +1,127 @@
+module HotTub
+  class Session
+    AVAILABLE_CLIENTS = ["NetHttpClient","EmSynchronyClient"]
+   
+    # OPTIONS
+    # * :size - number of connections for each pool
+    # * :inactivity_timeout - number of seconds to wait before disconnecting, 
+    # setting to 0 means the connection will not be closed
+    # * :pool_timeout - the amount of seconds to block waiting for an availble connection, 
+    # because this is blocking it should be an extremely short amount of 
+    # time default to 0.5 seconds, if you need more consider enlarging your pool
+    # instead of raising this number
+    # :never_block - if set to true, a connection will always be returned, but 
+    # these extra connections are not added to the pool when the request is completed
+    def initialize(options={})
+      @options = {
+        :size => 5,
+        :never_block => false,
+        :blocking_timeout => 0.5,
+        :client_options => {}
+      }.merge(options)
+      @pool = []
+      @pool_data = {:current_size => 0}   
+      @client = @options[:client]
+      @mutex = (@client.respond_to?(:mutex) ? @client.mutex : Client.mutex)
+    end
+            
+    def pool
+      @mutex.synchronize do
+        add if add?
+        @pool
+      end
+    end
+  
+    # Fetches an avaible client from the pool.
+    # Hot tubs are not always clean... Make sure we have a good connection. The client
+    # should respond to sanitize_hot_tub_connection, which checks to make sure
+    # the connection is still viable, and resets if not
+    def fetch        
+      client = nil
+      alarm = (Time.now + @options[:blocking_timeout])       
+      # block until we get an available connection or Timeout::Error     
+      while client.nil?
+        raise_alarm if alarm <= Time.now
+
+        client = pool.shift
+        if client.nil? && (@options[:never_block])
+          HotTub.logger.info "Adding never_block client for #{@client.class.name}, will not be returned to pool."
+          client = new_client
+          client.mark_temporary
+        end
+      end
+      client.sanitize_hot_tub_client
+      client
+    end
+  
+    # return a client to the pool
+    def return_client(client)
+      if client.temporary?
+        client.close_hot_tub_client # Too hot in the hot tub...
+      else
+        @pool << client 
+      end
+      @pool
+    end
+    
+    # Run the block on the retrieved connection. Good for ensure the same client
+    # is used for mulitple requests. For HTTP requests make sure you request has
+    # keep-alive properly set for your client
+    # EX:
+    #   @pool = HotTub.new("https://some_web_site.com")
+    #   results = []
+    #   @pool.run do |client|
+    #     results.push  (client.get(:query => {:foo => "bar"}, :keepalive => true))
+    #     results.push  (client.get(:query => {:bar => "foo"}, :keepalive => true)) # reuse client
+    #   end
+    #
+    def run(&block)
+      client = fetch     
+      if block_given?
+        block.call(client)
+      else
+        raise ArgumentError, 'Run requires a block.'
+      end
+    ensure
+      return_client(client) if client
+    end
+   
+
+    # Let pool instance respond to client methods. For HTTP request make sure you 
+    # requests has keep-alive properly set for your client
+    # EX: 
+    #   @pool = HotTub.new("https://some_web_site.com")
+    #   r1 = @pool.get(:query => {:foo => "bar"}, :keepalive => true)
+    #   r2 = @pool.get(:query => {:bar => "foo"}, :keepalive => true) # uses a different client
+    #
+    def method_missing(method, *args, &blk)
+      client = fetch
+      client.send(method,*args,&blk)
+    ensure
+      return_client(client) if client
+    end
+    
+    private
+  
+    def add?
+      (@pool.empty? && (@pool_data[:current_size] < @options[:size]))
+    end
+        
+    def add
+      HotTub.logger.info "Adding HotTub client: #{@client.class.name} to pool"
+      @pool_data[:current_size] += 1
+      @pool << new_client         
+      @pool
+    end
+        
+    def new_client
+      @client.dup
+    end  
+
+    def raise_alarm
+      message = "Could not fetch a free client in time. Consider increasing your pool size for #{@client.class.name}."
+      HotTub.logger.error message
+      raise Timeout::Error, message    
+    end
+  end
+end

data/lib/hot_tub/version.rb

@@ -0,0 +1,3 @@
+module HotTub
+  VERSION = "0.0.1"
+end

data/lib/hot_tub.rb

@@ -0,0 +1,21 @@
+require 'thread'
+require 'timeout'
+require 'logger'
+require "hot_tub/version"
+require "hot_tub/session"
+require "hot_tub/clients/client"
+require "hot_tub/clients/em_synchrony_client"
+require "hot_tub/clients/excon_client"
+require "hot_tub/clients/http_client_client" if RUBY_VERSION < '1.9' or (defined? RUBY_ENGINE and 'jruby' == RUBY_ENGINE)
+
+module HotTub
+ @@logger = Logger.new(STDOUT)
+  def self.logger
+    @@logger
+  end
+  
+  def self.logger=logger
+    @@logger = logger
+  end
+end
+

data/spec/em_synchrony_client_spec.rb

@@ -0,0 +1,47 @@
+unless RUBY_VERSION < '1.9' or (defined? RUBY_ENGINE and 'jruby' == RUBY_ENGINE)
+  require "em-synchrony"
+  require "em-synchrony/em-http"
+  require "em-synchrony/fiber_iterator"
+  require "hot_tub/clients/em_synchrony_client"
+  require 'test_helper_methods'
+  include TestHelperMethods
+
+  describe HotTub::EmSynchronyClient do
+    before(:each) do
+      @url = "https://www.google.com" 
+    end
+
+    it "Keep alive should work" do
+      EM.synchrony do   
+        keep_alive_test HotTub::EmSynchronyClient.new(@url) do |connection| 
+          connection.get.response_header.status
+        end
+        EM.stop
+      end
+    end
+#    context 'integration test with parallel requests' do
+#      # 10 parallel requests
+#      it "should work" do
+#        @connection_pool = HotTub::Session.new(:client_options => 
+#            {:url => "https://www.google.com"},
+#          :never_block => true,
+#          :client => HotTub::EmSynchronyClient)
+#        EM.synchrony do       
+#          concurrency = 10
+#          options = (0..19).to_a
+#          results = []
+#            
+#          EM::Synchrony::FiberIterator.new(options, concurrency).each do |count|
+#            resp =  @connection_pool.get
+#            results.push resp.response_header.status 
+#          end
+#            
+#          results.length.should eql(20)
+#          results.include?(200).should be_true
+#          @connection_pool.instance_variable_get(:@pool).length.should eql(@connection_pool.instance_variable_get(:@options)[:size])                
+#          EM.stop
+#        end
+#      end         
+#    end
+  end
+end

data/spec/excon_client_spec.rb

@@ -0,0 +1,18 @@
+unless (RUBY_VERSION < '1.9' or (defined? RUBY_ENGINE and 'jruby' == RUBY_ENGINE))
+  require "hot_tub/clients/excon_client"
+  require 'test_helper_methods'
+  require 'excon'
+  include TestHelperMethods
+  describe HotTub::ExconClient do
+    before(:each) do
+      @url = "https://www.google.com"
+    end
+  
+    it "Keep alive should work" do
+      keep_alive_test HotTub::ExconClient.new(@url) do |client| 
+        client.get.status
+      end
+    end
+  end
+end
+

data/spec/http_client_client_spec.rb

@@ -0,0 +1,16 @@
+if RUBY_VERSION < '1.9' or (defined? RUBY_ENGINE and 'jruby' == RUBY_ENGINE)
+  require "hot_tub/clients/http_client_client"
+  require 'test_helper_methods'
+  include TestHelperMethods
+  describe HotTub::HttpClientClient do
+    before(:each) do
+      @url = "https://www.google.com"
+    end 
+    it "Keep alive should work" do
+      keep_alive_test HotTub::HttpClientClient.new(:url => @url) do |client| 
+        c = client.get('')
+        c.status_code
+      end
+    end
+  end
+end

data/spec/session_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+  class MocClient < HotTub::Client
+    def initialize(url,options={})   
+    end
+  
+    def get
+      sleep(0.05)
+    end
+  end
+
+describe HotTub::Session do
+  before(:each) do
+    @url = "http://www.testurl123.com/"
+    @tub = HotTub::Session.new(:client => MocClient.new(@url)) 
+  end
+
+  context 'default configuration' do
+    it "should have @pool_size of 5" do
+      @tub.instance_variable_get(:@options)[:size].should eql(5)
+    end
+      
+    it "should have @pool_timeout of 0" do
+      @tub.instance_variable_get(:@options)[:blocking_timeout].should eql(0.5)
+    end
+  end
+        
+  describe '#add_connection?' do
+    it "should be true if @pool_data[:length] is less than desired pool size and 
+    the pool is empty?"do
+      @tub.instance_variable_set(:@pool_data,{:current_size => 1})
+      @tub.send(:add?).should be_true 
+    end
+          
+    it "should be false pool has reached pool_size" do
+      @tub.instance_variable_set(:@pool_data,{:current_size => 5})
+      @tub.instance_variable_set(:@pool,
+        ["connection","connection","connection","connection","connection"])
+      @tub.send(:add?).should be_false
+    end
+  end
+        
+  describe '#add_connection' do
+    it "should add connections for supplied url"do
+      @tub.send(:add)
+      @tub.instance_variable_get(:@pool).should_not be_nil
+    end
+  end   
+        
+  describe '#fetch_connection' do
+    it "should raise Timeout::Error if an available is not found in time"do
+      @tub.stub(:pool).and_return([])
+      lambda { @tub.fetch}.should raise_error(Timeout::Error)
+    end
+    
+    it "should not raise Timeout::Error if an available is not found in time"do
+      @tub.instance_variable_get(:@options)[:never_block] = true
+      @tub.stub(:pool).and_return([])
+      lambda { @tub.fetch}.should_not raise_error(Timeout::Error)
+    end
+    
+    it "should return an instance of the driver" do
+      @tub.fetch.should be_instance_of(MocClient)
+    end
+  end
+  
+  describe '#run' do
+    it "should fetch a connection and run the supplied block" do
+      @fetched = nil
+      
+      @tub.run do |connection|
+        @fetched = connection.class.name
+      end
+      @fetched.should eql("MocClient")
+    end
+    
+    it "should return the connection after use" do
+      @tub.run do |connection|
+        @connection = connection
+        @fetched = @tub.instance_variable_get(:@pool).include?(connection)
+      end
+      @fetched.should be_false # not in pool because its doing work
+      
+      # returned to pool after work was done
+      @tub.instance_variable_get(:@pool).include?(@connection).should be_true
+    end
+  end
+  
+  context 'thread safety' do
+    it "should work" do
+      threads = []
+      20.times.each do
+        threads << Thread.new do
+          @tub.run{|connection| connection.get}
+        end
+      end
+      
+      sleep(0.5)
+      
+      threads.each do |t|
+        t.join
+      end
+      
+      @tub.instance_variable_get(:@pool).length.should eql(5)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'hot_tub'
+require 'rspec'
+require 'bundler/setup'
+require 'logger'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+#Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+HotTub.logger.level = Logger::ERROR
+RSpec.configure do |config|
+
+end

data/spec/test_helper_methods.rb

@@ -0,0 +1,34 @@
+module TestHelperMethods
+  def keep_alive_test(client,&get_status_blk)
+    responses = []
+    start = Time.now
+    
+    50.times.each do
+      c = client.dup # want a new client everytime
+      responses.push get_status_blk.call(c)
+    end
+    
+    normal = Time.now - start
+    
+    # we want a whole new pool to make sure we don't cheat
+    connection_pool = HotTub::Session.new(
+      :client => client)
+    
+    start = Time.now
+    50.times.each do
+      #responses.push get_status_blk.call(connection_pool.get)    
+      connection_pool.run do |c|
+        responses.push get_status_blk.call(c)
+      end
+      
+    end
+    
+    keep_alive = Time.now - start
+    
+   
+    puts "#{client.class.name} keep-alive: #{keep_alive}; normal: #{normal};"
+    #puts responses.join(", ")
+    (keep_alive < normal).should be_true
+  end
+
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: hot_tub
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 0.0.1
+platform: ruby
+authors:
+- Joshua Mckinney
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2012-06-16 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: &2056 !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  requirement: *2056
+  prerelease: false
+  type: :development
+description: A very simple ruby pool gem
+email:
+- joshmckin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- http_hot_tub.gemspec
+- lib/hot_tub.rb
+- lib/hot_tub/clients/client.rb
+- lib/hot_tub/clients/em_synchrony_client.rb
+- lib/hot_tub/clients/excon_client.rb
+- lib/hot_tub/clients/http_client_client.rb
+- lib/hot_tub/session.rb
+- lib/hot_tub/version.rb
+- spec/em_synchrony_client_spec.rb
+- spec/excon_client_spec.rb
+- spec/http_client_client_spec.rb
+- spec/session_spec.rb
+- spec/spec_helper.rb
+- spec/test_helper_methods.rb
+homepage: https://github.com/JoshMcKin/hot_tub
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project: hot_tub
+rubygems_version: 1.8.15
+signing_key:
+specification_version: 3
+summary: A very simple ruby pool gem
+test_files:
+- spec/em_synchrony_client_spec.rb
+- spec/excon_client_spec.rb
+- spec/http_client_client_spec.rb
+- spec/session_spec.rb
+- spec/spec_helper.rb
+- spec/test_helper_methods.rb
+...