aws-sdk-core 2.0.0.rc1

data/lib/aws/error_handler.rb

@@ -0,0 +1,48 @@
+module Aws
+  # @api private
+  class ErrorHandler
+
+    def initialize(parser)
+      @parser = parser
+    end
+
+    attr_accessor :handler
+
+    def call(context)
+      @handler.call(context).on_status(300..599) do |response|
+        if empty_body?(response)
+          error_code = error_code_for_empty_response(response)
+          error_message = ''
+        else
+          error_code, error_message = @parser.extract_error(response)
+        end
+        response.error = error(context, error_code, error_message)
+        response.data = nil
+      end
+    end
+
+    private
+
+    def error(context, code, message)
+      svc_class_name = context.config.api.metadata['service_class_name']
+      klass = Errors.error_class(svc_class_name, code)
+      Errors.error_class(svc_class_name, code).new(context, message)
+    end
+
+    def empty_body?(response)
+      response.http_response.body_contents.empty?
+    end
+
+    def error_code_for_empty_response(response)
+      error_code = response.http_response.status_code
+      {
+        302 => 'MovedTemporarily',
+        304 => 'NotModified',
+        400 => 'BadRequest',
+        403 => 'Forbidden',
+        404 => 'NotFound',
+      }[error_code] || "#{error_code}Error"
+    end
+
+  end
+end

data/lib/aws/errors.rb

@@ -0,0 +1,83 @@
+module Aws
+  module Errors
+
+    # The base class for all errors returned by an Amazon Web Service.
+    # All ~400 level client errors and ~500 level server errors are raised
+    # as service errors.  This indicates it was an error returned from the
+    # service and not one generated by the client.
+    class ServiceError < RuntimeError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      def initialize(context = nil, message = nil)
+        if context.is_a?(String)
+          message = context
+        else
+          @context = context
+        end
+        super(message)
+      end
+
+      # @return [Seahorse::Client::RequestContext] The context of the request
+      #   that triggered the remote service to return this error.
+      attr_reader :context
+
+    end
+
+    # Various plugins perform client-side checksums of responses.
+    # This error indicates a checksum failed.
+    class ChecksumError < RuntimeError; end
+
+    # Raised when a {Service} is constructed an no suitable API
+    # version is found based on configuration.
+    class NoSuchApiVersionError < RuntimeError; end
+
+    # Raised when a {Service} is constructed and credentials are not
+    # set, or the set credentials are empty.
+    class MissingCredentialsError < RuntimeError; end
+
+    # Raised when a {Service} is constructed and region is not specified.
+    class MissingRegionError < RuntimeError; end
+
+    # This module is mixed into another module, providing dynamic
+    # error classes.  Error classes all inherit from {ServiceError}.
+    #
+    #     # creates and returns the class
+    #     Aws::S3::Errors::MyNewErrorClass
+    #
+    # Since the complete list of possible AWS errors returned by services
+    # is not known, this allows us to create them as needed.  This also
+    # allows users to rescue errors by class without them being concrete
+    # classes beforehand.
+    #
+    # @api private
+    module DynamicErrors
+
+      def const_missing(constant)
+        const_set(constant, Class.new(ServiceError))
+      end
+
+    end
+
+    class << self
+
+      # Given the name of a service and an error code, this method
+      # returns an error class (that extends {ServiceError}.
+      #
+      #     Aws::Errors.error_class('S3', 'NoSuchBucket').new
+      #     #=> #<Aws::S3::Errors::NoSuchBucket>
+      #
+      # @api private
+      def error_class(svc_class_name, error_code)
+        constant = error_code.to_s.gsub(/\W+/, '').to_sym
+        errors = Aws.const_get(svc_class_name).const_get(:Errors)
+        if errors.constants.include?(constant)
+          errors.const_get(constant)
+        else
+          errors.const_set(constant, Class.new(ServiceError))
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/json/builder.rb

@@ -0,0 +1,77 @@
+require 'multi_json'
+require 'base64'
+
+module Aws
+  module Json
+    class Builder
+
+      include Seahorse::Model::Shapes
+      include TimestampFormatter
+
+      # @param [Seahorse::Model::Shapes::Shape] rules
+      def initialize(rules)
+        @rules = rules
+      end
+
+      # @param [Hash] params
+      # @return [Hash]
+      def build(params)
+        structure(@rules, params)
+      end
+
+      # @param [Hash] params
+      # @return [String<JSON>]
+      def to_json(params)
+        MultiJson.dump(build(params))
+      end
+
+      class << self
+
+        # @param [Seahorse::Model::Shapes::Shape] rules
+        # @param [Hash] params
+        # @return [String<JSON>]
+        def to_json(rules, params)
+          new(rules).to_json(params)
+        end
+        alias build  to_json
+
+      end
+
+      private
+
+      def structure(shape, values)
+        data = {}
+        values.each do |key, value|
+          if member_shape = shape.members[key]
+            data[member_shape.serialized_name] = member(member_shape, value)
+          end
+        end
+        data
+      end
+
+      def list(shape, values)
+        values.map { |value| member(shape.members, value) }
+      end
+
+      def map(shape, values)
+        data = {}
+        values.each do |key, value|
+          data[key] = member(shape.members, value)
+        end
+        data
+      end
+
+      def member(shape, value)
+        case shape
+        when StructureShape then structure(shape, value)
+        when ListShape then list(shape, value)
+        when MapShape then map(shape, value)
+        when TimestampShape then timestamp(shape, value.utc)
+        when BlobShape then Base64.strict_encode64(value)
+        else value
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/json/error_parser.rb

