aws-sdk-core 2.0.0.rc1

data/lib/aws/plugins/global_configuration.rb

@@ -0,0 +1,79 @@
+module Aws
+  module Plugins
+
+    # This plugin provides the ability to provide global configuration for
+    # all AWS classes or specific ones.
+    #
+    # ## Global AWS configuration
+    #
+    # You can specify global configuration defaults via `Aws.config`
+    #
+    #     Aws.config[:region] = 'us-west-2'
+    #
+    # Options applied to `Aws.config` are merged with constructed
+    # service interfaces.
+    #
+    #     # uses the global configuration
+    #     Aws::EC2.new.config.region #=> 'us-west-2'
+    #
+    #     # constructor args have priority over global configuration
+    #     Aws::EC2.new(region: 'us-east-1').config.region #=> 'us-east-1'
+    #
+    # ## Service Specific Global Configuration
+    #
+    # Some services have very specific configuration options that are not
+    # shared by other services.
+    #
+    #     # oops, this option is only recognized by Aws::S3
+    #     Aws.config[:force_path_style] = true
+    #     Aws::EC2.new
+    #     #=> raises ArgumentError: invalid configuration option `:force_path_style'
+    #
+    # To avoid this issue, you can nest service specific options 
+    #
+    #     Aws.config[:s3] = { force_path_style: true }
+    #
+    #     Aws::EC2.new # no error this time
+    #     Aws::S3.new.config.force_path_style #=> true
+    #
+    class GlobalConfiguration < Seahorse::Client::Plugin
+
+      # @api private
+      def before_initialize(service_class, options)
+        # apply service specific defaults before the global aws defaults
+        apply_service_defaults(service_class, options)
+        apply_aws_defaults(options)
+      end
+
+      private
+
+      def apply_service_defaults(service_class, options)
+        if defaults = Aws.config[identifier(service_class)]
+          defaults.each do |option_name, default|
+            next if option_name == :api_version
+            next if options.key?(option_name)
+            options[option_name] = default
+          end
+        end
+      end
+
+      def apply_aws_defaults(options)
+        Aws.config.each do |option_name, default|
+          next if svc_identifier?(option_name)
+          next if option_name == :api_version
+          next if options.key?(option_name)
+          options[option_name] = default
+        end
+      end
+
+      def identifier(service_class)
+        service_class.api.metadata['service_class_name'].downcase.to_sym
+      end
+
+      def svc_identifier?(option_name)
+        Aws.service_classes.key?(option_name)
+      end
+
+    end
+  end
+end

data/lib/aws/plugins/json_protocol.rb

@@ -0,0 +1,30 @@
+module Aws
+  module Plugins
+
+    # @seahorse.client.option [Boolean] :raw_json (false)
+    #   When `true`, request parameters are not validated or translated.
+    #   Request parameter keys and values are expected to be formated as
+    #   they are expected by the service.  Similarly, when `:raw_json`
+    #   is enabled, response data is no longer translated.  Instead
+    #   it is simply the result of a JSON parse.
+    class JsonProtocol < Seahorse::Client::Plugin
+
+      option(:raw_json, false)
+
+      option(:validate_params) { |config| !config.raw_json }
+
+      option(:convert_params) { |config| !config.raw_json }
+
+      def add_handlers(handlers, config)
+        if config.raw_json
+          handlers.add(Seahorse::Client::Plugins::JsonSimple::Handler)
+        else
+          handlers.add(RequestHandler.new(Json::Serializer.new))
+          handlers.add(ResponseHandler.new(Json::Parser.new))
+        end
+        handlers.add(ErrorHandler.new(Json::ErrorParser.new), step: :sign)
+      end
+
+    end
+  end
+end

data/lib/aws/plugins/json_rpc_headers.rb

@@ -0,0 +1,34 @@
+
+module Aws
+  module Plugins
+
+    # This plugin applies the "X-Amz-Target" and "Content-Type" headers
+    # for AWS JSON Rpc style APIs.
+    class JsonRpcHeaders < Seahorse::Client::Plugin
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          context.http_request.headers['X-Amz-Target'] = target(context)
+          context.http_request.headers['Content-Type'] = content_type(context)
+          @handler.call(context)
+        end
+
+        def target(context)
+          prefix = context.config.api.metadata['json_target_prefix']
+          "#{prefix}.#{context.operation.name}"
+        end
+
+        def content_type(context)
+          version = context.config.api.metadata['json_version']
+          "application/x-amz-json-#{version}"
+        end
+
+      end
+
+      handler(Handler)
+
+    end
+  end
+end

