happening 0.0.1

data/LICENSE.txt

@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2010 Peritor GmbH <info@peritor.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */

data/README.md

@@ -0,0 +1,116 @@
+Amazon S3 Ruby library that leverages [EventMachine](http://rubyeventmachine.com/) and [em-http-request](http://github.com/igrigorik/em-http-request).
+
+By using EventMachine Happening does not block on S3 downloads/uploads thus allowing for a higher concurrency.
+
+Happening was developed by [Peritor](http://www.peritor.com) for usage inside Nanite/EventMachine. 
+Alternatives like RightAws block during the HTTP calls thus blocking the Nanite-Agent.
+
+For now it only supports GET, PUT and DELETE operations on S3 items. The PUT operations support S3 ACLs/permissions.
+Happening will handle redirects and retries on errors by default.
+
+Installation
+============
+
+    gem install happening
+
+Usage
+=============
+
+    require 'happening'
+    
+    EM.run do
+      item = Happening::S3::Item.new('bucket', 'item_id')
+      item.get # non-authenticated download, works only for public-read content
+    
+      item = Happening::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
+      item.get # authenticated download
+      
+      item.put("The new content")
+      
+      item.delete
+    end
+    
+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
+    end
+    
+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 }
+      item = Happening::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
+      item.get
+    end
+    
+Downloading many files would look like this:
+
+    EM.run do
+      count = 100
+      on_error = Proc.new {|http| puts "An error occured: #{http.response_header.status}"; EM.stop if count <= 0}
+      on_success = Proc.new {|http| puts "the response is: #{http.response}"; EM.stop if count <= 0}
+      
+      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
+      end
+    end
+    
+Upload
+=============
+
+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') )
+    end
+    
+Setting permissions looks like this:
+
+    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 }
+      item = Happening::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret', :permissions => 'public-write')
+      item.get
+    end
+
+Deleting
+=============
+
+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.delete
+    end
+
+Amazon returns no content on delete, so having a success handler is usually not needed for delete operations.
+
+Credits
+=============
+
+The AWS signing and canonical request description is based on [RightAws](http://github.com/rightscale/right_aws).
+    
+    
+License
+=============
+
+Happening is licensed under the OpenBSD / two-clause BSD license, modeled after the ISC license. See LICENSE.txt
+
+
+About
+=============
+
+Happening was written by [Jonathan Weiss](http://twitter.com/jweiss) for [Peritor](http://www.peritor.com).

data/lib/aws.rb

@@ -0,0 +1,59 @@
+module Happening
+  class AWS
+    
+    AMAZON_HEADER_PREFIX   = 'x-amz-'
+    AMAZON_METADATA_PREFIX = 'x-amz-meta-'
+    DIGEST = OpenSSL::Digest.new('sha1')
+    
+    attr_accessor :aws_access_key_id, :aws_secret_access_key
+    
+    def initialize(aws_access_key_id, aws_secret_access_key)
+      @aws_access_key_id = aws_access_key_id
+      @aws_secret_access_key = aws_secret_access_key
+      raise ArgumentError, "need AWS Access Key Id and AWS Secret Key" unless aws_access_key_id.present? && aws_secret_access_key.present?
+    end
+    
+    def sign(method, path, headers={})
+      headers = {
+        'date' => Time.now.httpdate
+      }.update(headers)
+      
+      request_description = canonical_request_description(method, path, headers)
+      headers.update("Authorization" => "AWS #{aws_access_key_id}:#{generate_signature(request_description)}")
+    end
+    
+  protected
+        
+    def generate_signature(request_description)
+      Base64.encode64(OpenSSL::HMAC.digest(DIGEST, aws_secret_access_key, request_description)).strip
+    end
+    
+    def canonical_request_description(method, path, headers = {}, expires = nil)
+      s3_attributes = {}
+      headers.each do |key, value|
+        key = key.downcase
+        s3_attributes[key] = value.to_s.strip if key.match(/^#{AMAZON_HEADER_PREFIX}|^content-md5$|^content-type$|^date$/o)
+      end
+      s3_attributes['content-type'] ||= ''
+      s3_attributes['content-md5']  ||= ''
+      s3_attributes['date'] = '' if s3_attributes.has_key?('x-amz-date')
+      s3_attributes['date'] = expires if expires
+
+      description = "#{method}\n"
+      s3_attributes.sort { |a, b| a[0] <=> b[0] }.each do |key, value|
+        description << (key.match(/^#{AMAZON_HEADER_PREFIX}/o) ? "#{key}:#{value}\n" : "#{value}\n")
+      end
+      
+      # ignore all parameters by default
+      description << path.gsub(/\?.*$/, '')
+      
+      # handle amazon parameters
+      description << '?acl'      if path[/[&?]acl($|&|=)/]
+      description << '?torrent'  if path[/[&?]torrent($|&|=)/]
+      description << '?location' if path[/[&?]location($|&|=)/]
+      description << '?logging'  if path[/[&?]logging($|&|=)/]
+      description
+    end
+    
+  end
+end

data/lib/log.rb

@@ -0,0 +1,40 @@
+module Happening
+  class Log
+    
+    @@logger = Logger.new(STDOUT)
+    @@logger.level = Logger::ERROR
+    
+    def self.logger=(log)
+      @@logger = log
+    end
+    
+    def self.logger
+      @@logger
+    end
+    
+    def self.level=(lev)
+      logger.level = lev
+    end
+    
+    def self.level
+      logger.level
+    end
+    
+    def self.debug(msg)
+      logger.debug(msg)
+    end
+    
+    def self.info(msg)
+      logger.info(msg)
+    end
+    
+    def self.warn(msg)
+      logger.warn(msg)
+    end
+    
+    def self.error(msg)
+      logger.error(msg)
+    end
+    
+  end
+end

data/lib/s3/item.rb

@@ -0,0 +1,196 @@
+require 'uri'
+require 'cgi'
+
+module Happening
+  module S3
+    class Item
+    
+      REQUIRED_FIELDS = [:server]
+    
+      attr_accessor :bucket, :aws_id, :options
+    
+      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,
+          :aws_secret_access_key => nil,
+          :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)
+        @aws_id = aws_id.to_s
+        @bucket = bucket.to_s
+      
+        validate
+      end
+    
+      def get
+        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
+      end
+      
+      def put(data)
+        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
+      end
+      
+      def delete
+        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
+      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]
+      end
+      
+      def path(with_bucket=true)
+        with_bucket ? "/#{bucket}/#{CGI::escape(aws_id)}" : "/#{CGI::escape(aws_id)}"
+      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
+    
+      def dns_bucket?
+        # http://docs.amazonwebservices.com/AmazonS3/2006-03-01/index.html?BucketRestrictions.html
+        return false unless (3..63) === bucket.size
+        bucket.split('.').each do |component|
+          return false unless component[/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/]
+        end
+        true
+      end
+    
+      def port
+        (options[:protocol].to_s == 'https') ? 443 : 80
+      end
+    
+      def validate
+        raise ArgumentError, "need a bucket name" unless bucket.present?
+        raise ArgumentError, "need a AWS Key" unless aws_id.present?
+      
+        REQUIRED_FIELDS.each do |field|
+          raise ArgumentError, "need field #{field}" unless options[field].present?
+        end
+      
+        raise ArgumentError, "unknown protocoll #{options[:protocol]}" unless ['http', 'https'].include?(options[:protocol])
+      end
+      
+      def aws
+        @aws ||= Happening::AWS.new(options[:aws_access_key_id], options[:aws_secret_access_key])
+      end
+    
+    end
+  end
+end

data/test/aws_test.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+class ItemTest < Test::Unit::TestCase
+  context "An Happening::AWS instance" do
+    
+    setup do
+      @aws = Happening::AWS.new('the-aws-access-key', 'the-aws-secret-key')
+    end
+    
+    context "when constructing" do
+      should "require Access Key and Secret Key" do
+        assert_raise(ArgumentError) do
+          Happening::AWS.new(nil, nil)
+        end
+        
+        assert_raise(ArgumentError) do
+          Happening::AWS.new('', '')
+        end
+        
+        assert_nothing_raised do
+          Happening::AWS.new('abc', 'abc')
+        end
+      end
+    end
+    
+    context "when signing parameters" do
+      should "return a header hash" do
+        assert_not_nil @aws.sign("GET", '/')['Authorization']
+      end
+      
+      should "include the current date" do
+        assert_not_nil @aws.sign("GET", '/')['date']
+      end
+      
+      should "keep given headers" do
+        assert_equal 'bar', @aws.sign("GET", '/', {'foo' => 'bar'})['foo']
+      end
+    end
+    
+  end
+end

data/test/s3/item_test.rb

@@ -0,0 +1,333 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class ItemTest < Test::Unit::TestCase
+  context "An Happening::S3::Item instance" do
+    
+    setup do
+      Happening::Log.level = Logger::ERROR
+      @item = Happening::S3::Item.new('the-bucket', 'the-key', :aws_access_key_id => '123', :aws_secret_access_key => 'secret', :server => '127.0.0.1')
+      
+      @time = "Thu, 25 Feb 2010 10:00:00 GMT"
+      Time.stubs(:now).returns(stub(:httpdate => @time, :to_i => 99, :usec => 88))
+    end
+    
+    context "validation" do
+      should "require a bucket and a key" do
+        assert_raise(ArgumentError) do
+          item = Happening::S3::Item.new()
+        end
+        
+        assert_raise(ArgumentError) do
+          item = Happening::S3::Item.new('the-key')
+        end
+        
+        assert_nothing_raised(ArgumentError) do
+          item = Happening::S3::Item.new('the-bucket', 'the-key')
+        end
+        
+      end
+      
+      should "not allow unknown options" do
+        assert_raise(ArgumentError) do
+          item = Happening::S3::Item.new('the-bucket', 'the-key', :aws_access_key_id => '123', :aws_secret_access_key => 'secret', :lala => 'lulul')
+        end
+      end
+      
+      should "check valid protocol" do
+        assert_raise(ArgumentError) do
+          item = Happening::S3::Item.new('the-bucket', 'the-key', :aws_access_key_id => '123', :aws_secret_access_key => 'secret', :protocol => 'lulul')
+        end
+        
+        assert_nothing_raised do
+          item = Happening::S3::Item.new('the-bucket', 'the-key', :aws_access_key_id => '123', :aws_secret_access_key => 'secret', :protocol => 'http')
+        end
+        
+        assert_nothing_raised do
+          item = Happening::S3::Item.new('the-bucket', 'the-key', :aws_access_key_id => '123', :aws_secret_access_key => 'secret', :protocol => 'https')
+        end
+      end
+    end
+    
+    context "when building the item url" do
+      should "build the full path out of the server, bucket, and key" do
+        @item = Happening::S3::Item.new('the-bucketissoooooooooooooooooooooooooooooooooooooolonggggggggggggggggggggggggggggggggggg', 'the-key', :aws_access_key_id => '123', :aws_secret_access_key => 'secret', :server => '127.0.0.1')
+        assert_equal "https://127.0.0.1:443/the-bucketissoooooooooooooooooooooooooooooooooooooolonggggggggggggggggggggggggggggggggggg/the-key", @item.url
+      end
+      
+      should "use the DNS bucket name where possible" do
+        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => '123', :aws_secret_access_key => 'secret')
+        assert_equal "https://bucket.s3.amazonaws.com:443/the-key", @item.url
+      end
+    end
+    
+    context "when getting an item" do
+      
+      should "call the on success callback" do
+        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :get, {}, fake_response("data-here"))
+        
+        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)
+        run_in_em_loop do
+          @item.get
+          
+          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 "sign requests if AWS credentials are passend" do
+        time = "Thu, 25 Feb 2010 12:06:33 GMT"
+        Time.stubs(:now).returns(mock(:httpdate => time))
+        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :get, {"Authorization"=>"AWS abc:3OEcVbE//maUUmqh3A5ETEcr9TE=", 'date' => time}, fake_response("data-here"))
+        
+        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123')
+        run_in_em_loop do
+          @item.get
+          
+          EM.add_timer(1) {
+            EM.stop_event_loop
+            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :get, {"Authorization"=>"AWS abc:3OEcVbE//maUUmqh3A5ETEcr9TE=", 'date' => time})
+          }
+          
+        end
+      end
+      
+      should "retry on error" do
+        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :get, {}, error_response(400))
+
+        @item = Happening::S3::Item.new('bucket', 'the-key')
+        run_in_em_loop do
+          @item.get
+
+          EM.add_timer(1) {
+            EM.stop_event_loop
+            assert_equal 5, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :get, {})
+          }
+
+        end
+      end
+      
+      should "handle re-direct" do
+        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :get, {}, redirect_response('https://bucket.s3-external-3.amazonaws.com/the-key'))
+        EventMachine::MockHttpRequest.register('https://bucket.s3-external-3.amazonaws.com:443/the-key', :get, {}, fake_response('hy there'))
+
+        @item = Happening::S3::Item.new('bucket', 'the-key')
+        run_in_em_loop do
+          @item.get
+
+          EM.add_timer(1) {
+            EM.stop_event_loop
+            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :get, {})
+            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3-external-3.amazonaws.com:443/the-key', :get, {})
+          }
+
+        end
+      end
+    end
+    
+    context "when deleting an item" do
+      should "send a DELETE to the items location" do
+        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :delete, {
+           "Authorization"=>"AWS abc:nvkrlq4wor1qbFXZh6rHnAbiRjk=", 
+           'date' => @time, 
+           'url' => "/bucket/the-key"}, fake_response("data-here"))
+
+        @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
+
+          EM.add_timer(1) {
+            EM.stop_event_loop
+            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :delete, {
+              "Authorization"=>"AWS abc:nvkrlq4wor1qbFXZh6rHnAbiRjk=", 
+              'date' => @time, 
+              'url' => "/bucket/the-key"})
+          }
+
+        end
+      end
+      
+      should "handle re-direct" do
+        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :delete, {
+           "Authorization"=>"AWS abc:nvkrlq4wor1qbFXZh6rHnAbiRjk=", 
+           'date' => @time, 
+           'url' => "/bucket/the-key"}, redirect_response('https://bucket.s3-external-3.amazonaws.com/the-key'))
+        EventMachine::MockHttpRequest.register('https://bucket.s3-external-3.amazonaws.com:443/the-key', :delete, {
+           "Authorization"=>"AWS abc:nvkrlq4wor1qbFXZh6rHnAbiRjk=", 
+           'date' => @time, 
+           'url' => "/bucket/the-key"}, fake_response("success!"))
+
+        @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
+
+          EM.add_timer(1) {
+            EM.stop_event_loop
+            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :delete, {
+              "Authorization"=>"AWS abc:nvkrlq4wor1qbFXZh6rHnAbiRjk=", 
+              'date' => @time, 
+              'url' => "/bucket/the-key"})
+            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3-external-3.amazonaws.com:443/the-key', :delete, {
+              "Authorization"=>"AWS abc:nvkrlq4wor1qbFXZh6rHnAbiRjk=", 
+              'date' => @time, 
+              'url' => "/bucket/the-key"})
+          }
+
+        end
+      end
+      
+      should "handle retry" do
+        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :delete, {
+           "Authorization"=>"AWS abc:nvkrlq4wor1qbFXZh6rHnAbiRjk=", 
+           'date' => @time, 
+           'url' => "/bucket/the-key"}, error_response(400))
+
+        @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
+
+          EM.add_timer(1) {
+            EM.stop_event_loop
+            assert_equal 5, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :delete, {
+              "Authorization"=>"AWS abc:nvkrlq4wor1qbFXZh6rHnAbiRjk=", 
+              'date' => @time, 
+              'url' => "/bucket/the-key"})
+          }
+
+        end
+      end
+    end
+    
+    context "when saving an item" do
+      
+      should "post to the desired location" do
+       EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :put, {
+         "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
+         'date' => @time, 
+         'url' => "/bucket/the-key"}, fake_response("data-here"))
+
+        @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')
+
+          EM.add_timer(1) {
+            EM.stop_event_loop
+            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :put, {
+              "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
+              'date' => @time, 
+              'url' => "/bucket/the-key"})
+          }
+
+        end
+      end
+      
+      should "set the desired permissions" do
+       EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :put, {
+         "Authorization"=>"AWS abc:cqkfX+nC7WIkYD+yWaUFuoRuePA=", 
+         'date' => @time, 
+         'url' => "/bucket/the-key",
+         "x-amz-acl" => 'public-read'}, fake_response("data-here"))
+
+        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123' , :permissions => 'public-read')
+        run_in_em_loop do
+          @item.put('content')
+
+          EM.add_timer(1) {
+            EM.stop_event_loop
+            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :put, {
+              "Authorization"=>"AWS abc:cqkfX+nC7WIkYD+yWaUFuoRuePA=", 
+              'date' => @time, 
+              'url' => "/bucket/the-key",
+              'x-amz-acl' => 'public-read'})
+          }
+
+        end
+      end
+      
+      should "re-post to a new location" do
+        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :put, {
+          "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
+          'date' => @time, 
+          'url' => "/bucket/the-key"}, redirect_response('https://bucket.s3-external-3.amazonaws.com/the-key'))
+        EventMachine::MockHttpRequest.register('https://bucket.s3-external-3.amazonaws.com:443/the-key', :put, {
+          "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
+          'date' => @time, 
+          'url' => "/bucket/the-key"}, fake_response('Thanks!')) 
+
+        @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')
+
+          EM.add_timer(1) {
+            EM.stop_event_loop
+            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :put, {
+              "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
+              'date' => @time, 
+              'url' => "/bucket/the-key"})
+            
+            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3-external-3.amazonaws.com:443/the-key', :put, {
+              "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
+              'date' => @time, 
+              'url' => "/bucket/the-key"})
+          }
+
+        end
+      end
+      
+      should "retry on error" do
+       EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :put, {
+         "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
+         'date' => @time, 
+         'url' => "/bucket/the-key"}, error_response(400))
+
+        @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')
+
+          EM.add_timer(1) {
+            EM.stop_event_loop
+            assert_equal 5, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :put, {
+              "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
+              'date' => @time,
+              'url' => "/bucket/the-key"})
+          }
+
+        end
+      end
+      
+      should "call error handler after retry reached" do
+       EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :put, {
+         "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
+         'date' => @time, 
+         'url' => "/bucket/the-key"}, error_response(400))
+
+       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)
+        run_in_em_loop do
+          @item.put('content')
+
+          EM.add_timer(1) {
+            EM.stop_event_loop
+            assert called
+            assert_equal 2, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :put, {
+              "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
+              'date' => @time,
+              'url' => "/bucket/the-key"})
+          }
+
+        end
+      end
+      
+    end
+    
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,111 @@
+require 'rubygems'
+
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+
+$:.unshift(File.dirname(__FILE__) + "/../")
+
+require 'happening'
+
+require 'em-http/mock'
+
+EventMachine.instance_eval do
+  # Switching out EM's defer since it makes tests just a tad more unreliable
+  alias :defer_original :defer
+  def defer
+    yield
+  end
+end unless EM.respond_to?(:defer_original)
+
+class Test::Unit::TestCase
+  def setup
+    EventMachine::MockHttpRequest.reset_counts!
+    EventMachine::MockHttpRequest.reset_registry!
+  end
+  
+  def run_in_em_loop
+    EM.run {
+      yield
+    }
+  end
+end
+
+module Happening
+  module S3
+    class Item
+      def http_class
+        EventMachine::MockHttpRequest
+      end
+    end
+  end
+end
+
+def fake_response(data)
+  <<-HEREDOC
+HTTP/1.0 200 OK
+Date: Mon, 16 Nov 2009 20:39:15 GMT
+Expires: -1
+Cache-Control: private, max-age=0
+Content-Type: text/html; charset=ISO-8859-1
+Set-Cookie: PREF=ID=9454187d21c4a6a6:TM=1258403955:LM=1258403955:S=2-mf1n5oV5yAeT9-; expires=Wed, 16-Nov-2011 20:39:15 GMT; path=/; domain=.google.ca
+Set-Cookie: NID=28=lvxxVdiBQkCetu_WFaUxLyB7qPlHXS5OdAGYTqge_laVlCKVN8VYYeVBh4bNZiK_Oan2gm8oP9GA-FrZfMPC3ZMHeNq37MG2JH8AIW9LYucU8brOeuggMEbLNNXuiWg4; expires=Tue, 18-May-2010 20:39:15 GMT; path=/; domain=.google.ca; HttpOnly
+Server: gws
+X-XSS-Protection: 0
+X-Cache: MISS from .
+Via: 1.0 .:80 (squid)
+Connection: close
+
+#{data}
+HEREDOC
+end
+
+# amazon tells us to upload to another location, e.g. happening-benchmark.s3-external-3.amazonaws.com instead of happening-benchmark.s3.amazonaws.com
+def redirect_response(location)
+    <<-HEREDOC
+HTTP/1.0 301 Moved Permanently
+Date: Mon, 16 Nov 2009 20:39:15 GMT
+Expires: -1
+Cache-Control: private, max-age=0
+Content-Type: text/html; charset=ISO-8859-1
+Via: 1.0 .:80 (squid)
+Connection: close
+Location: #{location}
+
+<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<Error><Code>TemporaryRedirect</Code><Message>Please re-send this request to the specified temporary endpoint. Continue to use the original request endpoint for future requests.</Message><RequestId>137D5486D66095AE</RequestId><Bucket>happening-benchmark</Bucket><HostId>Nyk+Zq9GbtxcspdbKDWyGhsZhyUZquZP55tteYef4QVodsn73HUUad0xrIeD09lF</HostId><Endpoint>#{location}</Endpoint></Error>
+  HEREDOC
+end
+
+def error_response(error_code)
+  <<-HEREDOC
+HTTP/1.0 #{error_code} OK
+Date: Mon, 16 Nov 2009 20:39:15 GMT
+Content-Type: text/html; charset=ISO-8859-1
+Connection: close
+
+<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<Error><Code>TemporaryRedirect</Code><Message>Please re-send this request to the specified temporary endpoint. Continue to use the original request endpoint for future requests.</Message><RequestId>137D5486D66095AE</RequestId><Bucket>happening-benchmark</Bucket><HostId>Nyk+Zq9GbtxcspdbKDWyGhsZhyUZquZP55tteYef4QVodsn73HUUad0xrIeD09lF</HostId><Endpoint>https://s3.amazonaws.com</Endpoint></Error>
+HEREDOC
+end
+
+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

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: happening
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jonathan Weiss
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-26 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: em-http-request
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: An EventMachine based S3 client - using em-http-request
+email: info@peritor.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.md
+files: 
+- LICENSE.txt
+- README.md
+- lib/aws.rb
+- lib/log.rb
+- lib/s3/item.rb
+has_rdoc: true
+homepage: http://github.com/peritor/happening
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: An EventMachine based S3 client
+test_files: 
+- test/aws_test.rb
+- test/s3/item_test.rb
+- test/test_helper.rb