simple_aws 0.0.1b → 0.0.1c

data/README.md

@@ -106,6 +106,7 @@ Implemented APIs
 
 These are the following Amazon APIs that SimpleAWS currently handles:
 
+* S3
 * EC2
 * ELB
 * IAM
@@ -125,7 +126,6 @@ These are the following Amazon APIs that SimpleAWS currently handles:
 Yet to be Implemented
 ---------------------
 
-* S3
 * CloudFront
 
 Currently Out-Of-Scope

data/lib/aws/core/connection.rb

@@ -1,4 +1,5 @@
 require 'httparty'
+require 'httmultiparty'
 require 'openssl'
 
 require 'aws/core/response'
@@ -6,7 +7,7 @@ require 'aws/core/response'
 module AWS
 
   class HTTP
-    include HTTParty
+    include HTTMultiParty
     format :xml
   end
 
@@ -24,7 +25,8 @@ module AWS
         HTTP.send(request.method,
           request.uri,
           :query => request.params,
-          :headers => request.headers
+          :headers => request.headers,
+          :body => request.body
         )
       )
     end

data/lib/aws/core/request.rb

@@ -111,6 +111,13 @@ module AWS
     ##
     attr_reader :headers
 
+    ##
+    # Raw string data to be put in the body of the request.
+    # Body can also be an IO object (something that response to #read) and
+    # if so the request will stream the file to the server.
+    ##
+    attr_accessor :body
+
     ##
     # Set up a new Request for the given +host+ and +path+ using the given
     # http +method+ (:get, :post, :put, :delete).

data/lib/aws/core/response.rb

@@ -146,8 +146,11 @@ module AWS
       end
 
       def value_or_proxy(value)
-        if value.is_a?(Hash) || value.is_a?(Array)
+        case value
+        when Hash
           ResponseProxy.new value
+        when Array
+          value.map {|v| ResponseProxy.new v }
         else
           value
         end
@@ -159,27 +162,36 @@ module AWS
     ##
     attr_reader :body
 
+    ##
+    # HTTP Status code of the response
+    ##
+    attr_reader :code
+
+    ##
+    # Hash of headers found in the response
+    ##
+    attr_reader :headers
+
     def initialize(http_response)
       if !http_response.success?
-        error = parse_error_from http_response.parsed_response
-        raise UnsuccessfulResponse.new(
-          http_response.code,
-          error["Code"],
-          error["Message"]
-        )
+        parse_and_throw_error_from http_response
       end
 
+      @code = http_response.code
       @body = http_response.parsed_response
+      @headers = http_response.headers
 
-      inner = @body[@body.keys.first]
-      response_root =
-        if result_key = inner.keys.find {|k| k =~ /Result$/}
-          inner[result_key]
-        else
-          inner
-        end
+      if @body
+        inner = @body[@body.keys.first]
+        response_root =
+          if result_key = inner.keys.find {|k| k =~ /Result$/}
+            inner[result_key]
+          else
+            inner
+          end
 
-      @request_root = ResponseProxy.new response_root
+        @request_root = ResponseProxy.new response_root
+      end
     end
 
     ##
@@ -216,9 +228,29 @@ module AWS
 
     protected
 
+    def parse_and_throw_error_from(http_response)
+      if http_response.parsed_response
+        error = parse_error_from http_response.parsed_response
+      else
+        error = { "Message" => http_response.response }
+      end
+
+      raise UnsuccessfulResponse.new(
+        http_response.code,
+        error["Code"],
+        error["Message"]
+      )
+    end
+
     def parse_error_from(body)
       if body.has_key? "ErrorResponse"
         body["ErrorResponse"]["Error"]
+      elsif body.has_key? "Error"
+        if body["Error"]["StringToSign"]
+          body["Error"]["Message"] += " String to Sign: #{body["Error"]["StringToSign"].inspect}"
+        end
+
+        body["Error"]
       elsif body.has_key? "Response"
         body["Response"]["Errors"]["Error"]
       else

data/lib/aws/s3.rb