@@ -0,0 +1,20 @@
+module Aws
+  module Json
+    class ErrorParser
+
+      def extract_error(response)
+        json = MultiJson.load(response.http_response.body_contents)
+        error_code = json['code'] || json['__type'] 
+        error_code ||= response.http_response.headers['x-amzn-errortype']
+        error_code = error_code.split('#').last
+        if error_code == 'RequestEntityTooLarge'
+          error_message = 'Request body must be less than 1 MB'
+        else
+          error_message = json['message'] || json['Message']
+        end
+        [error_code, error_message]
+      end
+
+    end
+  end
+end

data/lib/aws/json/parser.rb

@@ -0,0 +1,67 @@
+require 'multi_json'
+require 'base64'
+
+module Aws
+  module Json
+    class Parser
+
+      include Seahorse::Model::Shapes
+
+      # @param [Seahorse::Model::Shapes::OutputShape] rules
+      # @param [String<JSON>] json
+      # @return [Hash]
+      def parse(rules, json)
+        json = '{}' if json == ''
+        structure(rules, MultiJson.load(json, max_nesting: false))
+      end
+
+      # @param [Seahorse::Model::Shapes::OutputShape] rules
+      # @param [String<JSON>] json
+      # @return [Hash]
+      def self.parse(rules, json)
+        new.parse(rules, json)
+      end
+
+      private
+
+      def structure(shape, values)
+        data = Structure.new(shape.members.keys)
+        values.each do |key, value|
+          if member_shape = shape.serialized_members[key]
+            data[member_shape.member_name] = member(member_shape, value)
+          end
+        end
+        data
+      end
+
+      def list(shape, values)
+        values.map { |value| member(shape.members, value) }
+      end
+
+      def map(shape, values)
+        data = {}
+        values.each do |key, value|
+          data[key] = member(shape.members, value)
+        end
+        data
+      end
+
+      def member(shape, value)
+        return nil if value.nil?
+        case shape
+        when StructureShape then structure(shape, value)
+        when ListShape then list(shape, value)
+        when MapShape then map(shape, value)
+        when TimestampShape then time(value)
+        when BlobShape then Base64.decode64(value)
+        else value
+        end
+      end
+
+      def time(value)
+        value.is_a?(Numeric) ? Time.at(value) : Time.parse(value)
+      end
+
+    end
+  end
+end

data/lib/aws/json/serializer.rb

@@ -0,0 +1,15 @@
+module Aws
+  module Json
+    # @api private
+    class Serializer
+
+      def setup_request(*args); end
+
+      def serialize_params(context, rules, params)
+        json_params = Builder.new(rules).build(params)
+        context.http_request.body = MultiJson.dump(json_params)
+      end
+
+    end
+  end
+end

data/lib/aws/plugins/credentials.rb

@@ -0,0 +1,48 @@
+module Aws
+  module Plugins
+
+    # @seahorse.client.option [String] :access_key_id Your AWS account
+    #   access key ID.  Defaults to `ENV['AWS_ACCESS_KEY_ID']`.
+    #
+    # @seahorse.client.option [String] :secret_access_key Your AWS account
+    #   secret access key.  Defaults to `ENV['AWS_SECRET_ACCESS_KEY']`.
+    #
+    # @seahorse.client.option [String] :session_token If your credentials
+    #   are temporary session credentials, this should be the
+    #   session token.  Defaults to `ENV['AWS_SESSION_TOKEN']`.
+    #
+    # @seahorse.client.option [Credentials] :credentials
+    #   Your AWS account credentials.  Defaults to a new {Credentials} object
+    #   populated by `:access_key_id`, `:secret_access_key` and
+    #   `:session_token`.
+    #
+    class Credentials < Seahorse::Client::Plugin
+
+      option(:access_key_id) {
+        ENV['AWS_ACCESS_KEY_ID'] || ENV['AMAZON_ACCESS_KEY_ID']
+      }
+
+      option(:secret_access_key) {
+        ENV['AWS_SECRET_ACCESS_KEY'] || ENV['AMAZON_SECRET_ACCESS_KEY']
+      }
+
+      option(:session_token) {
+        ENV['AWS_SESSION_TOKEN'] || ENV['AMAZON_SESSION_TOKEN']
+      }
+
+      option(:credentials) do |config|
+        Aws::Credentials.new(
+          config.access_key_id,
+          config.secret_access_key,
+          config.session_token)
+      end
+
+      def after_initialize(client)
+        if client.config.credentials.nil? or !client.config.credentials.set?
+          raise Errors::MissingCredentialsError
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/plugins/dynamodb_extended_retries.rb

