aws-sdk-core 3.178.0 → 3.233.0

data/lib/aws-sdk-core/rest/request/endpoint.rb

@@ -30,7 +30,9 @@ module Aws
         private
 
         def apply_path_params(uri, params)
-          path = uri.path.sub(/\/$/, '') + @path_pattern.split('?')[0]
+          path = uri.path.sub(%r{/$}, '')
+          # handle trailing slash
+          path += @path_pattern.split('?')[0] if path.empty? || @path_pattern != '/'
           uri.path = path.gsub(/{.+?}/) do |placeholder|
             param_value_for_placeholder(placeholder, params)
           end
@@ -38,22 +40,40 @@ module Aws
 
         def param_value_for_placeholder(placeholder, params)
           name = param_name(placeholder)
-          value = params[name].to_s
+          param_shape = @rules.shape.member(name).shape
+          value =
+            case param_shape
+            when Seahorse::Model::Shapes::TimestampShape
+              timestamp(param_shape, params[name]).to_s
+            else
+              params[name].to_s
+            end
+
           raise ArgumentError, ":#{name} must not be blank" if value.empty?
 
           if placeholder.include?('+')
-            value.gsub(/[^\/]+/) { |v| escape(v) }
+            value.gsub(%r{[^/]+}) { |v| escape(v) }
           else
             escape(value)
           end
         end
 
         def param_name(placeholder)
-          location_name = placeholder.gsub(/[{}+]/,'')
+          location_name = placeholder.gsub(/[{}+]/, '')
           param_name, _ = @rules.shape.member_by_location_name(location_name)
           param_name
         end
 
+        def timestamp(ref, value)
+          case ref['timestampFormat']
+          when 'unixTimestamp' then value.to_i
+          when 'rfc822' then value.utc.httpdate
+          else
+            # serializing as RFC 3399 date-time is the default
+            value.utc.iso8601
+          end
+        end
+
         def apply_querystring_params(uri, params)
           # collect params that are supposed to be part of the query string
           parts = @rules.shape.members.inject([]) do |prts, (member_name, member_ref)|

data/lib/aws-sdk-core/rest/request/headers.rb

@@ -21,6 +21,7 @@ module Aws
           @rules.shape.members.each do |name, ref|
             value = params[name]
             next if value.nil?
+
             case ref.location
             when 'header' then apply_header_value(http_req.headers, ref, value)
             when 'headers' then apply_header_map(http_req.headers, ref, value)
@@ -49,18 +50,25 @@ module Aws
           end
         end
 
-        def list(headers, ref, value)
-          return if !value || value.empty?
-          headers[ref.location_name] = value
-            .compact
-            .map { |s| Seahorse::Util.escape_header_list_string(s.to_s) }
-            .join(',')
+        def list(headers, ref, values)
+          return if values.nil?
+
+          member_ref = ref.shape.member
+          values = values.collect do |value|
+            case member_ref.shape
+            when TimestampShape
+              timestamp(member_ref, value).to_s
+            else
+              Seahorse::Util.escape_header_list_string(value.to_s)
+            end
+          end
+          headers[ref.location_name] = values.compact.join(', ')
         end
 
         def apply_header_map(headers, ref, values)
           prefix = ref.location_name || ''
           values.each_pair do |name, value|
-            headers["#{prefix}#{name}"] = value.to_s
+            headers["#{prefix}#{name}"] ||= value.to_s
           end
         end
 

data/lib/aws-sdk-core/rest/request/querystring_builder.rb

@@ -4,9 +4,16 @@ module Aws
   module Rest
     module Request
       class QuerystringBuilder
-
         include Seahorse::Model::Shapes
 
+        SUPPORTED_TYPES = [
+          BooleanShape,
+          FloatShape,
+          IntegerShape,
+          StringShape,
+          TimestampShape
+        ].freeze
+
         # Provide shape references and param values:
         #
         #     [
@@ -23,39 +30,32 @@ module Aws
         #
         # @return [String] Returns a built querystring
         def build(params)
+          # keys in query maps must NOT override other keys
+          query_keys = query_keys(params)
           params.map do |(shape_ref, param_value)|