@@ -0,0 +1,127 @@
+require 'aws/api'
+require 'aws/signing/authorization_header'
+
+module AWS
+
+  ##
+  # Amazon's Simple Storage Service
+  #
+  # http://docs.amazonwebservices.com/AmazonS3/latest/API/Welcome.html
+  #
+  # As S3 is much closer to a RESTful service than the other AWS APIs, all
+  # calls through this API are done through the four handled HTTP METHODS:
+  # GET, PUT, DELETE, POST and HEAD. When sending a request, follow exactly what
+  # is described in the AWS API docs in the link above.
+  #
+  # So "GET Service" is
+  #
+  #   s3.get "/"
+  #
+  # When working with a specific bucket, pass in :bucket after the path:
+  #
+  #   s3.get "/", :bucket => "bucket_name"
+  #
+  #   s3.get "/?policy", :bucket => "bucket_name"
+  #
+  # For requests that need extra parameters, use the :params option:
+  #
+  #   s3.get "/object/name", :bucket => "bucket_name", :params => {
+  #     "response-content-disposition" => "attachment"
+  #   }
+  #
+  # Also use params in the cases that AWS asks for form fields, such as
+  # "POST Object".
+  #
+  # A lot of S3 communication happens through request and response headers.
+  # To specify a certian set of headers on the request, use :headers:
+  #
+  #   s3.get "/", :bucket => "bucket_name", :headers => {
+  #     "x-amz-security-token" => "security string"
+  #   }
+  #
+  # Many of the PUT requests require a body of some sort, sometimes XML,
+  # sometimes JSON, and other times the raw file data. Use :body for this
+  # information. :body is expected to be either a String containing the XML or
+  # JSON information, or an object that otherwise response to #read for file
+  # uploads. This API does not build XML or JSON for you right now.
+  #
+  #   s3.put "/object/name.txt", :bucket => "bucket_name", :body => {:file => File.open()}
+  #
+  # As this is a common use case, if you don't have any more parameters to send
+  # with the file being uploaded, just use :file.
+  #
+  #   s3.put "/object/name.txt", :bucket => "bucket_name", :file => File.open()
+  #
+  # This API does ensure that file data is uploaded as efficiently as possible,
+  # streaming file data from disc to AWS without blowing up memory. All files are
+  # uploading using multipart/form-data.
+  #
+  # NOTE: Like the other parts of SimpleAWS, this API does NOT try to make the
+  # AWS API better, but simply provides a cleaner, easy to use API for Ruby.
+  # As such, this API does not offer streaming downloads of file data from S3.
+  # That is up to you to implement at this time, by running a HEAD to get
+  # Content-Length then repeated GETs using the "Range:bytes" header to specify
+  # which parts to download next.
+  #
+  # Raw file data in a response will be available in the #body method on the Response
+  # returned by the method call.
+  ##
+  class S3 < API
+    endpoint "s3"
+    use_https true
+    version "2006-03-01"
+
+    [:get, :post, :put, :delete, :head].each do |method|
+      define_method(method) do |*args|
+        self.call method, *args
+      end
+    end
+
+    def call(method, path, options = {})
+      if options[:bucket]
+        path = path.gsub(/^\//, "/#{options[:bucket]}/")
+      end
+
+      request = AWS::Request.new method, self.uri, path
+
+      (options[:params] || {}).each do |k, v|
+        request.params[k] = v
+      end
+
+      (options[:headers] || {}).each do |k, v|
+        request.headers[k] = v
+      end
+
+      if options[:file]
+        options[:body] = {:file => options[:file]}
+      end
+
+      request.body = options[:body]
+
+      if request.body.is_a?(Hash) && request.body[:file]
+        request.headers["Content-Type"] =
+          "multipart/form-data; boundary=-----------RubyMultipartPost"
+      end
+
+      connection = AWS::Connection.new
+      connection.call finish_and_sign_request(request)
+    end
+
+    include Signing::AuthorizationHeader
+
+    ##
+    # S3 handles region endpoints a little differently
+    ##
+    def uri
+      return @uri if @uri
+
+      @uri = @use_https ? "https" : "http"
+      @uri += "://#{@endpoint}"
+      @uri += "-#{@region}" if @region
+      @uri += ".amazonaws.com"
+      @uri
+    end
+
+  end
+
+end

data/lib/aws/signing/authorization_header.rb

@@ -0,0 +1,43 @@
+require 'openssl'
+
+module AWS
+  module Signing
+    ##
+    # Implementation of signing using the Authorization header, as used by S3 and CloudFront
+    ##
+    module AuthorizationHeader
+
+      ##
+      # Build and sign the final request, as per the rules here:
+      # http://s3.amazonaws.com/doc/s3-developer-guide/RESTAuthentication.html
+      ##
+      def finish_and_sign_request(request)
+        request.headers["Date"] = Time.now.utc.httpdate
+        request.headers["Authorization"] =
+          "AWS #{self.access_key}:#{Base64.encode64(build_signature_for(request)).chomp}"
+
+        request
+      end
+
+      def build_signature_for(request)
+        amazon_headers = request.headers.select {|k, v|
+          k =~ /^x-amz/i
+        }.map {|k, v|
+          "#{k.downcase}:#{v}".chomp
+        }
+
+        to_sign = [
+          request.method.to_s.upcase,
+          request.headers["Content-Md5"] || "",
+          request.headers["Content-Type"] || "",
+          request.headers["Date"],
+          amazon_headers,
+          request.path
+        ].flatten.join("\n")
+
+        OpenSSL::HMAC.digest("sha1", self.secret_key, to_sign)
+      end
+
+    end
+  end
+end

data/samples/s3.rb

@@ -0,0 +1,64 @@
+$: << File.expand_path("../../lib", __FILE__)
+
+require 'aws/s3'
+
+##
+# Expects your Amazon keys to be in the environment, something like
+#
+# export AWS_KEY="KEY"
+# export AWS_SECRET="SECRET"
+#
+# Usage:
+#   ruby sample/s3.rb [bucket name] [file to use]
+#
+# This script will upload the file, show that the file is up, then remove the file
+##
+
+def bad_usage
+  puts ""
+  puts "Usage:"
+  puts "  ruby sample/s3.rb [bucket name] [file to use]"
+  exit 1
+end
+
+s3 = AWS::S3.new ENV["AWS_KEY"], ENV["AWS_SECRET"]
+
+bucket_name = ARGV[0]
+file_name = ARGV[1]
+
+puts "All buckets in this account:", ""
+
+s3.get("/").buckets.bucket.each do |bucket|
+  puts bucket.name
+end
+
+puts "", "First 10 files in #{bucket_name}:", ""
+
+bad_usage unless bucket_name
+
+s3.get("/", :bucket => bucket_name, :params => {"max-keys" => 10}).contents.each do |entry|
+  puts entry.key
+end
+
+puts "", "Uploading #{file_name} to #{bucket_name}:", ""
+
+bad_usage unless file_name
+uploaded_file_name = File.basename file_name
+
+p s3.put("/#{uploaded_file_name}", :bucket => bucket_name, :file => File.open(file_name))
+
+puts "", "Checking that the file now exists...", ""
+
+p s3.head("/#{uploaded_file_name}", :bucket => bucket_name)
+
+puts "", "Deleting the file from S3", ""
+
+p s3.delete("/#{uploaded_file_name}", :bucket => bucket_name)
+
+puts "", "Checking that file is no longer in S3...", ""
+
+begin
+  p s3.head("/#{uploaded_file_name}", :bucket => bucket_name)
+rescue => ex
+  puts "Not found: #{ex.message}"
+end

data/simple_aws.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name     = "simple_aws"
-  s.version  = "0.0.1b"
+  s.version  = "0.0.1c"
   s.platform = Gem::Platform::RUBY
   s.authors  = ["Jason Roelofs"]
   s.email    = ["jameskilton@gmail.com"]
@@ -12,6 +12,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency "ox"
   s.add_dependency "httparty"
+  s.add_dependency "httmultiparty"
 
   s.add_dependency "jruby-openssl" if RUBY_PLATFORM == 'java'
 

data/test/aws/core/connection_test.rb

@@ -56,5 +56,17 @@ describe AWS::Connection do
       @connection.call request
     end
 
+    it "passes through any body on the Request" do
+      request = AWS::Request.new(:get, "host.com", "/")
+      request.body = "This is some body text"
+
+      AWS::HTTP.expects(:get).with {|uri, options|
+        options[:query].wont_be_nil
+        options[:body].must_equal "This is some body text"
+      }.returns(@http_response)
+
+      @connection.call request
+    end
+
   end
 end

data/test/aws/core/request_test.rb

@@ -19,13 +19,6 @@ describe AWS::Request do
     @request.method.must_equal :get
   end
 
-  it "can be given parameters to pass in" do
-    @request.params["Param1"] = "Value1"
-    @request.params["Param2"] = "Value2"
-
-    @request.params.must_equal "Param1" => "Value1", "Param2" => "Value2"
-  end
-
   it "ensures path is never an empty string" do
     @request.path = ""
     @request.path.must_equal "/"
@@ -38,6 +31,22 @@ describe AWS::Request do
     end
   end
 
+  describe "parameters" do
+    it "can be given parameters to pass in" do
+      @request.params["Param1"] = "Value1"
+      @request.params["Param2"] = "Value2"
+
+      @request.params.must_equal "Param1" => "Value1", "Param2" => "Value2"
+    end
+  end
+
+  describe "body" do
+    it "can be given raw body text" do
+      @request.body = "BODY!"
+      @request.body.must_equal "BODY!"
+    end
+  end
+
   describe "hashes" do
     it "converts hash params to AWS param names" do
       @request.params["Filter"] = [

data/test/aws/core/response_test.rb

@@ -8,6 +8,7 @@ describe AWS::Response do
     before do
       @error_response = {}
       @http_response = stub
+      @http_response.stubs(:headers).returns(nil)
       @http_response.stubs(:success?).returns(false)
       @http_response.stubs(:code).returns(401)
     end
@@ -55,6 +56,25 @@ describe AWS::Response do
       error.message.must_equal "AuthFailure (401): Message about failing to authenticate"
     end
 
+    it "handles S3 errors" do
+      @error_response = { "Error" => {
+        "Code" => "AuthFailure", "Message" => "OH snap!",
+        "StringToSign" => "SOME STRING"
+      } }
+      @http_response.stubs(:parsed_response).returns(@error_response)
+
+      error =
+        lambda {
+          AWS::Response.new @http_response
+        }.must_raise AWS::UnsuccessfulResponse
+
+      error.code.must_equal 401
+      error.error_type.must_equal "AuthFailure"
+      error.error_message.must_equal "OH snap! String to Sign: \"SOME STRING\""
+
+      error.message.must_equal "AuthFailure (401): OH snap! String to Sign: \"SOME STRING\""
+    end
+
     it "raises if it can't parse the error message" do
       @error_response = { "Erroring" => "This is an error message" }
       @http_response.stubs(:parsed_response).returns(@error_response)
@@ -66,6 +86,19 @@ describe AWS::Response do
 
       error.message.must_match /Unable to parse error code from/
     end
+
+    it "handles errors that have no body to parse" do
+      @http_response.stubs(:code).returns(404)
+      @http_response.stubs(:parsed_response).returns(nil)
+      @http_response.stubs(:response).returns("This is a response ok?")
+
+      error = lambda {
+        response = AWS::Response.new @http_response
+      }.must_raise AWS::UnsuccessfulResponse
+
+      error.code.must_equal 404
+      error.message.must_equal " (404): This is a response ok?"
+    end
   end
 
   describe "successful response parsing and mapping" do
@@ -79,6 +112,8 @@ describe AWS::Response do
       }
 
       @http_response = stub
+      @http_response.stubs(:headers).returns(nil)
+      @http_response.stubs(:code).returns(200)
       @http_response.stubs(:success?).returns(true)
       @http_response.stubs(:parsed_response).returns(@response_hash)
 
@@ -104,6 +139,23 @@ describe AWS::Response do
       @response["unknownKey"].must_be_nil
     end
 
+    it "handles responses with no body" do
+      @http_response.stubs(:parsed_response).returns(nil)
+      response = AWS::Response.new @http_response
+      response.body.must_be_nil
+    end
+
+    it "knows the status code of the response" do
+      @response.code.must_equal 200
+    end
+
+    it "pulls out any response headers" do
+      @http_response.stubs(:headers).returns({"Header1" => "Value2"})
+      response = AWS::Response.new @http_response
+
+      response.headers.must_equal "Header1" => "Value2"
+    end
+
   end
 
   describe "deeply nested response/results objects" do
@@ -119,6 +171,8 @@ describe AWS::Response do
       }
 
       @http_response = stub
