aws-sdk-core 3.185.1 → 3.214.0

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

@@ -27,13 +27,13 @@ module Aws
       # @return [Seahorse::Client::Response]
       def call(context)
         build_request(context)
-        @handler.call(context).on_success do |response|
-          response.error = nil
+        @handler.call(context).on_success do |resp|
+          resp.error = nil
           parsed = parse_xml(context)
           if parsed.nil? || parsed == EmptyStructure
-            response.data = EmptyStructure.new
+            resp.data = EmptyStructure.new
           else
-            response.data = parsed
+            resp.data = parsed
           end
         end
       end

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

@@ -36,7 +36,7 @@ module Aws
           return
         end
         if flat?(ref)
-          if name = query_name(member_ref)
+          if (name = query_name(ref))
             parts = prefix.split('.')
             parts.pop
             parts.push(name)
@@ -82,7 +82,7 @@ module Aws
       end
 
       def flat?(ref)
-        ref.shape.flattened
+        ref[:flattened] || ref.shape.flattened
       end
 
       def timestamp(ref, value)

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/refreshing_credentials.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'thread'
-
 module Aws
 
   # Base class used credential classes that can be refreshed. This
@@ -48,6 +46,14 @@ module Aws
 
     private
 
+    def sync_expiration_length
+      self.class::SYNC_EXPIRATION_LENGTH
+    end
+
+    def async_expiration_length
+      self.class::ASYNC_EXPIRATION_LENGTH
+    end
+
     # Refreshes credentials asynchronously and synchronously.
     # If we are near to expiration, block while getting new credentials.
     # Otherwise, if we're approaching expiration, use the existing credentials
@@ -56,18 +62,18 @@ module Aws
       # Note: This check is an optimization. Rather than acquire the mutex on every #refresh_if_near_expiration
       # call, we check before doing so, and then we check within the mutex to avoid a race condition.
       # See issue: https://github.com/aws/aws-sdk-ruby/issues/2641 for more info.
-      if near_expiration?(SYNC_EXPIRATION_LENGTH)
+      if near_expiration?(sync_expiration_length)
         @mutex.synchronize do
-          if near_expiration?(SYNC_EXPIRATION_LENGTH)
+          if near_expiration?(sync_expiration_length)
             @before_refresh.call(self) if @before_refresh
             refresh
           end
         end
-      elsif @async_refresh && near_expiration?(ASYNC_EXPIRATION_LENGTH)
+      elsif @async_refresh && near_expiration?(async_expiration_length)
         unless @mutex.locked?
           Thread.new do
             @mutex.synchronize do
-              if near_expiration?(ASYNC_EXPIRATION_LENGTH)
+              if near_expiration?(async_expiration_length)
                 @before_refresh.call(self) if @before_refresh
                 refresh
               end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Aws
+  # setup autoloading for Resources module
+  module Resources
+    autoload :Collection, 'aws-sdk-core/resources/collection'
+  end
+end

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

@@ -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,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.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)

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'