aws-sdk-core 3.117.0 → 3.197.2

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/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
@@ -17,45 +15,78 @@ module Aws
   # @api private
   module RefreshingCredentials
 
+    SYNC_EXPIRATION_LENGTH = 300 # 5 minutes
+    ASYNC_EXPIRATION_LENGTH = 600 # 10 minutes
+
+    CLIENT_EXCLUDE_OPTIONS = Set.new([:before_refresh]).freeze
+
     def initialize(options = {})
       @mutex = Mutex.new
+      @before_refresh = options.delete(:before_refresh) if Hash === options
+
+      @before_refresh.call(self) if @before_refresh
       refresh
     end
 
     # @return [Credentials]
     def credentials
-      refresh_if_near_expiration
+      refresh_if_near_expiration!
       @credentials
     end
 
-    # @return [Time,nil]
-    def expiration
-      refresh_if_near_expiration
-      @expiration
-    end
-
     # Refresh credentials.
     # @return [void]
     def refresh!
-      @mutex.synchronize { refresh }
+      @mutex.synchronize do
+        @before_refresh.call(self) if @before_refresh
+
+        refresh
+      end
     end
 
     private
 
-    # Refreshes instance metadata credentials if they are within
-    # 5 minutes of expiration.
-    def refresh_if_near_expiration
-      if near_expiration?
+    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
+    # but attempt a refresh in the background.
+    def refresh_if_near_expiration!
+      # 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)
         @mutex.synchronize do
-          refresh if near_expiration?
+          if near_expiration?(sync_expiration_length)
+            @before_refresh.call(self) if @before_refresh
+            refresh
+          end
+        end
+      elsif @async_refresh && near_expiration?(async_expiration_length)
+        unless @mutex.locked?
+          Thread.new do
+            @mutex.synchronize do
+              if near_expiration?(async_expiration_length)
+                @before_refresh.call(self) if @before_refresh
+                refresh
+              end
+            end
+          end
         end
       end
     end
 
-    def near_expiration?
+    def near_expiration?(expiration_length)
       if @expiration
-        # are we within 5 minutes of expiration?
-        (Time.now.to_i + 5 * 60) > @expiration.to_i
+        # Are we within expiration?
+        (Time.now.to_i + expiration_length) > @expiration.to_i
       else
         true
       end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'thread'
+
+module Aws
+
+  # Module/mixin used by token provider classes that can be refreshed. This
+  # provides basic refresh logic in a thread-safe manner. Classes mixing in
+  # this module are expected to implement a #refresh method that populates
+  # the following instance variable:
+  #
+  # * `@token` [Token] - {Aws::Token} object with the `expiration` and `token`
+  #       fields set.
+  #
+  # @api private
+  module RefreshingToken
+
+    def initialize(options = {})
+      @mutex = Mutex.new
+      @before_refresh = options.delete(:before_refresh) if Hash === options
+
+      @before_refresh.call(self) if @before_refresh
+      refresh
+    end
+
+    # @return [Token]
+    def token
+      refresh_if_near_expiration
+      @token
+    end
+
+    # @return [Time,nil]
+    def expiration
+      refresh_if_near_expiration
+      @expiration
+    end
+
+    # Refresh token.
+    # @return [void]
+    def refresh!
+      @mutex.synchronize do
+        @before_refresh.call(self) if @before_refresh
+        refresh
+      end
+    end
+
+    private
+
+    # Refreshes token if it is within
+    # 5 minutes of expiration.
+    def refresh_if_near_expiration
+      if near_expiration?
+        @mutex.synchronize do
+          if near_expiration?
+            @before_refresh.call(self) if @before_refresh
+            refresh
+          end
+        end
+      end
+    end
+
+    def near_expiration?
+      if @token && @token.expiration
+        # are we within 5 minutes of expiration?
+        (Time.now.to_i + 5 * 60) > @token.expiration.to_i
+      else
+        true
+      end
+    end
+  end
+end

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

@@ -17,7 +17,7 @@ module Aws
 
       def apply_request_id(context)
         h = context.http_response.headers
-        context[:request_id] = h['x-amz-request-id'] || h['x-amzn-requestid']
+        context[:request_id] ||= h['x-amz-request-id'] || h['x-amzn-requestid']
       end
 
     end

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

@@ -17,23 +17,60 @@ module Aws
         # @param [Seahorse::Client::Http::Request] http_req
         # @param [Hash] params
         def apply(http_req, params)
-          http_req.body = build_body(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? &&
+             json_builder? &&
+             modeled_body? &&
+             !streaming?
+            body = '{}'
+          end
+          http_req.body = body
         end
 
         private
 
+        # operation is modeled for body when it is modeled for a payload
+        # either with payload trait or normal members.
+        def modeled_body?
+          return true if @rules[:payload]
+          @rules.shape.members.each do |member|
+            _name, shape = member
+            return true if shape.location.nil?
+          end
+          false
+        end
+
         def build_body(params)
           if streaming?
             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 ||
@@ -41,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/content_type.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 ref 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/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)
@@ -32,11 +33,11 @@ module Aws
 
         def apply_header_value(headers, ref, value)
           value = apply_json_trait(value) if ref['jsonvalue']
-          headers[ref.location_name] =
-            case ref.shape
-            when TimestampShape then timestamp(ref, value)
-            else value.to_s
-            end
+          case ref.shape
+          when TimestampShape then headers[ref.location_name] = timestamp(ref, value)
+          when ListShape then list(headers, ref, value)
+          else headers[ref.location_name] = value.to_s
+          end
         end
 
         def timestamp(ref, value)
@@ -49,6 +50,21 @@ module Aws
           end
         end
 
+        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)
           prefix = ref.location_name || ''
           values.each_pair do |name, value|
@@ -57,7 +73,7 @@ module Aws
         end
 
         # With complex headers value in json syntax,
-        # base64 encodes value to aviod weird characters
+        # base64 encodes value to avoid weird characters
         # causing potential issues in headers
         def apply_json_trait(value)
           Base64.strict_encode64(value)

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