+      @http_response.stubs(:headers).returns(nil)
+      @http_response.stubs(:code).returns(202)
       @http_response.stubs(:success?).returns(true)
       @http_response.stubs(:parsed_response).returns(@response_hash)
 
@@ -167,11 +221,20 @@ describe AWS::Response do
           "withMemberSet" => {
             "member" => {"keyId" => "4567"}
           },
-          "UpperCamelKey" => "purple dog"
+          "UpperCamelKey" => "purple dog",
+          "Buckets" => {
+            "Bucket" => [
+              {"Name" => "bucket1"},
+              {"Name" => "bucket2"},
+              {"Name" => "bucket3"}
+            ]
+          }
         }
       }
 
       @http_response = stub
+      @http_response.stubs(:code).returns(202)
+      @http_response.stubs(:headers).returns(nil)
       @http_response.stubs(:success?).returns(true)
       @http_response.stubs(:parsed_response).returns(@response_hash)
 
@@ -226,6 +289,12 @@ describe AWS::Response do
         @response.upper_camel_key.must_equal "purple dog"
       end
 
+      it "works with straight array responses" do
+        @response.buckets.bucket[0].name.must_equal "bucket1"
+        @response.buckets.bucket[1].name.must_equal "bucket2"
+        @response.buckets.bucket[2].name.must_equal "bucket3"
+      end
+
     end
 
     describe "hash keys" do