-            build_part(shape_ref, param_value)
-          end.join('&')
+            build_part(shape_ref, param_value, query_keys)
+          end.reject { |p| p.nil? || p.empty? }.join('&')
         end
 
         private
 
-        def build_part(shape_ref, param_value)
+        def query_keys(params)
+          keys = Set.new
+          params.each do |(shape_ref, _)|
+            keys << shape_ref.location_name unless shape_ref.shape.is_a?(MapShape)
+          end
+          keys
+        end
+
+        def build_part(shape_ref, param_value, query_keys)
           case shape_ref.shape
           # supported scalar types
-          when StringShape, BooleanShape, FloatShape, IntegerShape, StringShape
-            param_name = shape_ref.location_name
-            "#{param_name}=#{escape(param_value.to_s)}"
-          when TimestampShape
-            param_name = shape_ref.location_name
-            "#{param_name}=#{escape(timestamp(shape_ref, param_value))}"
+          when *SUPPORTED_TYPES
+            "#{shape_ref.location_name}=#{query_value(shape_ref, param_value)}"
           when MapShape
-            if StringShape === shape_ref.shape.value.shape
-              query_map_of_string(param_value)
-            elsif ListShape === shape_ref.shape.value.shape
-              query_map_of_string_list(param_value)
-            else
-              msg = "only map of string and string list supported"
-              raise NotImplementedError, msg
-            end
+            generate_query_map(shape_ref, param_value, query_keys)
           when ListShape
-            if StringShape === shape_ref.shape.member.shape
-              list_of_strings(shape_ref.location_name, param_value)
-            else
-              msg = "Only list of strings supported, got "\
-                    "#{shape_ref.shape.member.shape.class.name}"
-              raise NotImplementedError, msg
-            end
+            generate_query_list(shape_ref, param_value)
           else
             raise NotImplementedError
           end
@@ -71,34 +71,60 @@ module Aws
           end
         end
 
-        def query_map_of_string(hash)
+        def query_value(ref, value)
+          case ref.shape
+          when TimestampShape
+            escape(timestamp(ref, value))
+          when *SUPPORTED_TYPES
+            escape(value.to_s)
+          else
+            raise NotImplementedError
+          end
+        end
+
+        def generate_query_list(ref, values)
+          member_ref = ref.shape.member
+          values.map do |value|
+            value = query_value(member_ref, value)
+            "#{ref.location_name}=#{value}"
+          end
+        end
+
+        def generate_query_map(ref, value, query_keys)
+          case ref.shape.value.shape
+          when StringShape
+            query_map_of_string(value, query_keys)
+          when ListShape
+            query_map_of_string_list(value, query_keys)
+          else
+            msg = 'Only map of string and string list supported'
+            raise NotImplementedError, msg
+          end
+        end
+
+        def query_map_of_string(hash, query_keys)
           list = []
           hash.each_pair do |key, value|
-            list << "#{escape(key)}=#{escape(value)}"
+            key = escape(key)
+            list << "#{key}=#{escape(value)}" unless query_keys.include?(key)
           end
           list
         end
 
-        def query_map_of_string_list(hash)
+        def query_map_of_string_list(hash, query_keys)
           list = []
           hash.each_pair do |key, values|
+            key = escape(key)
             values.each do |value|
-              list << "#{escape(key)}=#{escape(value)}"
+              list << "#{key}=#{escape(value)}" unless query_keys.include?(key)
             end
           end
           list
         end
 
-        def list_of_strings(name, values)
-          values.map do |value|
-            "#{name}=#{escape(value)}"
-          end
-        end
-
         def escape(string)
           Seahorse::Util.uri_escape(string)
         end
-
       end
     end
   end

data/lib/aws-sdk-core/rest/response/body.rb

@@ -20,7 +20,8 @@ module Aws
           if event_stream?
             data[@rules[:payload]] = parse_eventstream(body)
           elsif streaming?
-            data[@rules[:payload]] = body
+            # empty blob payloads are omitted
+            data[@rules[:payload]] = body unless empty_blob_payload?(body)
           elsif @rules[:payload]
             data[@rules[:payload]] = parse(body.read, @rules[:payload_member])
           elsif !@rules.shape.member_names.empty?
