hot_tub 0.2.6 → 0.3.0

data/lib/hot_tub/session.rb

@@ -1,103 +0,0 @@
-require 'uri'
-module HotTub
-  class Session
-    include HotTub::KnownClients
-    # A HotTub::Session is a synchronized hash used to separate pools/clients by their domain.
-    # Excon and EmHttpRequest clients are initialized to a specific domain, so we sometimes need a way to
-    # manage multiple pools like when a process need to connect to various AWS resources. You can use any client
-    # you choose, but make sure you client is threadsafe.
-    # Example:
-    #
-    #   sessions = HotTub::Session.new { |url| Excon.new(url) }
-    #
-    #   sessions.run("http://wwww.yahoo.com") do |conn|
-    #     p conn.head.status
-    #   end
-    #
-    #   sessions.run("https://wwww.google.com") do |conn|
-    #     p conn.head.status
-    #   end
-    #
-    # Example with Pool:
-    # You can initialize a HotTub::Pool with each client by passing :with_pool as true and any pool options
-    #   sessions = HotTub::Session.new(:with_pool => true, :size => 12) { EM::HttpRequest.new("http://somewebservice.com") }
-    #
-    #   sessions.run("http://wwww.yahoo.com") do |conn|
-    #     p conn.head.response_header.status
-    #   end
-    #
-    #   sessions.run("https://wwww.google.com") do |conn|
-    #     p conn.head.response_header.status
-    #   end
-    #
-    #
-    def initialize(options={},&client_block)
-      raise ArgumentError, "HotTub::Sessions requre a block on initialization that accepts a single argument" unless block_given?
-      @options = options || {}
-      @client_block = client_block
-      @sessions = Hash.new
-      @mutex = (em_client? ? EM::Synchrony::Thread::Mutex.new : Mutex.new)
-      HotTub.hot_at_exit( em_client? ) {close_all}
-    end
-
-    # Synchronizes initialization of our sessions
-    # expects a url string or URI
-    def sessions(url)
-      key = to_key(url)
-      return @sessions[key] if @sessions[key]
-      @mutex.synchronize do
-        if @options[:with_pool]
-          @sessions[key] = HotTub::Pool.new(@options) { @client_block.call(url) }
-        else
-          @sessions[key] = @client_block.call(url) if @sessions[key].nil?
-        end
-        @sessions[key]
-      end
-    end
-
-    def run(url,&block)
-      session = sessions(url)
-      return session.run(&block) if session.is_a?(HotTub::Pool)
-      block.call(sessions(url))
-    end
-
-    # Calls close on all pools/clients in sessions
-    def close_all
-      @sessions.each do |key,clnt|
-        if clnt.is_a?(HotTub::Pool)
-          clnt.close_all
-        else
-          begin
-            close_client(clnt)
-          rescue => e
-            HotTub.logger.error "There was an error close one of your HotTub::Session clients: #{e}"
-          end
-        end
-        @mutex.synchronize do
-          @sessions[key] = nil
-        end
-      end
-    end
-
-    private
-
-    def em_client?
-      begin
-        (HotTub.em_synchrony? && @client_block.call("http://moc").is_a?(EventMachine::HttpConnection))
-      rescue
-        false
-      end
-    end
-
-    def to_key(url)
-      if url.is_a?(String)
-        uri = URI(url)
-      elsif url.is_a?(URI)
-        uri = url
-      else
-        raise ArgumentError, "you must pass a string or a URI object"
-      end
-      "#{uri.scheme}://#{uri.host}:#{uri.port}"
-    end
-  end
-end

data/spec/session_spec.rb