@@ -259,6 +328,12 @@ describe AWS::Response do
       it "also squashes the 'member' tag" do
         @response["withMemberSet"][0]["keyId"].must_equal "4567"
       end
+
+      it "works with straight array responses" do
+        @response["Buckets"]["Bucket"][0]["Name"].must_equal "bucket1"
+        @response["Buckets"]["Bucket"][1]["Name"].must_equal "bucket2"
+        @response["Buckets"]["Bucket"][2]["Name"].must_equal "bucket3"
+      end
     end
 
   end
@@ -266,6 +341,8 @@ describe AWS::Response do
   describe "#request_id" do
     before do
       @http_response = stub
+      @http_response.stubs(:headers).returns(nil)
+      @http_response.stubs(:code).returns(200)
       @http_response.stubs(:success?).returns(true)
     end
 

data/test/aws/s3_test.rb

@@ -0,0 +1,108 @@
+require 'test_helper'
+require 'aws/s3'
+
+describe AWS::S3 do
+
+  before do
+    @api = AWS::S3.new "key", "secret"
+  end
+
+  it "points to the endpoint" do
+    @api.uri.must_equal "https://s3.amazonaws.com"
+  end
+
+  it "properly builds region endpoints" do
+    api = AWS::S3.new "key", "secret", "us-west-1"
+    api.uri.must_equal "https://s3-us-west-1.amazonaws.com"
+  end
+
+  it "works with the current version" do
+    @api.version.must_equal "2006-03-01"
+  end
+
+  describe "API calls" do
+
+    [:get, :post, :put, :delete, :head].each do |method|
+      it "supports the #{method} HTTP method" do
+        AWS::Connection.any_instance.expects(:call).with do |request|
+          request.method.must_equal method
+          request.host.must_equal "https://s3.amazonaws.com"
+          request.path.must_equal "/"
+          true
+        end
+
+        @api.send method, "/"
+      end
+    end
+
+    it "rebuilds the host if :bucket given" do
+      AWS::Connection.any_instance.expects(:call).with do |request|
+        request.path.must_equal "/bucket-name/"
+        request.host.must_equal "https://s3.amazonaws.com"
+        true
+      end
+
+      @api.get "/", :bucket => "bucket-name"
+    end
+
+    it "takes parameters" do
+      AWS::Connection.any_instance.expects(:call).with do |request|
+        request.params["Parameter1"].must_equal "Value2"
+        true
+      end
+
+      @api.get "/", :params => { "Parameter1" => "Value2" }
+    end
+
+    it "takes extra headers" do
+      AWS::Connection.any_instance.expects(:call).with do |request|
+        request.headers["Header14"].must_equal "Out to Lunch"
+        true
+      end
+
+      @api.get "/", :headers => { "Header14" => "Out to Lunch" }
+    end
+
+    it "takes a raw body" do
+      AWS::Connection.any_instance.expects(:call).with do |request|
+        request.body.must_equal "This is a body of text"
+        true
+      end
+
+      @api.get "/", :body => "This is a body of text"
+    end
+
+    it "adds the form-data header if the body has a file in it" do
+      AWS::Connection.any_instance.expects(:call).with do |request|
+        request.body.must_equal :file => "This is a body of text"
+        request.headers["Content-Type"].must_equal(
+          "multipart/form-data; boundary=-----------RubyMultipartPost"
+        )
+        true
+      end
+
+      @api.get "/", :body => {:file => "This is a body of text"}
+    end
+
+    it "allows use of :file if :body only contains a file" do
+      AWS::Connection.any_instance.expects(:call).with do |request|
+        request.body.must_equal :file => "This is a body of text"
+        request.headers["Content-Type"].must_equal(
+          "multipart/form-data; boundary=-----------RubyMultipartPost"
+        )
+        true
+      end
+
+      @api.get "/", :file => "This is a body of text"
+    end
+
+    it "signs the request using the Authorization header" do
+      AWS::Connection.any_instance.expects(:call).with do |request|
+        request.headers["Authorization"].wont_be_nil
+        true
+      end
+
+      @api.get "/"
+    end
+  end
+end

