aws-sdk-core 2.0.48 → 2.1.0

data/lib/aws-sdk-core/param_validator.rb

@@ -0,0 +1,148 @@
+module Aws
+  # @api private
+  class ParamValidator
+
+    include Seahorse::Model::Shapes
+
+    # @param [Seahorse::Model::Shapes::ShapeRef] rules
+    # @param [Hash] params
+    # @return [void]
+    def self.validate!(rules, params)
+      new(rules).validate!(params)
+    end
+
+    # @param [Seahorse::Model::Shapes::ShapeRef] rules
+    # @option options [Boolean] :validate_required (true)
+    def initialize(rules, options = {})
+      @rules = rules
+      @validate_required = options[:validate_required] != false
+    end
+
+    # @param [Hash] params
+    # @return [void]
+    def validate!(params)
+      errors = []
+      structure(@rules, params, errors, 'params') if @rules
+      raise ArgumentError, error_messages(errors) unless errors.empty?
+    end
+
+    private
+
+    def structure(ref, values, errors, context)
+      # ensure the value is hash like
+      return unless correct_type?(ref, values, errors, context)
+
+      shape = ref.shape
+
+      # ensure required members are present
+      if @validate_required
+        shape.required.each do |member_name|
+          if values[member_name].nil?
+            param = "#{context}[#{member_name.inspect}]"
+            errors << "missing required parameter #{param}"
+          end
+        end
+      end
+
+      # validate non-nil members
+      values.each_pair do |name, value|
+        unless value.nil?
+          if shape.member?(name)
+            member_ref = shape.member(name)
+            shape(member_ref, value, errors, context + "[#{name.inspect}]")
+          else
+            errors << "unexpected value at #{context}[#{name.inspect}]"
+          end
+        end
+      end
+    end
+
+    def list(ref, values, errors, context)
+      # ensure the value is an array
+      unless values.is_a?(Array)
+        errors << "expected #{context} to be an array"
+        return
+      end
+
+      # validate members
+      member_ref = ref.shape.member
+      values.each.with_index do |value, index|
+        shape(member_ref, value, errors, context + "[#{index}]")
+      end
+    end
+
+    def map(ref, values, errors, context)
+
+      return unless correct_type?(ref, values, errors, context)
+
+      key_ref = ref.shape.key
+      value_ref = ref.shape.value
+
+      values.each do |key, value|
+        shape(key_ref, key, errors, "#{context} #{key.inspect} key")
+        shape(value_ref, value, errors, context + "[#{key.inspect}]")
+      end
+    end
+
+    def shape(ref, value, errors, context)
+      case ref.shape
+      when StructureShape then structure(ref, value, errors, context)
+      when ListShape then list(ref, value, errors, context)
+      when MapShape then map(ref, value, errors, context)
+      when StringShape
+        unless value.is_a?(String)
+          errors << "expected #{context} to be a string"
+        end
+      when IntegerShape
+        unless value.is_a?(Integer)
+          errors << "expected #{context} to be an integer"
+        end
+      when FloatShape
+        unless value.is_a?(Float)
+          errors << "expected #{context} to be a float"
+        end
+      when TimestampShape
+        unless value.is_a?(Time)
+          errors << "expected #{context} to be a Time object"
+        end
+      when BooleanShape
+        unless [true, false].include?(value)
+          errors << "expected #{context} to be true or false"
+        end
+      when BlobShape
+        unless io_like?(value) or value.is_a?(String)
+          errors << "expected #{context} to be a string or IO object"
+        end
+      else
+        raise "unhandled shape type: #{ref.shape.class.name}"
+      end
+    end
+
+    def correct_type?(ref, value, errors, context)
+      case value
+      when Hash then true
+      when ref[:struct_class] then true
+      else
+        errors << "expected #{context} to be a hash"
+        false
+      end
+    end
+
+    def io_like?(value)
+      value.respond_to?(:read) &&
+      value.respond_to?(:rewind) &&
+      value.respond_to?(:size)
+    end
+
+    def error_messages(errors)
+      if errors.size == 1
+        errors.first
+      else
+        prefix = "\n  - "
+        "parameter validator found #{errors.size} errors:" +
+          prefix + errors.join(prefix)
+      end
+    end
+
+  end
+end

data/lib/aws-sdk-core/plugins/dynamodb_simple_attributes.rb

@@ -137,20 +137,21 @@ module Aws
       # @api private
       class ValueTranslator
 
