aws-sdk-core 3.191.1 → 3.229.0

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

@@ -30,20 +30,30 @@ 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 *SUPPORTED_TYPES
             "#{shape_ref.location_name}=#{query_value(shape_ref, param_value)}"
           when MapShape
-            generate_query_map(shape_ref, param_value)
+            generate_query_map(shape_ref, param_value, query_keys)
           when ListShape
             generate_query_list(shape_ref, param_value)
           else
@@ -80,31 +90,33 @@ module Aws
           end
         end
 
-        def generate_query_map(ref, value)
+        def generate_query_map(ref, value, query_keys)
           case ref.shape.value.shape
           when StringShape
-            query_map_of_string(value)
+            query_map_of_string(value, query_keys)
           when ListShape
-            query_map_of_string_list(value)
+            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)
+        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

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

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Aws
+  module RpcV2
+    class Parser
+      include Seahorse::Model::Shapes
+
+      # @param [Seahorse::Model::ShapeRef] rules
+      def initialize(rules, query_compatible: false)
+        @rules = rules
+        @query_compatible = query_compatible
+      end
+
+      def parse(cbor, target = nil)
+        return {} if cbor.empty?
+
+        parse_ref(@rules, RpcV2.decode(cbor), target)
+      end
+
+      private
+
+      def structure(ref, values, target = nil)
+        shape = ref.shape
+        target = ref.shape.struct_class.new if target.nil?
+        values.each do |key, value|
+          member_name, member_ref = shape.member_by_location_name(key)
+          if member_ref
+            target[member_name] = parse_ref(member_ref, value)
+          elsif shape.union && key != '__type'
+            target[:unknown] = { 'name' => key, 'value' => value }
+          end
+        end
+        # In services that were previously Query/XML, members that were
+        # "flattened" defaulted to empty lists. In JSON, these values are nil,
+        # which is backwards incompatible. To preserve backwards compatibility,
+        # we set a default value of [] for these members.
+        if @query_compatible
+          ref.shape.members.each do |member_name, member_target|
+            next unless target[member_name].nil?
+
+            if flattened_list?(member_target.shape)
+              target[member_name] = []
+            elsif flattened_map?(member_target.shape)
+              target[member_name] = {}
+            end
+          end
+        end
+
+        if shape.union
+          # convert to subclass
+          member_subclass = shape.member_subclass(target.member).new
+          member_subclass[target.member] = target.value
+          target = member_subclass
+        end
+        target
+      end
+
+      def list(ref, values, target = nil)
+        target = [] if target.nil?
+        values.each do |value|
+          target << parse_ref(ref.shape.member, value)
+        end
+        target
+      end
+
+      def map(ref, values, target = nil)
+        target = {} if target.nil?
+        values.each do |key, value|
+          target[key] = parse_ref(ref.shape.value, value) unless value.nil?
+        end
+        target
+      end
+
+      def parse_ref(ref, value, target = nil)
+        if value.nil?
+          nil
+        else
+          case ref.shape
+          when StructureShape then structure(ref, value, target)
+          when ListShape then list(ref, value, target)
+          when MapShape then map(ref, value, target)
+          else value
+          end
+        end
+      end
+
+      def flattened_list?(shape)
+        shape.is_a?(ListShape) && shape.flattened
+      end
+
+      def flattened_map?(shape)
+        shape.is_a?(MapShape) && shape.flattened
+      end
+    end
+  end
+end