data/test/aws/signing/authorization_header_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+require 'aws/api'
+require 'aws/call_types/action_param'
+require 'aws/signing/authorization_header'
+
+describe AWS::Signing::AuthorizationHeader do
+
+  class SigningAuthHeaderTestAPI < AWS::API
+    endpoint "aptest"
+    version "2011-01-01"
+    use_https true
+
+    include AWS::CallTypes::ActionParam
+    include AWS::Signing::AuthorizationHeader
+  end
+
+  it "signs the given request according to Version 3 rules" do
+    AWS::Connection.any_instance.expects(:call).with do |request|
+      header = request.headers["Authorization"]
+      parts = header.split(":")
+
+      parts[0].must_equal "AWS key"
+      parts[1].wont_be_nil
+
+      Time.parse(request.headers["Date"]).wont_be_nil
+      true
+    end.returns
+
+    obj = SigningAuthHeaderTestAPI.new "key", "secret"
+    obj.describe_instances
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple_aws
 version: !ruby/object:Gem::Version
-  version: 0.0.1b
+  version: 0.0.1c
   prerelease: 5
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-03 00:00:00.000000000 Z
+date: 2012-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ox
-  requirement: &70137915318080 !ruby/object:Gem::Requirement
+  requirement: &70146086124160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70137915318080
+  version_requirements: *70146086124160
 - !ruby/object:Gem::Dependency
   name: httparty