-        # @param [Seahorse::Model::Shapes::Shape] shape
-        # @param [Symbol<:marshal,:unmarshal>] mode
-        def initialize(shape, mode)
-          @shape = shape
+        include Seahorse::Model::Shapes
+
+        def initialize(rules, mode)
+          @rules = rules
           @mode = mode
         end
 
         def apply(values)
-          structure(@shape, values) if @shape
+          structure(@rules, values) if @rules
         end
 
         private
 
-        def structure(shape, values)
+        def structure(ref, values)
+          shape = ref.shape
           if values.is_a?(Struct)
             values.members.each do |key|
               values[key] = translate(shape.member(key), values[key])
@@ -165,33 +166,35 @@ module Aws
           end
         end
 
-        def list(shape, values)
+        def list(ref, values)
           return values unless values.is_a?(Array)
+          member_ref = ref.shape.member
           values.inject([]) do |list, value|
-            list << translate(shape.member, value)
+            list << translate(member_ref, value)
           end
         end
 
-        def map(shape, values)
+        def map(ref, values)
           return values unless values.is_a?(Hash)
+          value_ref = ref.shape.value
           values.each.with_object({}) do |(key, value), hash|
-            hash[key] = translate(shape.value, value)
+            hash[key] = translate(value_ref, value)
           end
         end
 
-        def translate(shape, value)
-          if shape.name == 'AttributeValue'
+        def translate(ref, value)
+          if ref.shape.name == 'AttributeValue'
             DynamoDB::AttributeValue.new.send(@mode, value)
           else
-            translate_complex(shape, value)
+            translate_complex(ref, value)
           end
         end
 
-        def translate_complex(shape, value)
-          case shape
-          when Seahorse::Model::Shapes::Structure then structure(shape, value)
-          when Seahorse::Model::Shapes::List then list(shape, value)
-          when Seahorse::Model::Shapes::Map then map(shape, value)
+        def translate_complex(ref, value)
+          case ref.shape
+          when StructureShape then structure(ref, value)
+          when ListShape then list(ref, value)
+          when MapShape then map(ref, value)
           else value
           end
         end

data/lib/aws-sdk-core/plugins/glacier_account_id.rb

@@ -1,11 +1,19 @@
 module Aws
   module Plugins
+
+    # @seahorse.client.option [String] :account_id ('-')
+    #   The default Glacier AWS account ID to use for all glacier
+    #   operations. The default value of `-` uses the account
+    #   your `:credentials` belong to.
+    #
     class GlacierAccountId < Seahorse::Client::Plugin
+
       option :account_id, '-'
 
-      handle_request(step: :validate, priority: 99) do |context|
+      handle_request(step: :initialize) do |context|
         context.params[:account_id] ||= context.config.account_id
       end
+
     end
   end
 end

data/lib/aws-sdk-core/plugins/glacier_checksums.rb

@@ -30,6 +30,7 @@ module Aws
       class Handler < Seahorse::Client::Handler
 
         HASH = 'X-Amz-Content-Sha256'
+
         TREE_HASH = 'X-Amz-Sha256-Tree-Hash'
 
         def call(context)
@@ -65,12 +66,10 @@ module Aws
             digest.update('')
           end
 
-          until body.eof?
-            chunk = body.read(1024 * 1024) # read 1MB
+          while chunk = body.read(1024 * 1024) # read 1MB
             tree_hash.update(chunk)
             digest.update(chunk)
           end
-
           body.rewind
 
           yield(digest.to_s, tree_hash)

data/lib/aws-sdk-core/plugins/param_converter.rb

@@ -0,0 +1,27 @@
+module Aws
+  module Plugins
+
+    # @seahorse.client.option [Boolean] :convert_params (true)
+    #   When `true`, an attempt is made to coerce request parameters
+    #   into the required types.
+    class ParamConverter < Seahorse::Client::Plugin
+
+      option(:convert_params, true)
+
+      def add_handlers(handlers, config)
+        handlers.add(Handler, step: :initialize) if config.convert_params
+      end
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          if input = context.operation.input
+            context.params = Aws::ParamConverter.convert(input, context.params)
+          end
+          @handler.call(context)
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/param_validator.rb

@@ -0,0 +1,28 @@
+module Aws
+  module Plugins
+
+    # @seahorse.client.option [Boolean] :validate_params (true)
+    #   When `true`, request parameters are validated before
+    #   sending the request.
+    class ParamValidator < Seahorse::Client::Plugin
+
+      option(:validate_params, true)
+
+      def add_handlers(handlers, config)
+        if config.validate_params
+          handlers.add(Handler, step: :validate, priority: 50)
+        end
+      end
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          Aws::ParamValidator.validate!(context.operation.input, context.params)
+          @handler.call(context)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/protocols/json_rpc.rb

