em_aws 0.1.10 → 0.2.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    em_aws (0.1.7)
+    em_aws (0.2.0)
       aws-sdk
       em-http-request
       em-synchrony
@@ -9,47 +9,47 @@ PATH
 GEM
   remote: http://rubygems.org/
   specs:
-    addressable (2.2.8)
-    aws-sdk (1.5.5)
+    addressable (2.3.2)
+    aws-sdk (1.8.0)
       httparty (~> 0.7)
       json (~> 1.4)
       nokogiri (>= 1.4.4)
       uuidtools (~> 2.1)
-    builder (3.0.0)
+    builder (3.1.4)
     cookiejar (0.3.0)
     diff-lcs (1.1.3)
-    em-http-request (1.0.2)
+    em-http-request (1.0.3)
       addressable (>= 2.2.3)
       cookiejar
       em-socksify
       eventmachine (>= 1.0.0.beta.4)
       http_parser.rb (>= 0.5.3)
-    em-socksify (0.2.0)
+    em-socksify (0.2.1)
       eventmachine (>= 1.0.0.beta.4)
     em-synchrony (1.0.2)
       eventmachine (>= 1.0.0.beta.1)
-    eventmachine (1.0.0.rc.4)
-    eventmachine (1.0.0.rc.4-java)
+    eventmachine (1.0.0)
+    eventmachine (1.0.0-java)
     http_parser.rb (0.5.3)
     http_parser.rb (0.5.3-java)
-    httparty (0.8.3)
+    httparty (0.9.0)
       multi_json (~> 1.0)
       multi_xml
-    json (1.7.3)
-    json (1.7.3-java)
-    multi_json (1.3.6)
+    json (1.7.6)
+    json (1.7.6-java)
+    multi_json (1.5.0)
     multi_xml (0.5.1)
-    nokogiri (1.5.5)
-    nokogiri (1.5.5-java)
-    rspec (2.10.0)
-      rspec-core (~> 2.10.0)
-      rspec-expectations (~> 2.10.0)
-      rspec-mocks (~> 2.10.0)
-    rspec-core (2.10.1)
-    rspec-expectations (2.10.0)
+    nokogiri (1.5.6)
+    nokogiri (1.5.6-java)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
       diff-lcs (~> 1.1.3)
-    rspec-mocks (2.10.1)
-    uuidtools (2.1.2)
+    rspec-mocks (2.12.1)
+    uuidtools (2.1.3)
 
 PLATFORMS
   java

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2012 Joshua T. Mckinney
+Copyright (c) 2010-2013 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

@@ -1,5 +1,5 @@
 # EmAws