@@ -1,213 +0,0 @@
-require 'spec_helper'
-require 'hot_tub/session'
-require 'uri'
-require 'time'
-unless HotTub.jruby?
-  require "em-synchrony"
-  require "em-synchrony/em-http"
-end
-describe HotTub::Session do
-
-  context 'initialized without a block' do
-    it "should raise error if block is not supplied" do
-      lambda {HotTub::Session.new}.should raise_error(ArgumentError)
-    end
-  end
-  context 'initialized with a block' do
-    before(:each) do
-      @url = "https://www.somewebsite.com"
-      @uri = URI(@url)
-      @sessions = HotTub::Session.new { |url| MocClient.new(url) }
-    end
-
-    describe '#to_url' do
-      context "passed URL string" do
-        it "should return key with URI scheme-domain" do
-          @sessions.send(:to_key,@url).should eql("#{@uri.scheme}://#{@uri.host}:#{@uri.port}")
-        end
-      end
-
-      context "passed URI" do
-        it "should return key with URI scheme-domain" do
-          @sessions.send(:to_key,@uri).should eql("#{@uri.scheme}://#{@uri.host}:#{@uri.port}")
-        end
-      end
-
-      context "invalid argument" do
-        it "should raise an ArgumentError" do
-          lambda { @sessions.send(:to_key, nil) }.should raise_error(ArgumentError)
-        end
-        it  "should raise URI::InvalidURIError with bad url" do
-          lambda { @sessions.send(:to_key,"bad url") }.should raise_error(URI::InvalidURIError)
-        end
-      end
-    end
-
-    describe '#sessions' do
-      context 'HotTub::Pool as client' do
-        it "should add a new client for the url" do
-          with_pool_options = HotTub::Session.new { |url| HotTub::Pool.new(:size => 13) { MocClient.new(url) } }
-          with_pool_options.sessions(@url)
-          sessions = with_pool_options.instance_variable_get(:@sessions)
-          sessions.length.should eql(1)
-          sessions.first[1].should be_a(HotTub::Pool)
-        end
-      end
-
-      context 'other clients' do
-        it "should add a new client for the url" do
-          no_pool = HotTub::Session.new { |url| Excon.new(url) }
-          no_pool.sessions(@url)
-          sessions = no_pool.instance_variable_get(:@sessions)
-          sessions.length.should eql(1)
-          sessions.first[1].should be_a(Excon::Connection)
-        end
-      end
-
-      context "passed URL string" do
-        it "should set key with URI scheme-domain" do
-          @sessions.sessions(@url)
-          sessions = @sessions.instance_variable_get(:@sessions)
-          sessions["#{@uri.scheme}://#{@uri.host}:#{@uri.port}"].should be_a(MocClient)
-        end
-      end
-      context "passed URI" do
-        it "should set key with URI scheme-domain" do
-          @sessions.sessions(@uri)
-          sessions = @sessions.instance_variable_get(:@sessions)
-          sessions["#{@uri.scheme}://#{@uri.host}:#{@uri.port}"].should be_a(MocClient)
-        end
-      end
-
-      context "with_pool" do
-        it "should initialize a new HotTub::Pool" do
-          session_with_pool = HotTub::Session.new({:with_pool => true})  { |url| MocClient.new(url) }
-          pool = session_with_pool.sessions(@url)
-          pool.should be_a(HotTub::Pool)
-        end
-      end
-    end
-
-    describe '#run' do
-      it "should work" do
-        url = HotTub::Server.url
-        sessions = HotTub::Session.new { |url| Excon.new(url) }
-        result = nil
-        sessions.run(url) do |conn|
-          result = conn.get.status
-        end
-        result.should eql(200)
-      end
-
-      context "with_pool" do
-        it "should pass run to pool" do
-          url = HotTub::Server.url
-          session_with_pool = HotTub::Session.new({:with_pool => true})  { |url| Excon.new(url) }
-          result = nil
-          session_with_pool.run(url) do |conn|
-            result = conn.get.status
-          end
-          result.should eql(200)
-        end
-      end
-    end
-
-    context 'threads' do
-      it "should work" do
-        url = HotTub::Server.url
-        url2 = HotTub::Server2.url
-        session = HotTub::Session.new(:with_pool => true) { |url| Excon.new(url)}
-        failed = false
-        start_time = Time.now
-        stop_time = nil
-        threads = []
-        lambda {
-          10.times.each do
-            threads << Thread.new do
-              # MocClient is not thread safe so lets initialize a new instance for each
-              session.run(url)  { |clnt| Thread.current[:result] = clnt.get.status }
-              session.run(url2) { |clnt| Thread.current[:result] = clnt.get.status }
-            end
-          end
-          threads.each do |t|
-            t.join
-          end
-          stop_time = Time.now
-        }.should_not raise_error # make sure we're thread safe
-        # Some extra checks just to make sure...
-        results = threads.collect{ |t| t[:result]}
-        results.length.should eql(10) # make sure all threads are present
-        results.uniq.should eql([results.first]) # make sure we got the same results
-        ((stop_time.to_i - start_time.to_i) < (results.length * MocClient.sleep_time)).should be_true # make sure IO is running parallel
-        session.instance_variable_get(:@sessions).keys.length.should eql(2) # make sure sessions were created
-      end
-    end
-
-    unless HotTub.jruby?
-
-      describe "em_client?" do
-
-        context 'EM::HttpRequest as client' do
-          before(:each) do
-            @session = HotTub::Session.new {|url| EM::HttpRequest.new(url)}
-          end
-          context "EM::Synchrony is present" do
-            it "should be true" do
-              HotTub.stub(:em_synchrony?).and_return(true)
-              @session.send(:em_client?).should be_true
-            end
-          end
-          context "EM::Synchrony is not present" do
-            it "should be false" do
-              HotTub.stub(:em_synchrony?).and_return(false)
-              @session.send(:em_client?).should be_false
-            end
-          end
-        end
-        context 'client is not EM::HttpRequest' do
-          it "should be false" do
-            session = HotTub::Session.new {|url| MocClient.new}
-            session.send(:em_client?).should be_false
-          end
-        end
-      end
-
-      context 'fibers' do
-        it "should work" do
-          EM.synchrony do
-            sessions = HotTub::Session.new(:with_pool => true) {|url| EM::HttpRequest.new(url)}
-            failed = false
-            fibers = []
-            lambda {
-              10.times.each do
-                fibers << Fiber.new do
-                  sessions.run(@url) {|connection|
-                    s = connection.head(:keepalive => true).response_header.status
-                  failed = true unless s == 200}
-                end
-              end
-              fibers.each do |f|
-                f.resume
-              end
-              loop do
-                done = true
-                fibers.each do |f|
-                  done = false if f.alive?
-                end
-                if done
-                  break
-                else
-                  EM::Synchrony.sleep(0.01)
-                end
-              end
-            }.should_not raise_error
-            sessions.instance_variable_get(:@sessions).keys.length.should eql(1)
-            (sessions.sessions(@url).instance_variable_get(:@pool).length >= 5).should be_true #make sure work got done
-            failed.should be_false # Make sure our requests worked
-            EM.stop
-          end
-        end
-      end
-    end
-  end
-end