@@ -30,6 +31,19 @@ module Aws
 
         private
 
+        def empty_blob_payload?(body)
+          true if non_streaming_blob_payload? && empty_body?(body)
+        end
+
+        def non_streaming_blob_payload?
+          @rules[:payload_member].shape.is_a?(BlobShape) &&
+            !@rules[:payload_member]['streaming']
+        end
+
+        def empty_body?(body)
+          body.respond_to?(:size) && body.size.zero?
+        end
+
         def event_stream?
           @rules[:payload] && @rules[:payload_member].eventstream
         end

data/lib/aws-sdk-core/rest/response/header_list_parser.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'strscan'
+
+module Aws
+  module Rest
+    module Response
+      # @api private
+      module HeaderListParser
+
+        class << self
+          # parse a list of possibly quoted and escaped string values
+          # Follows:
+          # # [RFC-7230's specification of header values](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.6).
+          def parse_string_list(value)
+            buffer = StringScanner.new(value)
+            parsed = []
+
+            parsed << read_value(buffer) until buffer.eos?
+
+            parsed
+          end
+
+          def parse_timestamp_list(value, ref)
+            # timestamp lists use an http-date by default and are unescaped
+            # eg: Mon, 16 Dec 2019 23:48:18 GMT, Mon, 16 Dec 2019 23:48:18 GMT
+            case ref['timestampFormat'] || ref.shape['timestampFormat']
+            when 'unixTimestamp'
+              value.split(', ').map { |v| Time.at(v.to_f) }
+            when 'iso8601' then value.split(', ').map { |v| Time.parse(v) }
+            else
+              # header default to rfc822/http-date, which has a comma after day
+              value.split(',').each_slice(2).map { |v| Time.parse(v[0] + v[1])}
+            end
+          end
+
+          private
+
+          def read_value(buffer)
+            until buffer.eos?
+              case buffer.peek(1)
+              when ' ', "\t"
+                # drop leading whitespace
+                buffer.getch
+                next
+              when '"'
+                buffer.getch # drop the quote and advance
+                return read_quoted_value(buffer)
+              else
+                return read_unquoted_value(buffer)
+              end
+            end
+            # buffer is only whitespace
+            nil
+          end
+
+          def read_unquoted_value(buffer)
+            # there cannot be any escaped values
+            value = buffer.scan_until(/,|$/)
+            # drop the comma if we matched it
+            buffer.matched == ',' ? value.chop : value
+          end
+
+          def read_quoted_value(buffer)
+            # scan until we have an unescaped double quote
+            value = buffer.scan_until(/[^\\]"/)
+            raise ArgumentError, 'Invalid String list: No closing quote found' unless value
+
+            # drop any remaining whitespace/commas
+            buffer.scan_until(/[\s,]*/)
+            # the last character will always be the closing quote.
+            # Add a starting quote  and then unescape (undump)
+            "\"#{value}".undump
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/rest/response/headers.rb

@@ -2,6 +2,7 @@
 
 require 'time'
 require 'base64'
+require_relative 'header_list_parser'
 
 module Aws
   module Rest
@@ -36,12 +37,16 @@ module Aws
         def cast_value(ref, value)
           value = extract_json_trait(value) if ref['jsonvalue']
           case ref.shape
-          when StringShape then value
+          when StringShape then value.to_s
           when IntegerShape then value.to_i
-          when FloatShape then value.to_f
+          when FloatShape then Util.deserialize_number(value)
           when BooleanShape then value == 'true'
           when ListShape then
-            value.split(",").map { |v| cast_value(ref.shape.member, v) }
+            case ref.shape.member.shape
+            when StringShape then HeaderListParser.parse_string_list(value)
+            when TimestampShape then HeaderListParser.parse_timestamp_list(value, ref.shape.member)
+            else value.split(', ').map { |v| cast_value(ref.shape.member, v) }
+            end
           when TimestampShape
             if value =~ /^\d+(\.\d*)/
               Time.at(value.to_f)

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'rest/handler'
+require_relative 'rest/content_type_handler'
 require_relative 'rest/request/body'
 require_relative 'rest/request/builder'
 require_relative 'rest/request/endpoint'

data/lib/aws-sdk-core/rpc_v2/builder.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Aws
+  module RpcV2
+    class Builder
+      include Seahorse::Model::Shapes
+
+      def initialize(rules, _options = {})
+        @rules = rules
+      end
+
+      def serialize(params)
+        # If the input shape is empty, do not set a body. This is
+        # different than if the input shape is a structure with no members.
+        return nil if @rules.shape.struct_class == EmptyStructure
+
+        RpcV2.encode(format(@rules, params))
+      end
+
+      private
+
+      def structure(ref, values)
+        shape = ref.shape
+        values.each_pair.with_object({}) do |(key, value), data|
+          if shape.member?(key) && !value.nil?
+            member_ref = shape.member(key)
+            member_name = member_ref.location_name || key
+            data[member_name] = format(member_ref, value)
+          end
+        end
+      end
+
+      def list(ref, values)
+        member_ref = ref.shape.member
+        values.collect { |value| format(member_ref, value) }
+      end
+
+      def map(ref, values)
+        value_ref = ref.shape.value
+        values.each.with_object({}) do |(key, value), data|
+          data[key] = format(value_ref, value)
+        end
+      end
+
+      def blob(value)
+        (String === value ? value : value.read).force_encoding(Encoding::BINARY)
+      end
+
+      def format(ref, value)
+        case ref.shape
+        when StructureShape then structure(ref, value)
+        when ListShape      then list(ref, value)
+        when MapShape       then map(ref, value)
+        when BlobShape      then blob(value)
+        else value
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/rpc_v2/cbor_engine.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative '../cbor'
+
+module Aws
+  module RpcV2
+    # Pure Ruby implementation of CBOR encode and decode
+    module CborEngine
+      def self.encode(data)
+        Cbor::Encoder.new.add(data).bytes
+      end
+
+      def self.decode(bytes)
+        Cbor::Decoder.new(bytes.force_encoding(Encoding::BINARY)).decode
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/rpc_v2/content_type_handler.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Aws
+  module RpcV2
+    class ContentTypeHandler < Seahorse::Client::Handler
+      def call(context)
+        content_type =
+          if eventstream_input?(context)
+            'application/vnd.amazon.eventstream'
+          elsif !empty_input_structure?(context)
+            'application/cbor'
+          end
+        accept =
+          if eventstream_output?(context)
+            'application/vnd.amazon.eventstream'
+          else
+            'application/cbor'
+          end
+
+        headers = context.http_request.headers
+        headers['Content-Type'] ||= content_type if content_type
+        headers['Accept'] ||= accept
+        @handler.call(context)
+      end
+
+      private
+
+      def eventstream_input?(context)
+        context.operation.input.shape.members.each do |_, ref|
+          return true if ref.eventstream
+        end
+        false
+      end
+
+      def eventstream_output?(context)
+        context.operation.output.shape.members.each do |_, ref|
+          return true if ref.eventstream
+        end
+        false
+      end
+
+      def empty_input_structure?(context)
+        context.operation.input.shape.struct_class == EmptyStructure
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/rpc_v2/error_handler.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Aws
+  module RpcV2
+    # @api private
+    class ErrorHandler < Aws::ErrorHandler
+
+      def call(context)
+        # Malformed responses should throw an http based error, so we check
+        # 200 range for error handling only for this case.
+        @handler.call(context).on(200..599) do |response|
+          if !valid_response?(context)
+            code, message, data = http_status_error(context)
+            response.error = build_error(context, code, message, data)
+          elsif (300..599).cover?(context.http_response.status_code)
+            response.error = error(context)
+          end
+          response.data = nil
+        end
+      end
+
+      private
+
+      def valid_response?(context)
+        req_header = context.http_request.headers['smithy-protocol']
+        resp_header = context.http_response.headers['smithy-protocol']
+        req_header == resp_header
+      end
+
+      def extract_error(body, context)
+        data = RpcV2.decode(body)
+        code = error_code(data, context)
+        message = data['message']
+        data = parse_error_data(context, body, code)
+        [code, message, data]
+      rescue Cbor::Error
+        [http_status_error_code(context), '', EmptyStructure.new]
+      end
+
+      def error_code(data, context)
+        # This is not correct per protocol tests. awsQueryError is intended to populate the
+        # error code of the error class. The error class should come from __type. Query and
+        # query compatible services currently have dynamic errors raised from error codes instead
+        # of the modeled error class. However, changing this in this major version would break
+        # existing usage.
+        code =
+          if aws_query_error?(context)
+            aws_query_error_code(context)
+          else
+            data['__type']
+          end
+        if code
+          code.split('#').last
+        else
+          http_status_error_code(context)
+        end
+      end
+
+      def aws_query_error?(context)
+        context.config.api.metadata['awsQueryCompatible'] &&
+          context.http_response.headers['x-amzn-query-error']
+      end
+
+      def aws_query_error_code(context)
+        query_header = context.http_response.headers['x-amzn-query-error']
+        error, _type = query_header.split(';') # type not supported
+        remove_prefix(error, context)
+      end
+
+      def remove_prefix(error_code, context)
+        if (prefix = context.config.api.metadata['errorPrefix'])
+          error_code.sub(/^#{prefix}/, '')
+        else
+          error_code
+        end
+      end
+
+      def parse_error_data(context, body, code)
+        data = EmptyStructure.new
+        if (error_rules = context.operation.errors)
+          error_rules.each do |rule|
+            # match modeled shape name with the type(code) only
+            # some type(code) might contains invalid characters
+            # such as ':' (efs) etc
+            match = rule.shape.name == code.gsub(/[^^a-zA-Z0-9]/, '')
+            next unless match && rule.shape.members.any?
+
+            data = Parser.new(rule).parse(body)
+          end
+        end
+        data
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/rpc_v2/handler.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Aws
+  module RpcV2
+    class Handler < Seahorse::Client::Handler
+      # @param [Seahorse::Client::RequestContext] context
+      # @return [Seahorse::Client::Response]
+      def call(context)
+        build_request(context)
+        response = with_metric { @handler.call(context) }
+        response.on(200..299) { |resp| resp.data = parse_body(context) }
+        response.on(200..599) { |_resp| apply_request_id(context) }
+        response
+      end
+
+      private
+
+      def with_metric(&block)
+        Aws::Plugins::UserAgent.metric('PROTOCOL_RPC_V2_CBOR', &block)
+      end
+
+      def build_request(context)
+        context.http_request.headers['Smithy-Protocol'] = 'rpc-v2-cbor'
+        context.http_request.headers['X-Amzn-Query-Mode'] = 'true' if query_compatible?(context)
+        context.http_request.http_method = 'POST'
+        context.http_request.body = build_body(context)
+        build_url(context)
+      end
+
+      def build_url(context)
+        base = context.http_request.endpoint
+        service_name = context.config.api.metadata['targetPrefix']
+        base.path += "/service/#{service_name}/operation/#{context.operation.name}"
+      end
+
+      def build_body(context)
+        Builder.new(context.operation.input).serialize(context.params)
+      end
+
+      def parse_body(context)
+        cbor = context.http_response.body_contents
+        if (rules = context.operation.output)
+          if cbor.is_a?(Array)
+            # an array of emitted events
+            if cbor[0].respond_to?(:response)
+              # initial response exists
+              # it must be the first event arrived
+              resp_struct = cbor.shift.response
+            else
+              resp_struct = context.operation.output.shape.struct_class.new
+            end
+
+            rules.shape.members.each do |name, ref|
+              if ref.eventstream
+                resp_struct.send("#{name}=", cbor.to_enum)
+              end
+            end
+            resp_struct
+          else
+            Parser.new(
+              rules,
+              query_compatible: query_compatible?(context)
+            ).parse(cbor)
+          end
+        else
+          EmptyStructure.new
+        end
+      end
+
+      def apply_request_id(context)
+        context[:request_id] = context.http_response.headers['x-amzn-requestid']
+      end
+
+      def query_compatible?(context)
+        context.config.api.metadata.key?('awsQueryCompatible')
+      end
+    end
+  end
+end