data/lib/aws/plugins/query_protocol.rb

@@ -0,0 +1,11 @@
+module Aws
+  module Plugins
+    class QueryProtocol < Seahorse::Client::Plugin
+
+      handler(RequestHandler.new(Query::Serializer.new))
+      handler(ResponseHandler.new(Xml::Parser.new))
+      handler(ErrorHandler.new(Xml::ErrorParser.new), step: :sign)
+
+    end
+  end
+end

data/lib/aws/plugins/regional_endpoint.rb

@@ -0,0 +1,37 @@
+module Aws
+  module Plugins
+
+    # @seahorse.client.option [String] :region (ENV['AWS_REGION'])
+    #   The AWS region to connect to.  The region is used to construct
+    #   the client endpoint.
+    #
+    # @seahorse.client.option [String] :endpoint
+    #   The HTTP endpoint for this client. Normally you should not need
+    #   to configure the `:endpoint` directly.  It is constructed from
+    #   the `:region` option.  However, sometime you need to specify
+    #   the full endpoint, especially when connecting to test
+    #   endpoints.
+    #
+    class RegionalEndpoint < Seahorse::Client::Plugin
+
+      # raised when region is not configured
+      MISSING_REGION = 'missing required configuration option :region'
+
+      option(:region) { ENV['AWS_REGION'] || ENV['AMAZON_REGION'] }
+
+      option(:endpoint) do |cfg|
+        endpoints = cfg.api.metadata['regional_endpoints']
+        if endpoints && endpoints[cfg.region]
+          endpoints[cfg.region]
+        else
+          "#{cfg.api.metadata['endpoint_prefix']}.#{cfg.region}.amazonaws.com"
+        end
+      end
+
+      def after_initialize(client)
+        raise Errors::MissingRegionError unless client.config.region
+      end
+
+    end
+  end
+end

data/lib/aws/plugins/retry_errors.rb

@@ -0,0 +1,149 @@
+require 'set'
+
+module Aws
+  module Plugins
+
+    # @seahorse.client.option [Integer] :retry_limit (3)
+    #   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 RetryErrors < Seahorse::Client::Plugin
+
+      option(:retry_limit, 3)
+
+      option(:retry_backoff, lambda { |c| Kernel.sleep(2 ** c.retries * 0.3) })
+
+      # @api private
+      class ErrorInspector
+
+        EXPIRED_CREDS = Set.new([
+          'InvalidClientTokenId',        # query services
+          'UnrecognizedClientException', # json services
+          'InvalidAccessKeyId',          # s3
+          'AuthFailure',                 # ec2
+        ])
+
+        THROTTLING_ERRORS = Set.new([
+          'Throttling',                             # query services
+          'ThrottlingException',                    # json services
+          'RequestThrottled',                       # sqs
+          'ProvisionedThroughputExceededException', # dynamodb
+          'RequestLimitExceeded',                   # ec2
+          'BandwidthLimitExceeded',                 # cloud search
+        ])
+
+        CHECKSUM_ERRORS = Set.new([
+          'CRC32CheckFailed', # dynamodb
+        ])
+
+        NETWORKING_ERRORS = Set.new([
+          'RequestTimeout', # s3
+        ])
+
+        def initialize(error, http_status_code)
+          @error = error
+          @name = error.class.name.split('::').last
+          @http_status_code = http_status_code
+        end
+
+        def expired_credentials?
+          !!(EXPIRED_CREDS.include?(@name) || @name.match(/expired/i))
+        end
+
+        def throttling_error?
+          !!(THROTTLING_ERRORS.include?(@name) || @name.match(/throttl/i))
+        end
+
+        def checksum?
+          CHECKSUM_ERRORS.include?(@name) || @error.is_a?(Errors::ChecksumError)
+        end
+
+        def networking?
+          NETWORKING_ERRORS.include?(@name) || @http_status_code == 0
+        end
+
+        def server?
+          (500..599).include?(@http_status_code)
+        end
+
+      end
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          response = @handler.call(context)
+          if response.error
+            retry_if_possible(response)
+          else
+            response
+          end
+        end
+
+        private
+
+        def retry_if_possible(response)
+          context = response.context
+          error = error_for(response)
+          if should_retry?(context, error)
+            retry_request(context, error)
+          else
+            response
+          end
+        end
+
+        def error_for(response)
+          ErrorInspector.new(response.error, response.http_response.status_code)
+        end
+
+        def retry_request(context, error)
+          delay_retry(context)
+          context.retries += 1
+          context.config.credentials.refresh! if error.expired_credentials?
+          context.http_request.body.rewind
+          context.http_response.body.truncate(0)
+          call(context)
+        end
+
+        def delay_retry(context)
+          context.config.retry_backoff.call(context)
+        end
+
+        def should_retry?(context, error)
+          retryable?(context, error) and
+          context.retries < retry_limit(context) and
+          response_truncatable?(context)
+        end
+
+        def retryable?(context, error)
+          (error.expired_credentials? and refreshable_credentials?(context)) or
+          error.throttling_error? or
+          error.checksum? or
+          error.networking? or
+          error.server?
+        end
+
+        def refreshable_credentials?(context)
+          context.config.credentials.respond_to?(:refresh!)
+        end
+
+        def retry_limit(context)
+          context.config.retry_limit
+        end
+
+        def response_truncatable?(context)
+          context.http_response.body.respond_to?(:truncate)
+        end
+
+      end
+
+      def add_handlers(handlers, config)
+        if config.retry_limit > 0
+          handlers.add(Handler, step: :sign, priority: 99)
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/plugins/s3_bucket_dns.rb