-An EM-Synchrony handler for Ruby [AWS-SDK](https://github.com/amazonwebservices/aws-sdk-for-ruby/)
+An EM-Synchrony handler for Ruby [AWS-SDK-Ruby](https://github.com/aws/aws-sdk-ruby)
 
 ## Installation
 
@@ -8,7 +8,7 @@ em_aws is available through [Rubygems](https://rubygems.org/gems/em_aws) and can
     $ gem install em_aws
 
 ## Rails 3 setup (no rails 2 sorry)
-Setup [AWS-SKD](https://github.com/amazonwebservices/aws-sdk-for-ruby/blob/master/README.rdoc) as you would normally.
+Setup [AWS-SDK-Ruby](https://github.com/aws/aws-sdk-ruby/blob/master/README.rdoc) as you would normally.
 
 Assuming you've already setup async-rails, add em_aws to you gemfile:
     
@@ -25,16 +25,57 @@ In your environments files add:
     AWS.eager_autoload! # AWS lazyloading is not threadsafe
     AWS.config(
       :http_handler => AWS::Http::EMHttpHandler.new(
-      :proxy => {:host => "http://myproxy.com", :port => 80}
-       ))
+      :proxy => {:host => "http://myproxy.com", :port => 80}))
+      :pool_size => 0 # by default connection pooling is off
+      :async => false # if set to true all requests for this client will be asynchronous
 
 Your done. 
 
-All requests to AWS will use EM-Synchrony's implementation of em-http-request for non-block HTTP request and fiber management.
+All requests to AWS will use EM-Synchrony's implementation of em-http-request for non-block HTTP requests and fiber management.
+
+## Connection Pooling (keep-alive)
+To enable connection pooling set the :pool_size to anything greater than 0. By default :inactivity_timeout is set
+to 0 which will leave the connection open for as long as the client allows. Connects
+are created lazy, so pools grow until they meet the set pool size.
+    
+    require 'aws-sdk'
+    require 'aws/core/http/em_http_handler'
+    AWS.config(
+      :http_handler => AWS::Http::EMHttpHandler.new({
+        :pool_size => 20,
+        :inactivity_timeout => 0, # number of seconds to timeout stale connections in the pool,
+        :never_block => true, # if we run out of connections, create a new one
+        :proxy => {:host => "http://myproxy.com",:port => 80})
+    )
+
+## Streaming
+Requires [AWS-SKD-Ruby >= 1.6.3] (http://aws.amazon.com/releasenotes/Ruby/5728376747252106)
+    EM.synchrony do
+      s3 = AWS::S3.new 
+      file = File.open("path_to_file")
+      s3.buckets['bucket_name'].objects["foo.txt"].write(file)
+      EM.stop
+    end
+
+## Asynchronous Requests
+Requests can be set to perform asynchronously, returning nil initially and performing
+the actions in the background. If the request option :async are set to true that only
+that request request will handled asynchronously. If the client option :async all requests will 
+be handled asynchronously.
+
+    EM.synchrony do
+      s3 = AWS::S3.new
+      s3.buckets['bucket-name'].objects["foo"].write('test', :async => true) # => nil
+      EM::Synchrony.sleep(2) # Let the pending fibers run
+      s3.buckets['bucket-name'].objects["foo"].read # => # 'test'
+      s3.buckets['bucket-name'].objects["foo"].delete(:async => true) # => nil
+      EM::Synchrony.sleep(2) # Let the pending fibers run
+      EM.stop
+    end
 
 ## References
 
-  [aws-sdk](https://github.com/amazonwebservices/aws-sdk-for-ruby)
+  [AWS-SDK-Ruby](https://github.com/aws/aws-sdk-ruby)
 
   [Async-Rails](https://github.com/igrigorik/async-rails)
 
@@ -52,9 +93,9 @@ All requests to AWS will use EM-Synchrony's implementation of em-http-request fo
 
 ## Thanks
 
-Code based on HTTParty Hander in [aws-sdk](https://github.com/amazonwebservices/aws-sdk-for-ruby/blob/master/README.rdoc)
+Code based on HTTP Handers in [AWS-SDK-Ruby](https://github.com/aws/aws-sdk-ruby/blob/master/README.rdoc)
 
 ## License
 
 EmAws [license](https://github.com/JoshMcKin/em_aws/blob/master/LICENSE.txt)
-AWS-SDK [license](https://github.com/amazonwebservices/aws-sdk-for-ruby/blob/master/LICENSE.txt)
+AWS-SDK-Ruby [license](https://github.com/aws/aws-sdk-for-ruby/blob/master/LICENSE.txt)

data/lib/aws/core/http/em_connection_pool.rb

@@ -0,0 +1,120 @@
+require 'thread'
+require "em-synchrony/em-http"
+require 'em-synchrony/thread'
+
+module AWS 
+  module Core
+    module Http
+      class EMConnectionPool
+        # Since AWS connections may be to any number of urls, the connection
+        # pool is a hash of connection arrays, instead of a simple array like
+        # most connection pools
+        # Stores data concerning pools, like current size, last fetched
+        # 
+        # Options:
+        # * :pool_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 available 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
+        def initialize(options={})
+          options[:never_block] ||= true
+          @pools = {}
+          @pool_data = {}
+          @pool_size = (options[:pool_size] || 5)
+          @never_block = (options[:never_block])
+          @inactivity_timeout = (options[:inactivity_timeout].to_i)
+          @pool_timeout = (options[:pool_timeout] || 0.5) 
+        end
+        
+        # A fiber safe mutex
+        def _fiber_mutex
+          @fibered_mutex ||= EM::Synchrony::Thread::Mutex.new
+        end
+        
+        # Returns a pool for the associated url
+        def available_pools(url)
+          _fiber_mutex.synchronize do
+            add_connection(url) if add_connection?(url)
+            @pools[url]
+          end
+        end
+        
+        def add_connection?(url)
+          (@pool_data[url].nil? || (@pools[url].length == 0 && (@pool_data[url][:current_size] < @pool_size)))
+        end
+        
+        def add_connection(url) 
+          AWS.config.logger.info "Adding AWS connection to #{url}"
+          add_connection_data(url)
+          @pools[url] ||= []
+          @pools[url] << new_connection(url)         
+          @pools[url]
+        end
+        
+        def add_connection_data(url)
+          @pool_data[url] ||= {:current_size => 0} 
+          @pool_data[url][:current_size] += 1 
+        end
+        
+        def new_connection(url)
+          EM::HttpRequest.new(url, :inactivity_timeout => @inactivity_timeout)
+        end
+        
+        # Run the block on the retrieved connection, then return the connection
+        # back to the pool.
+        def run(url, &block)
+          connection = santize_connection(fetch_connection(url))
+          block.call(connection)
+        ensure
+          return_connection(url,connection) 
+        end
+        
+        # Fetch an available connection or raise an error
+        def fetch_connection(url)         
+          connection = nil
+          alarm = (Time.now + @pool_timeout)       
+          # block until we get an available connection or Timeout::Error     
+          while connection.nil?
+            if alarm <= Time.now
+              message = "Could not fetch a free connection in time. Consider increasing your connection pool for em_aws or setting :never_block to true."
+              AWS.config.logger.error message
+              raise Timeout::Error, message
+            end
+            connection = available_pools(url).shift
+            if connection.nil? && (@never_block)
+              AWS.config.logger.info "Adding AWS connection to #{url} for never_block, will not be returned to pool."
+              connection = new_connection(url)
+            end
+          end
+          connection    
+        end
+        
+        # Make sure we have a good connection.
+        def santize_connection(connection)
+          if connection.conn && connection.conn.error?
+            AWS.config.logger.info "Reconnecting to AWS: #{EventMachine::report_connection_error_status(connection.conn.instance_variable_get(:@signature))}"
+            connection.conn.close_connection
+            connection.instance_variable_set(:@deferred, true)
+          end
+          connection
+        end
+        
+        # Return connections to pool if allowed, otherwise closes connection
+        def return_connection(url,connection)
+          _fiber_mutex.synchronize do
+            if (@pools[url].nil? || (@pools[url].length == @pool_size))
+              connection.conn.close_connection if connection.conn
+            else
+              @pools[url] << connection 
+            end
+            @pools[url]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/core/http/em_http_handler.rb

@@ -3,7 +3,6 @@ require "em-synchrony"
 require "em-synchrony/em-http"
 require 'em-synchrony/thread'
 module AWS
-  
   module Core
     module Http
       
@@ -17,18 +16,19 @@ module AWS
       # require 'aws-sdk'
       # require 'aws/core/http/em_http_handler'
       # AWS.config(
-      # :http_handler => AWS::Http::EMHttpHandler.new(
-      # :proxy => {:host => "http://myproxy.com",:port => 80}
-      # )
-      # )
-      #
+      #   :http_handler => AWS::Http::EMHttpHandler.new(
+      #   :proxy => {:host => "http://myproxy.com",
+      #   :port => 80,
+      #   :pool_size => 20, # not set by default which disables connection pooling
+      #   :async => false # if set to true all requests are handle asynchronously and initially return nil
+      #   }))
       class EMHttpHandler
-        # @return [Hash] The default options to send to EM-Synchrony on each
-        # request.
+        
+        # @return [Hash] The default options to send to EM-Synchrony on each request.
         attr_reader :default_request_options
-             
+        attr_accessor :status_0_retries  
+        
         # Constructs a new HTTP handler using EM-Synchrony.
-        #
         # @param [Hash] options Default options to send to EM-Synchrony on
         # each request. These options will be sent to +get+, +post+,
         # +head+, +put+, or +delete+ when a request is made. Note
@@ -36,12 +36,48 @@ module AWS
         # ignored. If you need to set the CA file, you should use the
         # +:ssl_ca_file+ option to {AWS.config} or
         # {AWS::Configuration} instead.
-        # Defaults pool_size to 5
         def initialize options = {}
-          #puts "Using EM-Synchrony for AWS requests"
           @default_request_options = options
+          @pool = EMConnectionPool.new(options) if options[:pool_size].to_i > 0
+          @status_0_retries = 2 # set to 0 for no retries
+        end 
+    
+        def handle(request,response,&read_block)
+          if EM::reactor_running? 
+            process_request(request,response,&read_block)    
+          else
+            EM.synchrony do
+              process_request(request,response,&read_block)
+              EM.stop
+            end
+          end
+        end
+        
+        # If the request option :async are set to true that request will  handled 
+        # asynchronously returning nil initially and processing in the background 
+        # managed by EM-Synchrony. If the client option :async all requests will 
+        # be handled asynchronously.
+        # EX:
+        #     EM.synchrony do
+        #       s3 = AWS::S3.new
+        #       s3.obj.write('test', :async => true) => nil
+        #       EM::Synchrony.sleep(2)
+        #       s3.obj.read => # 'test'
+        #       EM.stop
+        #     end
+        def handle_async(request,response,handle,&read_block)
+          if EM::reactor_running? 
+            process_request(request,response,true,&read_block)    
+          else
+            EM.synchrony do
+              process_request(request,response,true,&read_block)
+              EM.stop
+            end
+          end
         end
         
+        private
+        
         def fetch_url(request)
           url = nil
           if request.use_ssl?
@@ -53,15 +89,10 @@ module AWS
         end
                    
         def fetch_headers(request)
-          # Net::HTTP adds this header for us when the body is
-          # provided, but it messes up signing
           headers = { 'content-type' => '' }
-  
-          # headers must have string values (net http calls .strip on them)
           request.headers.each_pair do |key,value|
             headers[key] = value.to_s
           end
-  
           {:head => headers}
         end
         
@@ -82,51 +113,38 @@ module AWS
           opts
         end
         
-        def request_options(request)
-          fetch_headers(request).
-            merge(fetch_proxy(request)).
-            merge(fetch_ssl(request))
-        end
-        
-        def fetch_response(url,method,opts={})
-          return EM::HttpRequest.new("#{url}").send(method, opts)     
-        end
-    
-        def handle(request,response)
-          if EM::reactor_running? 
-            handle_it(request, response)    
-          else
-            EM.synchrony do
-              handle_it(request, response)
-              EM.stop
-            end
-          end
-        end
-                
-        def handle_it(request, response)
-          #puts "Using EM!!!!"
-          # get, post, put, delete, head
-          method = request.http_method.downcase.to_sym  
-          opts = default_request_options.merge(request_options(request))  
+        def fetch_request_options(request,method)
+          opts = default_request_options.
+            merge(fetch_headers(request).
+              merge(fetch_proxy(request)).
+              merge(fetch_ssl(request)))  
           if (method == :get)
             opts[:query] = request.body
           else
             opts[:body] = request.body
           end
-          url = fetch_url(request)
-          begin
-            http_response = fetch_response(url,method,opts)                  
-            response.status = http_response.response_header.status.to_i
-            response.headers = to_aws_headers(http_response.response_header.raw.to_hash)
-            response.body = http_response.response if response.status < 300
-          rescue *AWS::Core::Http::NetHttpHandler::NETWORK_ERRORS
-            response.network_error = true  
+          opts
+        end
+        
+        def fetch_response(url,method,opts={},&read_block)
+          if @pool
+            @pool.run(url) do |connection|
+              req = connection.send(method, {:keepalive => true}.merge(opts))
+              req.stream &read_block if block_given?
+              return  EM::Synchrony.sync req unless opts[:async]
+            end
+          else
+            req = EM::HttpRequest.new(url).send(method,opts)
+            req.stream &read_block if block_given?
+            return  EM::Synchrony.sync req unless opts[:async]
           end
+          nil
         end
         
         # AWS needs all headers downcased, and for some reason x-amz-expiration and
         # x-amz-restore need to be arrays
-        def to_aws_headers(response_headers)
+        def fetch_response_headers(response)
+          response_headers = response.response_header.raw.to_hash
           aws_headers = {}
           response_headers.each_pair do  |k,v|
             key = k.downcase
@@ -138,6 +156,35 @@ module AWS
           end
           response_headers.merge(aws_headers)
         end
+        
+        # Builds and attempts the request. Occasionally under load em-http-request
+        # returns a status of 0 with nil for header and body, in such situations
+        # we retry as many times as status_0_retries is set. If our retries exceed
+        # status_0_retries we assume there is a network error
+        def process_request(request,response,async=false,retries=0,&read_block)      
+          method = "a#{request.http_method}".downcase.to_sym  # aget, apost, aput, adelete, ahead
+          opts = fetch_request_options(request,method)
+          opts[:async] = (async || opts[:async])
+          url = fetch_url(request)
+          begin
+            http_response = fetch_response(url,method,opts,&read_block) 
+            unless opts[:async]
+               response.status = http_response.response_header.status.to_i
+              if response.status == 0
+                if retries <= status_0_retries.to_i
+                  process_request(request,response,(retries + 1),&read_block)
+                else
+                  response.network_error = true  
+                end
+              else
+                response.headers = fetch_response_headers(http_response)
+                response.body = http_response.response
+              end
+            end
+          rescue *AWS::Core::Http::NetHttpHandler::NETWORK_ERRORS
+            response.network_error = true  
+          end
+        end
       end
     end
   end

data/lib/em_aws.rb

@@ -5,6 +5,8 @@ require 'em-http'
 require 'em-synchrony'
 require 'em-synchrony/em-http'
 require 'aws/core/autoloader'
+require 'aws/core/http/em_connection_pool'
+require 'aws/core/http/em_http_handler'
 
 AWS.eager_autoload! # lazy load isn't thread safe
-module EmAws;end
+module EmAws;end

data/lib/em_aws/version.rb

@@ -1,3 +1,3 @@
 module EmAws
-  VERSION = "0.1.10"
+  VERSION = "0.2.0"
 end

data/spec/em_connection_pool_spec.rb

@@ -0,0 +1,103 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+require 'thread'
+require "em-synchrony"
+require "em-synchrony/em-http"
+require 'spec_helper'
+module AWS 
+  module Core
+    module Http
+      describe EMConnectionPool do
+        before(:each) do
+          @em_connection_pool = EMConnectionPool.new
+        end
+
+        context 'default configuration' do
+          it "should have @pool_size of 5" do
+            @em_connection_pool.instance_variable_get(:@pool_size).should eql(5)
+          end
+    
+          it "should have @inactivity_timeout of 0" do
+            @em_connection_pool.instance_variable_get(:@inactivity_timeout).should eql(0)
+          end
+    
+          it "should have @pool_timeout of 0" do
+            @em_connection_pool.instance_variable_get(:@pool_timeout).should eql(0.5)
+          end
+        end
+        
+        describe '#add_connection?' do
+          it "should be true if @pool_data does not have data for the url"do
+            @em_connection_pool.add_connection?("http://www.testurl123.com/").should be_true 
+          end
+      
+          it "should be true if @pool_data has data but the number of connnections has not reached the pool_size" do
+            @em_connection_pool.instance_variable_set(:@pools,{"http://www.testurl123.com/" => ["connection"]})
+            @em_connection_pool.add_connection?("http://www.testurl123.com/").should be_true 
+          end
+          
+          it "should be false pool has reached pool_size" do
+            @em_connection_pool.instance_variable_set(:@pools,
+              {"http://www.testurl123.com/" => ["connection","connection","connection","connection","connection"]})
+            @em_connection_pool.add_connection?("http://www.testurl123.com/").should be_true 
+          end
+        end
+        
+        describe '#add_connection' do
+          it "should add connections for supplied url"do
+            @em_connection_pool.add_connection("http://www.testurl123.com/") 
+            @em_connection_pool.instance_variable_get(:@pools)["http://www.testurl123.com/"].should_not be_nil
+          end
+        end   
+        
+        describe '#fetch_connection' do
+          it "should raise Timeout::Error if an available is not found in time"do
+            @em_connection_pool.stub(:available_pools).and_return([])
+            @em_connection_pool.instance_variable_set(:@never_block, false)
+            lambda { @em_connection_pool.fetch_connection('http://some_url.com')}.should raise_error(Timeout::Error)
+          end
+        end
+
+        context 'integration test with parallel requests' do
+          # 10 parallel requests
+          
+          it "should work" do             
+            @requests_made = []
+            EM.synchrony do 
+              @em_connection_pool.instance_variable_set(:@never_block, true)
+              fibers = []  
+              10.times do 
+                fibers << Fiber.new do                           
+                @em_connection_pool.run "http://www.testurl123.com/" do |connection|                 
+                  @requests_made << connection.get(:keepalive => true).response_header.status    
+                  end  
+                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
+    
+              @requests_made.length.should eql(10)
+              @em_connection_pool.instance_variable_get(:@pools)["http://www.testurl123.com/"].length.should eql(@em_connection_pool.instance_variable_get(:@pool_size))              
+
+              EM.stop
+            end
+          end          
+        end
+      end
+    end
+  end
+end

data/spec/em_http_handler_spec.rb

@@ -46,17 +46,8 @@ module AWS::Core
         be_an(AWS::Core::Http::EMHttpHandler)
       end
 
-      describe '#initialize' do
-        it 'should set the default request options' do
-          described_class.new(:foo => "BAR").default_request_options.
-            should == { :foo => "BAR" }
-        end
-      end
-
       describe '#handle' do
-
         context 'timeouts' do
-
           it 'should rescue Timeout::Error' do
             handler.stub(:fetch_response).
               and_raise(Timeout::Error)
@@ -71,13 +62,12 @@ module AWS::Core
               should_not raise_error
           end
 
-          it 'should indicate that there was a timeout' do
+          it 'should indicate that there was a network_error' do
             handler.stub(:fetch_response).
               and_raise(Errno::ETIMEDOUT)
             handler.handle(req, resp)
-            resp.timeout?.should be_true
+            resp.network_error?.should be_true
           end
-
         end
 
         context 'default request options' do
@@ -93,19 +83,27 @@ module AWS::Core
           it 'uses the default when the request option is not set' do
             #puts handler.default_request_options
             handler.default_request_options[:private_key_file].should == "blarg"
+          end         
+        end 
+      end
+      describe '#process_request' do
+        context 'too many retries' do
+          it "should have network error" do
+            EM.synchrony do
+              handler.send(:process_request,(req),(resp),3)
+              resp.network_error?.should be_true
+              EM.stop
+            end
           end
-          
         end
-        
       end
       describe '#fetch_proxy' do
         context ':proxy_uri' do
           it 'passes proxy address and port from the request' do
             req.proxy_uri = URI.parse('https://user:pass@proxy.com:443/path?query')
-            handler.fetch_proxy(req)[:proxy][:host].should == 'proxy.com'
-            handler.fetch_proxy(req)[:proxy][:port].should == 443
+            handler.send(:fetch_proxy,(req))[:proxy][:host].should == 'proxy.com'
+            handler.send(:fetch_proxy,(req))[:proxy][:port].should == 443
           end
-
         end
         
         describe '#fetch_ssl' do
@@ -113,12 +111,11 @@ module AWS::Core
             req.use_ssl = true
             req.ssl_verify_peer = true
             req.ssl_ca_file = "something"
-            handler.fetch_ssl(req)[:private_key_file].should == "something"
-            handler.fetch_ssl(req)[:cert_chain_file].should == "something"
+            handler.send(:fetch_ssl,(req))[:private_key_file].should == "something"
+            handler.send(:fetch_ssl,(req))[:cert_chain_file].should == "something"
           end
            
           context 'CA cert path' do
-
             context 'use_ssl? is true' do
 
               before(:each) { req.use_ssl = true }
@@ -131,21 +128,21 @@ module AWS::Core
                 end
 
                 it 'should use the ssl_ca_file attribute of the request' do
-                  handler.fetch_ssl(req)[:private_key_file].should == "foobar.txt"
+                  handler.send(:fetch_ssl,(req))[:private_key_file].should == "foobar.txt"
                 end
                   
                 it 'should use the ssl_ca_file attribute of the request' do
-                  handler.fetch_ssl(req)[:cert_chain_file].should == "foobar.txt"
+                  handler.send(:fetch_ssl,(req))[:cert_chain_file].should == "foobar.txt"
                 end
               end
 
               it 'should not set the ssl_ca_file option without ssl_verify_peer?' do
-                handler.fetch_ssl(req).should_not include(:private_key_file)
+                handler.send(:fetch_ssl,(req)).should_not include(:private_key_file)
               end
             end
 
             it 'should not set the ssl_ca_file option without use_ssl?' do
-              handler.fetch_ssl(req).should_not include(:private_key_file)
+              handler.send(:fetch_ssl,(req)).should_not include(:private_key_file)
             end
           end
         end      

data/spec/spec_helper.rb

@@ -4,14 +4,19 @@ require 'em_aws'
 require 'aws/core/http/em_http_handler'
 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}
-
-
+class StubLogger
+  def method_missing(method, *args)
+    #we don't care
+  end
+end
+AWS.config(:logger => StubLogger.new)
 RSpec.configure do |config|
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: em_aws
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-03 00:00:00.000000000 Z
+date: 2013-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -106,10 +106,12 @@ files:
 - README.md
 - Rakefile
 - em_aws.gemspec
+- lib/aws/core/http/em_connection_pool.rb
 - lib/aws/core/http/em_http_handler.rb
 - lib/em_aws.rb
 - lib/em_aws/patches.rb
 - lib/em_aws/version.rb
+- spec/em_connection_pool_spec.rb
 - spec/em_http_handler_spec.rb
 - spec/patches_spec.rb
 - spec/spec_helper.rb
@@ -138,6 +140,7 @@ signing_key:
 specification_version: 3
 summary: Adds EM-Synchrony support to AWS-SDK gem
 test_files:
+- spec/em_connection_pool_spec.rb
 - spec/em_http_handler_spec.rb
 - spec/patches_spec.rb
 - spec/spec_helper.rb