@@ -0,0 +1,22 @@
+module Aws
+  module Plugins
+
+    # @seahorse.client.option [Integer] :retry_limit (10)
+    #   The maximum number of times to retry failed requests.  Only
+    #   ~ 500 level server errors and certain ~ 400 level client errors
+    #   are retried.  Generally, these are throttling errors, data
+    #   checksum errors, networking errors, timeout errors and auth
+    #   errors from expired credentials.
+    class DynamoDBExtendedRetries < Seahorse::Client::Plugin
+
+      option(:retry_limit, 10)
+
+      option(:retry_backoff, lambda { |context|
+        if context.retries > 1
+          Kernel.sleep(50 * (2 ** (context.retries - 1)) / 1000.0)
+        end
+      })
+
+    end
+  end
+end

data/lib/aws/plugins/glacier_api_version.rb

@@ -0,0 +1,19 @@
+module Aws
+  module Plugins
+    class GlacierApiVersion < Seahorse::Client::Plugin
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          version = context.config.api.version
+          context.http_request.headers['x-amz-glacier-version'] = version
+          @handler.call(context)
+        end
+
+      end
+
+      handler(Handler)
+
+    end
+  end
+end

data/lib/aws/plugins/glacier_checksums.rb

@@ -0,0 +1,100 @@
+require 'openssl'
+
+module Aws
+  module Plugins
+
+    # Computes the `:checksum` of the HTTP request body for operations
+    # that require the `X-Amz-Sha256-Tree-Hash` header.  This includes:
+    #
+    # * `:complete_multipart_upload`
+    # * `:upload_archive`
+    # * `:upload_multipart_part`
+    #
+    # The `:upload_archive` and `:upload_multipart_part` operations
+    # accept a `:checksum` request paramter.  If this param
+    # is present, then the checksum is assumed to be the proper
+    # tree hash of the file to be uploaded.  If this param is
+    # not present, then the required tree hash checksum will
+    # be generated.
+    #
+    # The `:complete_multipart_upload` operation does not accept
+    # a checksum and this plugin will always compute this of the
+    # HTTP request body on your behalf.
+    class GlacierChecksums < Seahorse::Client::Plugin
+
+      CHECKSUM_OPERATIONS = [
+        :complete_multipart_upload,
+        :upload_archive,
+        :upload_multipart_part,
+      ]
+
+      class Handler < Seahorse::Client::Handler
+
+        HASH = 'X-Amz-Content-Sha256'
+        TREE_HASH = 'X-Amz-Sha256-Tree-Hash'
+
+        def call(context)
+          unless context.http_request.headers[TREE_HASH]
+            populate_checksum_headers(context.http_request)
+          end
+          @handler.call(context)
+        end
+
+        private
+
+        def populate_checksum_headers(http_req)
+          compute_checksums(http_req.body) do |hash, tree_hash|
+            http_req.headers[HASH] = hash
+            http_req.headers[TREE_HASH] = tree_hash
+          end
+        end
+
+        # Computes two checksums of the body.  The tree hash is required
+        # by Glacier for operations where you upload a file.  The other
+        # checksum is required by signature version 4.  We compute both
+        # here so the sigv4 signer does not need to re-read the body.
+        def compute_checksums(body, &block)
+
+          digest = OpenSSL::Digest::Digest.new('sha256')
+          tree_digest = OpenSSL::Digest::Digest.new('sha256')
+          tree_parts = []
+
+          until body.eof?
+
+            chunk = body.read(1024 * 1024) # read 1MB
+            tree_parts << tree_digest.update(chunk).digest
+            tree_digest.reset
+
+            digest.update(chunk)
+
+          end
+
+          body.rewind
+
+          yield(digest.to_s, compute_tree_hash(tree_parts))
+
+        end
+
+        def compute_tree_hash hashes
+          digest = OpenSSL::Digest::Digest.new('sha256')
+          until hashes.count == 1
+            hashes = hashes.each_slice(2).map do |h1,h2|
+              digest.reset
+              if h2
+                digest.update(h1)
+                digest.update(h2)
+                digest.digest
+              else
+                h1
+              end
+            end
+          end
+          hashes.first.bytes.map{|x| x.to_i.to_s(16).rjust(2,'0')}.join('')
+        end
+      end
+
+      handler(Handler, operations: CHECKSUM_OPERATIONS)
+
+    end
+  end
+end