-  requirement: &70137915317640 !ruby/object:Gem::Requirement
+  requirement: &70146086123740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,18 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70137915317640
+  version_requirements: *70146086123740
+- !ruby/object:Gem::Dependency
+  name: httmultiparty
+  requirement: &70146086123280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70146086123280
 description: The simplest and easiest to use and maintain AWS communication library
 email:
 - jameskilton@gmail.com
@@ -63,7 +74,9 @@ files:
 - lib/aws/map_reduce.rb
 - lib/aws/mechanical_turk.rb
 - lib/aws/rds.rb
+- lib/aws/s3.rb
 - lib/aws/ses.rb
+- lib/aws/signing/authorization_header.rb
 - lib/aws/signing/version2.rb
 - lib/aws/signing/version3.rb
 - lib/aws/sns.rb
@@ -71,6 +84,7 @@ files:
 - samples/ec2.rb
 - samples/elb.rb
 - samples/iam.rb
+- samples/s3.rb
 - samples/sqs.rb
 - samples/turk.rb
 - simple_aws.gemspec
@@ -91,7 +105,9 @@ files:
 - test/aws/map_reduce_test.rb
 - test/aws/mechanical_turk_test.rb
 - test/aws/rds_test.rb
+- test/aws/s3_test.rb
 - test/aws/ses.rb
+- test/aws/signing/authorization_header_test.rb
 - test/aws/signing/version2_test.rb
 - test/aws/signing/version3.rb
 - test/aws/sns_test.rb
@@ -139,7 +155,9 @@ test_files:
 - test/aws/map_reduce_test.rb
 - test/aws/mechanical_turk_test.rb
 - test/aws/rds_test.rb
+- test/aws/s3_test.rb
 - test/aws/ses.rb
+- test/aws/signing/authorization_header_test.rb
 - test/aws/signing/version2_test.rb
 - test/aws/signing/version3.rb
 - test/aws/sns_test.rb