happening 0.0.2 → 0.0.3

data/README.md

@@ -34,9 +34,11 @@ The above examples are a bit useless, as you never get any content back.
 You need to specify a callback that interacts with the http response:
 
     EM.run do
-      on_success = Proc.new {|http| puts "the response is: #{http.response}"; EM.stop }
       item = Happening::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
-      item.get # authenticated download
+      item.get do |response|
+        puts "the response content is: #{response.response}"
+        EM.stop
+      end
     end
     
 This will enqueue your download and run it in the EventMachine event loop.
@@ -44,13 +46,17 @@ This will enqueue your download and run it in the EventMachine event loop.
 You can also react to errors:
 
     EM.run do
-      on_error = Proc.new {|http| puts "An error occured: #{http.response_header.status}"; EM.stop }
-      on_success = Proc.new {|http| puts "the response is: #{http.response}"; EM.stop }
+      on_error = Proc.new {|response| puts "An error occured: #{response.response_header.status}"; EM.stop }
       item = Happening::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
-      item.get
+      item.get(:on_error => on_error) do |response|
+        puts "the response content is: #{response.response}" 
+        EM.stop
+      end
     end
-    
-Downloading many files would look like this:
+
+If you don't supply an error handler yourself, Happening will be default raise an Exception.
+
+Downloading many files could look like this:
 
     EM.run do
       count = 100