@@ -0,0 +1,78 @@
+module Aws
+  module Plugins
+
+    # Amazon S3 requires DNS style addressing for buckets outside of
+    # the classic region when possible.
+    #
+    # @seahorse.client.option [Boolean] :force_path_style (false)
+    #   When set to `true`, the bucket name is always left in the
+    #   request URI and never moved to the host as a sub-domain.
+    #
+    class S3BucketDns < Seahorse::Client::Plugin
+
+      # When set to `false` DNS compatible bucket names are moved from
+      # the request URI path to the host as a subdomain, unless the request
+      # is using SSL and the bucket name contains a dot.
+      #
+      # When set to `true`, the bucket name is always forced to be part
+      # of the request URI path.  This will not work with buckets outside
+      # the classic region.
+      option(:force_path_style, false)
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          unless context.config.force_path_style
+            move_dns_compat_bucket_to_subdomain(context)
+          end
+          @handler.call(context)
+        end
+
+        private
+
+        def move_dns_compat_bucket_to_subdomain(context)
+          if bucket_name = context.params[:bucket]
+            req = context.http_request
+            if S3BucketDns.dns_compatible?(bucket_name, req.endpoint.https?)
+              move_bucket_to_subdomain(bucket_name, req)
+            end
+          end
+        end
+
+        def move_bucket_to_subdomain(bucket_name, req)
+          req.endpoint.host = "#{bucket_name}.#{req.endpoint.host}"
+          req.path = req.path[(bucket_name.size + 1)..-1]
+          req.path = "/#{req.path}" unless req.path.match(/^\//)
+        end
+
+      end
+
+      handler(Handler)
+
+      class << self
+
+        # @param [String] bucket_name
+        # @param [Boolean] ssl
+        # @return [Boolean]
+        def dns_compatible?(bucket_name, ssl)
+          if valid_subdomain?(bucket_name)
+            bucket_name.match(/\./) && ssl ? false : true
+          else
+            false
+          end
+        end
+
+        private
+
+        def valid_subdomain?(bucket_name)
+          bucket_name.size < 64 &&
+          bucket_name =~ /^[a-z0-9][a-z0-9.-]+[a-z0-9]$/ &&
+          bucket_name !~ /(\d+\.){3}\d+/ &&
+          bucket_name !~ /[.-]{2}/
+        end
+
+      end
+    end
+  end
+end

data/lib/aws/plugins/s3_complete_multipart_upload_fix.rb

@@ -0,0 +1,38 @@
+require 'multi_xml'
+
+module Aws
+  module Plugins
+    class S3CompleteMultipartUploadFix < Seahorse::Client::Plugin
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          @handler.call(context).on_success do |response|
+            if error = check_for_error(response)
+              response.http_response.status_code = 500
+              response.data = nil
+              response.error = error
+            end
+          end
+        end
+
+        def check_for_error(response)
+          xml = MultiXml.parse(response.http_response.body_contents)
+          if xml['Error']
+            error_code = xml['Error']['Code']
+            error_message = xml['Error']['Message']
+            Errors.error_class('S3', error_code).new(error_message)
+          end
+        end
+
+      end
+
+      handler(Handler,
+        step: :build,
+        priority: 40,
+        operations: [:complete_multipart_upload]
+      )
+
+    end
+  end
+end