@@ -20,13 +20,9 @@ module Aws
 
         option(:convert_params) { |config| !config.simple_json }
 
-        def add_handlers(handlers, config)
-          handlers.add(Json::ErrorHandler, step: :sign)
-          handlers.add(Json::RpcHeadersHandler)
-          handlers.add(config.simple_json ?
-            Json::SimpleBodyHandler :
-            Json::RpcBodyHandler)
-        end
+        handler(Json::Handler)
+
+        handler(Json::ErrorHandler, step: :sign)
 
       end
     end

data/lib/aws-sdk-core/plugins/protocols/rest_json.rb

@@ -3,8 +3,7 @@ module Aws
     module Protocols
       class RestJson < Seahorse::Client::Plugin
 
-        handler(Json::RestHandler)
-
+        handler(Rest::Handler)
         handler(Json::ErrorHandler, step: :sign)
 
       end

data/lib/aws-sdk-core/plugins/protocols/rest_xml.rb

@@ -3,7 +3,7 @@ module Aws
     module Protocols
       class RestXml < Seahorse::Client::Plugin
 
-        handler(Xml::RestHandler)
+        handler(Rest::Handler)
         handler(Xml::ErrorHandler, step: :sign)
 
       end

data/lib/aws-sdk-core/plugins/regional_endpoint.rb

@@ -20,7 +20,7 @@ module Aws
       }
 
       option(:endpoint) do |cfg|
-        EndpointProvider.resolve(cfg.region, cfg.api.metadata('endpointPrefix'))
+        EndpointProvider.resolve(cfg.region, cfg.api.metadata['endpointPrefix'])
       end
 
       def after_initialize(client)

data/lib/aws-sdk-core/plugins/request_signer.rb

@@ -40,15 +40,15 @@ module Aws
       # Intentionally not documented - this should go away when all
       # services support signature version 4 in every region.
       option(:signature_version) do |cfg|
-        cfg.api.metadata('signatureVersion')
+        cfg.api.metadata['signatureVersion']
       end
 
       option(:sigv4_name) do |cfg|
-        cfg.api.metadata('signingName') || cfg.api.metadata('endpointPrefix')
+        cfg.api.metadata['signingName'] || cfg.api.metadata['endpointPrefix']
       end
 
       option(:sigv4_region) do |cfg|
-        prefix = cfg.api.metadata('endpointPrefix')
+        prefix = cfg.api.metadata['endpointPrefix']
         endpoint = cfg.endpoint.to_s
         if matches = endpoint.match(/#{prefix}[.-](.+)\.amazonaws\.com/)
           matches[1] == 'us-gov' ? 'us-gov-west-1' : matches[1]
@@ -101,9 +101,9 @@ module Aws
         end
 
         def unsigned_request?(context)
-          if context.config.api.metadata('endpointPrefix') == 'sts'
+          if context.config.api.metadata['endpointPrefix'] == 'sts'
             STS_UNSIGNED_REQUESTS.include?(context.operation.name)
-          elsif context.config.api.metadata('endpointPrefix') == 'cloudsearchdomain'
+          elsif context.config.api.metadata['endpointPrefix'] == 'cloudsearchdomain'
             context.config.credentials.nil? || !context.config.credentials.set?
           else
             false

data/lib/aws-sdk-core/plugins/response_paging.rb

@@ -2,24 +2,33 @@ module Aws
   module Plugins
     class ResponsePaging < Seahorse::Client::Plugin
 
-      # @api private
-      class Handler < Seahorse::Client::Handler
+      def add_handlers(handlers, config)
+        handlers.add(Handler,
+          operations: pageable_operations(config),
+          step: :initialize,
+          priority: 90)
+      end
 
-        def call(context)
-          context[:original_params] = context.params
-          PageableResponse.new(@handler.call(context), pager(context))
+      private
+
+      def pageable_operations(config)
+        config.api.operations.inject([]) do |pageable, (name, operation)|
+          pageable << name if operation[:pager]
+          pageable
         end
+      end
 
-        private
+      # @api private
+      class Handler < Seahorse::Client::Handler
 
-        def pager(context)
-          context.client.class.paginators.pager(context.operation.name)
+        def call(context)
+          resp = @handler.call(context)
+          resp.extend(PageableResponse)
+          resp.pager = context.operation[:pager]
+          resp
         end
 
       end
-
-      handler(Handler, step: :initialize, priority: 90)
-
     end
   end
 end