@@ -59,7 +65,7 @@ Downloading many files would look like this:
       
       count.times do |i|
         item = Happening::S3::Item.new('bucket', "item_#{i}", :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
-        item.get
+        item.get(:on_success => on_success, :on_error => on_error)
       end
     end
     
@@ -70,9 +76,10 @@ Happening supports the simple S3 PUT upload:
   
     EM.run do
       on_error = Proc.new {|http| puts "An error occured: #{http.response_header.status}"; EM.stop }
-      on_success = Proc.new {|http| puts "Upload finished!"; EM.stop }
-      item = Happening::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
-      item.put( File.read('/etc/passwd') )
+      item = Happening::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret', :on_success => on_success, :on_error => on_error)
+      item.put( File.read('/etc/passwd'), :on_error => on_error ) do |response|
+        puts "Upload finished!"; EM.stop 
+      end
     end
     
 Setting permissions looks like this:
@@ -81,7 +88,7 @@ Setting permissions looks like this:
       on_error = Proc.new {|http| puts "An error occured: #{http.response_header.status}"; EM.stop }
       on_success = Proc.new {|http| puts "the response is: #{http.response}"; EM.stop }
       item = Happening::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret', :permissions => 'public-write')
-      item.get
+      item.get(:on_success => on_success, :on_error => on_error)
     end
 
 Deleting
@@ -92,7 +99,7 @@ Happening support the simple S3 PUT upload:
     EM.run do
       on_error = Proc.new {|http| puts "An error occured: #{http.response_header.status}"; EM.stop }
       on_success = Proc.new {|http| puts "Deleted!"; EM.stop }
-      item = Happening::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
+      item = Happening::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret', :on_success => on_success, :on_error => on_error)
       item.delete
     end
 

data/lib/s3/item.rb

@@ -12,8 +12,6 @@ module Happening
       def initialize(bucket, aws_id, options = {})
         @options = {
           :timeout => 10,
-          :on_error => nil,
-          :on_success => nil,
           :server => 's3.amazonaws.com',
           :protocol => 'https',
           :aws_access_key_id => nil,
@@ -21,51 +19,38 @@ module Happening
           :retry_count => 4,
           :permissions => 'private'
         }.update(options.symbolize_keys)
-        options.assert_valid_keys(:timeout, :on_success, :on_error, :server, :protocol, :aws_access_key_id, :aws_secret_access_key, :retry_count, :permissions)
+        options.assert_valid_keys(:timeout, :server, :protocol, :aws_access_key_id, :aws_secret_access_key, :retry_count, :permissions)
         @aws_id = aws_id.to_s
         @bucket = bucket.to_s
       
         validate
       end
     
-      def get
+      def get(request_options = {}, &blk)
         headers = needs_to_sign? ? aws.sign("GET", path) : {}
-        Happening::Log.debug "GET #{url}"
-        http = http_class.new(url).get(:timeout => options[:timeout], :head => headers)
-
-        http.errback { error_callback(:get, http) }
-        http.callback { success_callback(:get, http) }
-        nil
+        request_options[:on_success] = blk if blk
+        request_options.update(:headers => headers)
+        Happening::S3::Request.new(:get, url, request_options).execute
       end
       
-      def put(data)
+      def put(data, request_options = {})
         permissions = options[:permissions] != 'private' ? {'x-amz-acl' => options[:permissions] } : {}
         headers = needs_to_sign? ? aws.sign("PUT", path, permissions.update({'url' => path})) : {}
-        Happening::Log.debug "PUT #{url}"
-        http = http_class.new(url).put(:timeout => options[:timeout], :head => headers, :body => data)
-
-        http.errback { error_callback(:put, http) }
-        http.callback { success_callback(:put, http, data) }
-        nil
+        
+        request_options.update(:headers => headers, :data => data)
+        Happening::S3::Request.new(:put, url, request_options).execute
       end
       
-      def delete
+      def delete(request_options = {})
         headers = needs_to_sign? ? aws.sign("DELETE", path, {'url' => path}) : {}
-        Happening::Log.debug "DELETE #{url}"
-        http = http_class.new(url).delete(:timeout => options[:timeout], :head => headers)
-
-        http.errback { error_callback(:delete, http) }
-        http.callback { success_callback(:delete, http) }
-        nil
+        
+        request_options.update(:headers => headers)
+        Happening::S3::Request.new(:delete, url, request_options).execute
       end
     
       def url
         URI::Generic.new(options[:protocol], nil, server, port, nil, path(!dns_bucket?), nil, nil, nil).to_s
       end
-    
-      def http_class
-        EventMachine::HttpRequest
-      end
       
       def server
         dns_bucket? ? "#{bucket}.#{options[:server]}" : options[:server]
@@ -76,89 +61,7 @@ module Happening
       end
     
     protected
-    
-      def error_callback(http_method, http)
-        call_user_error_handler(http)
-      end
-    
-      def success_callback(http_method, http, data=nil)
-        Happening::Log.debug "Response #{http.response_header.status}"
-        case http.response_header.status
-        when 0, 400, 401, 404, 403, 409, 411, 412, 416, 500, 503
-          if should_retry?
-            Happening::Log.debug "retrying after: status #{http.response_header.status rescue ''}"
-            handle_retry(http_method, data)
-          else
-            call_user_error_handler(http)
-          end
-        when 300, 301, 303, 304, 307
-          Happening::Log.info "being redirected_to: #{http.response_header['LOCATION'] rescue ''}"
-          handle_redirect(http_method, http.response_header['LOCATION'], data)
-        else
-          call_user_success_handler(http)
-        end
-      end
-      
-      def call_user_error_handler(http)
-        options[:on_error].call(http) if options[:on_error].respond_to?(:call)
-      end
-      
-      def call_user_success_handler(http)
-        options[:on_success].call(http) if options[:on_success].respond_to?(:call)
-      end
-      
-      def should_retry?
-        options[:retry_count] > 0
-      end
-      
-      def handle_retry(http_method, data)
-        if should_retry?
-          new_request = self.class.new(bucket, aws_id, options.update(:retry_count => options[:retry_count] - 1 ))
-          case http_method
-          when :get
-            new_request.get
-          when :put
-            new_request.put(data)
-          when :delete
-            new_request.delete
-          else
-            raise "unknown http method #{http_method}"
-          end
-        else
-          Happening::Log.info "Re-tried too often - giving up" if Happening.debug?
-        end
-      end
-    
-      def handle_redirect(http_method, location, data)
-        new_server, new_path = extract_location(location)
-
-        new_request = self.class.new(bucket, aws_id, options.update(:server => new_server))
-        case http_method
-        when :get
-          new_request.get
-        when :put
-          new_request.put(data)
-        when :delete
-          new_request.delete
-        else
-          raise "unknown http method #{http_method}"
-        end
-      end
-    
-      def extract_location(location)
-        uri = URI.parse(location)
-        if match = uri.host.match(/\A#{bucket}\.(.*)/)
-          server = match[1]
-          path = uri.path
-        elsif match = uri.path.match(/\A\/#{bucket}\/(.*)/)
-          server = uri.host
-          path = match[1]
-        else
-          raise "being redirected to an not understood place: #{location}"
-        end
-        return server, path.sub(/^\//, '')
-      end
-    
+        
       def needs_to_sign?
         options[:aws_access_key_id].present?
       end

data/lib/s3/request.rb

@@ -0,0 +1,103 @@
+module Happening
+  module S3
+    class Request
+      
+      VALID_HTTP_METHODS = [:get, :put, :delete]
+      
+      attr_accessor :http_method, :url, :options, :response
+      
+      def initialize(http_method, url, options = {})
+        @options = {
+          :timeout => 10,
+          :retry_count => 4,
+          :headers => {},
+          :on_error => nil,
+          :on_success => nil,
+          :data => nil
+        }.update(options)
+        options.assert_valid_keys(:timeout, :on_success, :on_error, :retry_count, :headers, :data)
+        @http_method = http_method
+        @url = url
+        
+        validate
+      end
+      
+      def execute
+        Happening::Log.debug "#{http_method.to_s.upcase} #{url}"
+        @response = http_class.new(url).send(http_method, :timeout => options[:timeout], :head => options[:headers], :body => options[:data])
+
+        @response.errback { error_callback }
+        @response.callback { success_callback }
+        nil
+      end
+      
+      def http_class
+        EventMachine::HttpRequest
+      end
+      
+    protected
+    
+      def validate
+        raise ArgumentError, "#{http_method} is not a valid HTTP method that #{self.class.name} understands." unless VALID_HTTP_METHODS.include?(http_method)
+      end
+      
+      def error_callback
+        Happening::Log.error "Response #{response.response_header.status rescue ''}"
+        if options[:on_error].respond_to?(:call)
+          call_user_error_handler
+        else
+          raise Happening::Error.new("Failed reponse! Status code was #{response.response_header.status rescue ''}")
+        end
+      end
+      
+      def success_callback
+        Happening::Log.debug "Response #{response.response_header.status rescue ''}"
+        case response.response_header.status
+        when 0, 400, 401, 404, 403, 409, 411, 412, 416, 500, 503
+          if should_retry?
+            Happening::Log.debug "retrying after: status #{response.response_header.status rescue ''}"
+            handle_retry
+          else
+            error_callback
+          end
+        when 300, 301, 303, 304, 307
+          Happening::Log.info "being redirected_to: #{response.response_header['LOCATION'] rescue ''}"
+          handle_redirect
+        else
+          call_user_success_handler
+        end
+      end
+      
+      def call_user_success_handler
+        options[:on_success].call(response) if options[:on_success].respond_to?(:call)
+      end
+      
+      def call_user_error_handler
+        options[:on_error].call(response) if options[:on_error].respond_to?(:call)
+      end
+      
+      def should_retry?
+        options[:retry_count] > 0
+      end
+      
+      
+      def handle_retry
+        if should_retry?
+          new_request = self.class.new(http_method, url, options.update(:retry_count => options[:retry_count] - 1 ))
+          new_request.execute
+        else
+          Happening::Log.info "Re-tried too often - giving up" if Happening.debug?
+        end
+      end
+      
+      def handle_redirect
+        new_location = response.response_header['LOCATION'] rescue ''
+        raise "Could not find the location to redirect to, empty location header?" if new_location.blank?
+
+        new_request = self.class.new(http_method, new_location, options)
+        new_request.execute
+      end
+    
+    end
+  end
+end

data/test/s3/item_test.rb

@@ -68,9 +68,31 @@ class ItemTest < Test::Unit::TestCase
         called = false
         data = nil
         on_success = Proc.new {|http| called = true, data = http.response}
-        @item = Happening::S3::Item.new('bucket', 'the-key', :on_success => on_success)
+        @item = Happening::S3::Item.new('bucket', 'the-key')
         run_in_em_loop do
-          @item.get
+          @item.get(:on_success => on_success)
+          
+          EM.add_timer(1) {
+            assert called
+            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :get, {})
+            assert_equal "data-here\n", data
+            EM.stop_event_loop
+          }
+          
+        end
+      end
+      
+      should "support direct blocks" do
+        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :get, {}, fake_response("data-here"))
+        
+        called = false
+        data = nil
+        @item = Happening::S3::Item.new('bucket', 'the-key')
+        run_in_em_loop do
+          @item.get do |http| 
+            called = true
+            data = http.response
+          end
           
           EM.add_timer(1) {
             assert called
@@ -104,7 +126,7 @@ class ItemTest < Test::Unit::TestCase
 
         @item = Happening::S3::Item.new('bucket', 'the-key')
         run_in_em_loop do
-          @item.get
+          @item.get(:on_error => Proc.new{} ) #ignore error
 
           EM.add_timer(1) {
             EM.stop_event_loop
@@ -191,7 +213,7 @@ class ItemTest < Test::Unit::TestCase
 
         @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123')
         run_in_em_loop do
-          @item.delete
+          @item.delete(:on_error => Proc.new{} ) #ignore error
 
           EM.add_timer(1) {
             EM.stop_event_loop
@@ -289,7 +311,7 @@ class ItemTest < Test::Unit::TestCase
 
         @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123')
         run_in_em_loop do
-          @item.put('content')
+          @item.put('content', :on_error => Proc.new{} )
 
           EM.add_timer(1) {
             EM.stop_event_loop
@@ -311,9 +333,9 @@ class ItemTest < Test::Unit::TestCase
        called = false
        on_error = Proc.new {|http| called = true}
 
-        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123', :retry_count => 1, :on_error => on_error)
+        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123')
         run_in_em_loop do
-          @item.put('content')
+          @item.put('content', :on_error => on_error, :retry_count => 1)
 
           EM.add_timer(1) {
             EM.stop_event_loop

data/test/s3/request_test.rb

@@ -0,0 +1,95 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class ItemTest < Test::Unit::TestCase
+  context "An Happening::S3::Request instance" do
+    
+    setup do
+      Happening::Log.level = Logger::DEBUG
+      @response_stub = stub()
+      @response_stub.stubs(:errback)
+      @response_stub.stubs(:callback)
+    end
+    
+    context "validation" do
+      should "check HTTP method" do
+        assert_raise(ArgumentError) do
+          Happening::S3::Request.new(:foo, 'https://www.example.com')
+        end
+        
+        assert_nothing_raised do
+          Happening::S3::Request.new(:get, 'https://www.example.com')
+        end
+      end
+      
+      should "check the options" do
+        assert_raise(ArgumentError) do
+          Happening::S3::Request.new(:get, 'https://www.example.com', {:foo => :bar})
+        end
+        
+        assert_nothing_raised do
+          Happening::S3::Request.new(:get, 'https://www.example.com', {:timeout => 4})
+        end
+      end
+    end
+    
+    context "when executing" do
+      should "have no response before executing" do
+        assert_nil Happening::S3::Request.new(:get, 'https://www.example.com').response
+      end
+      
+      should "call em-http-request" do
+        request = mock(:get => @response_stub)
+        EventMachine::MockHttpRequest.expects(:new).with('https://www.example.com').returns(request)
+        Happening::S3::Request.new(:get, 'https://www.example.com').execute
+      end
+      
+      should "pass the given headers and options" do
+        request = mock('em-http-request')
+        request.expects(:get).with(:timeout => 10, :head => {'a' => 'b'}, :body => nil).returns(@response_stub)
+        EventMachine::MockHttpRequest.expects(:new).with('https://www.example.com').returns(request)
+        Happening::S3::Request.new(:get, 'https://www.example.com', :headers => {'a' => 'b'}).execute
+      end
+      
+      should "post any given data" do
+        request = mock('em-http-request')
+        request.expects(:put).with(:timeout => 10, :body => 'the-data', :head => {}).returns(@response_stub)
+        EventMachine::MockHttpRequest.expects(:new).with('https://www.example.com').returns(request)
+        Happening::S3::Request.new(:put, 'https://www.example.com', :data => 'the-data').execute
+      end
+      
+      context "when handling errors" do
+        should "call the user error handler" do
+          EventMachine::MockHttpRequest.register('http://www.example.com:80/', :get, {}, error_response(400))
+
+          called = false
+          on_error = Proc.new {|http| called = true}
+
+          run_in_em_loop do
+            Happening::S3::Request.new(:get, 'http://www.example.com/', :on_error => on_error).execute
+
+            EM.add_timer(1) {
+              EM.stop_event_loop
+              assert called
+              assert_equal 5, EventMachine::MockHttpRequest.count('http://www.example.com:80/', :get, {})
+            }
+
+          end
+        end
+        
+        should "use a default error handler if there is no user handler" do
+          EventMachine::MockHttpRequest.register('http://www.example.com:80/', :get, {}, error_response(400))
+
+          assert_raise(Happening::Error) do
+            run_in_em_loop do
+              Happening::S3::Request.new(:get, 'http://www.example.com/').execute
+            end
+          end
+          EM.stop_event_loop if EM.reactor_running?
+        end
+        
+      end
+      
+    end
+        
+  end
+end

data/test/test_helper.rb

@@ -33,7 +33,7 @@ end
 
 module Happening
   module S3
-    class Item
+    class Request
       def http_class
         EventMachine::MockHttpRequest
       end
@@ -91,21 +91,4 @@ module EventMachine
   class MockHttpRequest
     @@pass_through_requests = false
   end
-end
-#     def send_request(&blk)
-#       # raise @options.inspect
-#       query = "#{@uri.scheme}://#{@uri.host}:#{@uri.port}#{encode_query(@uri.path, @options[:query], @uri.query)}"
-#       cache_key = query + @options.to_s
-#       if s = @@registry[cache_key] and fake = s[@method]
-#         @@registry_count[cache_key][@method] += 1
-#         client = FakeHttpClient.new(nil)
-#         client.setup(fake, @uri)
-#         client
-#       elsif @@pass_through_requests
-#         real_send_request
-#       else
-#         raise "this request #{query} for method #{@method} isn't registered, and pass_through_requests is current set to false"
-#       end
-#     end
-#   end
-# end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: happening
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Jonathan Weiss
@@ -47,6 +47,7 @@ files:
 - lib/aws.rb
 - lib/log.rb
 - lib/s3/item.rb
+- lib/s3/request.rb
 has_rdoc: true
 homepage: http://github.com/peritor/happening
 licenses: []
@@ -78,4 +79,5 @@ summary: An EventMachine based S3 client
 test_files: 
 - test/aws_test.rb
 - test/s3/item_test.rb
+- test/s3/request_test.rb
 - test/test_helper.rb