aws-sdk-core 3.189.0 → 3.199.0

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

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'query/ec2_param_builder'
 require_relative 'query/handler'
+require_relative 'query/ec2_handler'
 require_relative 'query/param'
 require_relative 'query/param_builder'
+require_relative 'query/ec2_param_builder'
 require_relative 'query/param_list'

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Aws
+  module Rest
+    # NOTE: headers could be already populated if specified on input shape
+    class ContentTypeHandler < Seahorse::Client::Handler
+      def call(context)
+        if eventstream?(context)
+          context.http_request.headers['Content-Type'] ||=
+            'application/vnd.amazon.eventstream'
+        elsif (payload = context.operation.input[:payload_member])
+          case payload.shape
+          when Seahorse::Model::Shapes::BlobShape
+            context.http_request.headers['Content-Type'] ||=
+              'application/octet-stream'
+          when Seahorse::Model::Shapes::StringShape
+            context.http_request.headers['Content-Type'] ||=
+              'text/plain'
+          else
+            apply_default_content_type(context)
+          end
+        elsif (body = context.http_request.body) &&
+              (!body.respond_to?(:size) || non_empty_body?(body))
+          apply_default_content_type(context)
+        end
+
+        @handler.call(context)
+      end
+
+      private
+
+      def non_empty_body?(body)
+        body.respond_to?(:size) && body.size.positive?
+      end
+
+      def eventstream?(context)
+        context.operation.input.shape.members.each do |_, ref|
+          return true if ref.eventstream
+        end
+        false
+      end
+
+      # content-type defaults as noted here:
+      # rest-json: https://smithy.io/2.0/aws/protocols/aws-restxml-protocol.html#content-type
+      # rest-xml: https://smithy.io/2.0/aws/protocols/aws-restxml-protocol.html#content-type
+      def apply_default_content_type(context)
+        protocol = context.config.api.metadata['protocol']
+        case protocol
+        when 'rest-json'
+          context.http_request.headers['Content-Type'] ||=
+            'application/json'
+        when 'rest-xml'
+          context.http_request.headers['Content-Type'] ||=
+            'application/xml'
+        else raise "Unsupported protocol #{protocol}"
+        end
+      end
+    end
+  end
+end

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

@@ -7,10 +7,9 @@ module Aws
 
       def call(context)
         Rest::Request::Builder.new.apply(context)
-        resp = @handler.call(context)
-        resp.on(200..299) { |response| Response::Parser.new.apply(response) }
-        resp.on(200..599) { |response| apply_request_id(context) }
-        resp
+        response = @handler.call(context)
+        response.on(200..299) { |resp| Response::Parser.new.apply(resp) }
+        response.on(200..599) { |_resp| apply_request_id(context) }
       end
 
       private

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

@@ -18,10 +18,13 @@ module Aws
         # @param [Hash] params
         def apply(http_req, params)
           body = build_body(params)
+
           # for rest-json, ensure we send at least an empty object
           # don't send an empty object for streaming? case.
-          if body.nil? && @serializer_class == Json::Builder &&
-             modeled_body? && !streaming?
+          if body.nil? &&
+             json_builder? &&
+             modeled_body? &&
+             !streaming?
             body = '{}'
           end
           http_req.body = body
@@ -45,13 +48,29 @@ module Aws
             params[@rules[:payload]]
           elsif @rules[:payload]
             params = params[@rules[:payload]]
-            serialize(@rules[:payload_member], params) if params
+            if params
+              if xml_builder? &&
+                 @rules.shape.member?(@rules[:payload_member].location_name)
+                # serializing payload member name for rest-xml is as follows:
+                # 1. Use the member locationName if the member value doesn't match the member's name (default)
+                # 2. Use the value of the locationName on the member's target if present
+                # 3. Use the shape name of the member's target
+                serialize(@rules[:payload_member], params, location_name: payload_location_name)
+              else
+                serialize(@rules[:payload_member], params)
+              end
+            end
           else
             params = body_params(params)
             serialize(@rules, params) unless params.empty?
           end
         end
 
+        def payload_location_name
+          @rules[:payload_member].shape['locationName'] ||
+            @rules[:payload_member].shape.name
+        end
+
         def streaming?
           @rules[:payload] && (
             BlobShape === @rules[:payload_member].shape ||
@@ -59,8 +78,16 @@ module Aws
           )
         end
 
-        def serialize(rules, params)
-          @serializer_class.new(rules).serialize(params)
+        def xml_builder?
+          @serializer_class == Xml::Builder
+        end
+
+        def json_builder?
+          @serializer_class == Json::Builder
+        end
+
+        def serialize(rules, params, location_name: nil)
+          @serializer_class.new(rules, location_name: location_name).serialize(params)
         end
 
         def body_params(params)

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

@@ -20,7 +20,8 @@ module Aws
         def apply(http_req, params)
           @rules.shape.members.each do |name, ref|
             value = params[name]
-            next if value.nil?
+            next if value.nil? || ((ref.shape).is_a?(StringShape) && value.empty?)
+
             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,12 +50,19 @@ 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 || values.empty?
+
+          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)

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
+
+        Cbor.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/content_type_handler.rb

@@ -0,0 +1,45 @@
+# 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'
+          end
+
+        headers = context.http_request.headers
+        headers['Content-Type'] ||= content_type if content_type
+        headers['Accept'] ||= accept if 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,84 @@
+# frozen_string_literal: true
+
+module Aws
+  module RpcV2
+    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 = Cbor.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)
+        code =
+          if aws_query_error?(context)
+            error = context.http_response.headers['x-amzn-query-error'].split(';')[0]
+            remove_prefix(error, context)
+          else
+            data['__type']
+          end
+        if code
+          code.split('#').last
+        else
+          http_status_error_code(context)
+        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
+
+      def aws_query_error?(context)
+        context.config.api.metadata['awsQueryCompatible'] &&
+          context.http_response.headers['x-amzn-query-error']
+      end
+
+      def remove_prefix(error_code, context)
+        if (prefix = context.config.api.metadata['errorPrefix'])
+          error_code.sub(/^#{prefix}/, '')
+        else
+          error_code
+        end
+      end
+    end
+  end
+end