aws-sdk-core 3.152.0 → 3.234.0

data/lib/aws-sdk-core/plugins/user_agent.rb

@@ -4,7 +4,93 @@ module Aws
   module Plugins
     # @api private
     class UserAgent < Seahorse::Client::Plugin
+      METRICS = Aws::Json.load(<<-METRICS)
+        {
+          "RESOURCE_MODEL": "A",
+          "WAITER": "B",
+          "PAGINATOR": "C",
+          "RETRY_MODE_LEGACY": "D",
+          "RETRY_MODE_STANDARD": "E",
+          "RETRY_MODE_ADAPTIVE": "F",
+          "S3_TRANSFER": "G",
+          "S3_CRYPTO_V1N": "H",
+          "S3_CRYPTO_V2": "I",
+          "S3_EXPRESS_BUCKET": "J",
+          "S3_ACCESS_GRANTS": "K",
+          "GZIP_REQUEST_COMPRESSION": "L",
+          "PROTOCOL_RPC_V2_CBOR": "M",
+          "ENDPOINT_OVERRIDE": "N",
+          "ACCOUNT_ID_ENDPOINT": "O",
+          "ACCOUNT_ID_MODE_PREFERRED": "P",
+          "ACCOUNT_ID_MODE_DISABLED": "Q",
+          "ACCOUNT_ID_MODE_REQUIRED": "R",
+          "SIGV4A_SIGNING": "S",
+          "RESOLVED_ACCOUNT_ID": "T",
+          "FLEXIBLE_CHECKSUMS_REQ_CRC32" : "U",
+          "FLEXIBLE_CHECKSUMS_REQ_CRC32C" : "V",
+          "FLEXIBLE_CHECKSUMS_REQ_CRC64" : "W",
+          "FLEXIBLE_CHECKSUMS_REQ_SHA1" : "X",
+          "FLEXIBLE_CHECKSUMS_REQ_SHA256" : "Y",
+          "FLEXIBLE_CHECKSUMS_REQ_WHEN_SUPPORTED" : "Z",
+          "FLEXIBLE_CHECKSUMS_REQ_WHEN_REQUIRED" : "a",
+          "FLEXIBLE_CHECKSUMS_RES_WHEN_SUPPORTED" : "b",
+          "FLEXIBLE_CHECKSUMS_RES_WHEN_REQUIRED" : "c",
+          "DDB_MAPPER": "d",
+          "CREDENTIALS_CODE" : "e",
+          "CREDENTIALS_ENV_VARS" : "g",
+          "CREDENTIALS_ENV_VARS_STS_WEB_ID_TOKEN" : "h",
+          "CREDENTIALS_STS_ASSUME_ROLE" : "i",
+          "CREDENTIALS_STS_ASSUME_ROLE_WEB_ID" : "k",
+          "CREDENTIALS_PROFILE" : "n",
+          "CREDENTIALS_PROFILE_SOURCE_PROFILE" : "o",
+          "CREDENTIALS_PROFILE_NAMED_PROVIDER" : "p",
+          "CREDENTIALS_PROFILE_STS_WEB_ID_TOKEN" : "q",
+          "CREDENTIALS_PROFILE_SSO" : "r",
+          "CREDENTIALS_SSO" : "s",
+          "CREDENTIALS_PROFILE_SSO_LEGACY" : "t",
+          "CREDENTIALS_SSO_LEGACY" : "u",
+          "CREDENTIALS_PROFILE_PROCESS" : "v",
+          "CREDENTIALS_PROCESS" : "w",
+          "CREDENTIALS_HTTP" : "z",
+          "CREDENTIALS_IMDS" : "0",
+          "SSO_LOGIN_DEVICE" : "1",
+          "SSO_LOGIN_AUTH" : "2",
+          "BEARER_SERVICE_ENV_VARS": "3"
+        }
+      METRICS
+
+      # @api private
       option(:user_agent_suffix)
+      # @api private
+      option(:user_agent_frameworks, default: [])
+
+      option(
+        :sdk_ua_app_id,
+        doc_type: 'String',
+        docstring: <<-DOCS) do |cfg|
+A unique and opaque application ID that is appended to the
+User-Agent header as app/sdk_ua_app_id. It should have a
+maximum length of 50. This variable is sourced from environment
+variable AWS_SDK_UA_APP_ID or the shared config profile attribute sdk_ua_app_id.
+        DOCS
+        app_id = ENV['AWS_SDK_UA_APP_ID']
+        app_id ||= Aws.shared_config.sdk_ua_app_id(profile: cfg.profile)
+        app_id
+      end
+
+      # Deprecated - must exist for old service gems
+      def self.feature(_feature, &block)
+        block.call
+      end
+
+      def self.metric(*metrics, &block)
+        Thread.current[:aws_sdk_core_user_agent_metric] ||= []
+        metrics = metrics.map { |metric| METRICS[metric] }.compact
+        Thread.current[:aws_sdk_core_user_agent_metric].concat(metrics)
+        block.call
+      ensure
+        Thread.current[:aws_sdk_core_user_agent_metric].pop(metrics.size)
+      end
 
       # @api private
       class Handler < Seahorse::Client::Handler
@@ -14,33 +100,125 @@ module Aws
         end
 
         def set_user_agent(context)
-          ua = "aws-sdk-ruby3/#{CORE_GEM_VERSION}"
+          context.http_request.headers['User-Agent'] = UserAgent.new(context).to_s
+        end
+
+        class UserAgent
+          def initialize(context)
+            @context = context
+          end
+
+          def to_s
+            ua = "aws-sdk-ruby3/#{CORE_GEM_VERSION}"
+            ua += ' ua/2.1'
+            if (api_m = api_metadata)
+              ua += " #{api_m}"
+            end
+            ua += " #{os_metadata}"
+            ua += " #{language_metadata}"
+            if (env_m = env_metadata)
+              ua += " #{env_m}"
+            end
+            if (app_id_m = app_id_metadata)
+              ua += " #{app_id_m}"
+            end
+            if (framework_m = framework_metadata)
+              ua += " #{framework_m}"
+            end
+            if (metric_m = metric_metadata)
+              ua += " #{metric_m}"
+            end
+            if @context.config.user_agent_suffix
+              ua += " #{@context.config.user_agent_suffix}"
+            end
+            ua.strip
+          end
+
+          private
 
-          begin
-            ua += " #{RUBY_ENGINE}/#{RUBY_VERSION}"
-          rescue
-            ua += " RUBY_ENGINE_NA/#{RUBY_VERSION}"
+          # Used to be gem_name/gem_version
+          def api_metadata
+            service_id = @context.config.api.metadata['serviceId']
+            return unless service_id
+
+            service_id = service_id.gsub(' ', '_').downcase
+            gem_version = @context[:gem_version]
+            "api/#{service_id}##{gem_version}"
           end
 
-          ua += " #{RUBY_PLATFORM}"
+          # Used to be RUBY_PLATFORM
+          def os_metadata
+            os =
+              case RbConfig::CONFIG['host_os']
+              when /mac|darwin/
+                'macos'
+              when /linux|cygwin/
+                'linux'
+              when /mingw|mswin/
+                'windows'
+              else
+                'other'
+              end
+            metadata = "os/#{os}"
+            local_version = Gem::Platform.local.version
+            metadata += "##{local_version}" if local_version
+            metadata += " md/#{RbConfig::CONFIG['host_cpu']}"
+          end
 
-          if context[:gem_name] && context[:gem_version]
-            ua += " #{context[:gem_name]}/#{context[:gem_version]}"
+          # Used to be RUBY_ENGINE/RUBY_VERSION
+          def language_metadata
+            "lang/#{RUBY_ENGINE}##{RUBY_ENGINE_VERSION} md/#{RUBY_VERSION}"
           end
 
-          if (execution_env = ENV['AWS_EXECUTION_ENV'])
-            ua += " exec-env/#{execution_env}"
+          def env_metadata
+            return unless (execution_env = ENV['AWS_EXECUTION_ENV'])
+
+            "exec-env/#{execution_env}"
           end
 
-          if context.config.user_agent_suffix
-            ua += " #{context.config.user_agent_suffix}"
+          def app_id_metadata
+            return unless (app_id = @context.config.sdk_ua_app_id)
+
+            # Sanitize and only allow these characters
+            app_id = app_id.gsub(/[^!#$%&'*+\-.^_`|~0-9A-Za-z]/, '-')
+            "app/#{app_id}"
           end
 
-          context.http_request.headers['User-Agent'] = ua.strip
+          def framework_metadata
+            if (frameworks_cfg = @context.config.user_agent_frameworks).empty?
+              return
+            end
+
+            # Frameworks may be aws-record, aws-sdk-rails, etc.
+            regex = /gems\/(?<name>#{frameworks_cfg.join('|')})-(?<version>\d+\.\d+\.\d+)/.freeze
+            frameworks = {}
+            Kernel.caller.each do |line|
+              match = line.match(regex)
+              next unless match
+
+              frameworks[match[:name]] = match[:version]
+            end
+            frameworks.map { |n, v| "lib/#{n}##{v}" }.join(' ')
+          end
+
+          def metric_metadata
+            if Thread.current[:aws_sdk_core_user_agent_metric].nil? ||
+               Thread.current[:aws_sdk_core_user_agent_metric].empty?
+              return
+            end
+
+            metrics = Thread.current[:aws_sdk_core_user_agent_metric].join(',')
+            # Metric metadata is limited to 1024 bytes
+            return "m/#{metrics}" if metrics.bytesize <= 1024
+
+            # Removes the last unfinished metric
+            "m/#{metrics[0...metrics[0..1024].rindex(',')]}"
+          end
         end
       end
 
-      handler(Handler)
+      # Priority set to 5 in order to add user agent as late as possible after signing
+      handler(Handler, step: :sign, priority: 5)
     end
   end
 end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Aws
+  # setup autoloading for Plugins
+  # Most plugins are required explicitly from service clients
+  # but users may reference them outside of client usage.
+  module Plugins
+    autoload :ApiKey, 'aws-sdk-core/plugins/api_key'
+    autoload :BearerAuthorization, 'aws-sdk-core/plugins/bearer_authorization'
+    autoload :ChecksumAlgorithm, 'aws-sdk-core/plugins/checksum_algorithm'
+    autoload :ClientMetricsPlugin, 'aws-sdk-core/plugins/client_metrics_plugin'
+    autoload :ClientMetricsSendPlugin, 'aws-sdk-core/plugins/client_metrics_send_plugin'
+    autoload :CredentialsConfiguration, 'aws-sdk-core/plugins/credentials_configuration'
+    autoload :DefaultsMode, 'aws-sdk-core/plugins/defaults_mode'
+    autoload :EndpointDiscovery, 'aws-sdk-core/plugins/endpoint_discovery'
+    autoload :EndpointPattern, 'aws-sdk-core/plugins/endpoint_pattern'
+    autoload :EventStreamConfiguration, 'aws-sdk-core/plugins/event_stream_configuration'
+    autoload :GlobalConfiguration, 'aws-sdk-core/plugins/global_configuration'
+    autoload :HelpfulSocketErrors, 'aws-sdk-core/plugins/helpful_socket_errors'
+    autoload :HttpChecksum, 'aws-sdk-core/plugins/http_checksum'
+    autoload :IdempotencyToken, 'aws-sdk-core/plugins/idempotency_token'
+    autoload :InvocationId, 'aws-sdk-core/plugins/invocation_id'
+    autoload :JsonvalueConverter, 'aws-sdk-core/plugins/jsonvalue_converter'
+    autoload :Logging, 'aws-sdk-core/plugins/logging'
+    autoload :ParamConverter, 'aws-sdk-core/plugins/param_converter'
+    autoload :ParamValidator, 'aws-sdk-core/plugins/param_validator'
+    autoload :RecursionDetection, 'aws-sdk-core/plugins/recursion_detection'
+    autoload :RegionalEndpoint, 'aws-sdk-core/plugins/regional_endpoint'
+    autoload :RequestCompression, 'aws-sdk-core/plugins/request_compression'
+    autoload :ResponsePaging, 'aws-sdk-core/plugins/response_paging'
+    autoload :RetryErrors, 'aws-sdk-core/plugins/retry_errors'
+    autoload :Sign, 'aws-sdk-core/plugins/sign'
+    autoload :SignatureV4, 'aws-sdk-core/plugins/signature_v4'
+    autoload :StubResponses, 'aws-sdk-core/plugins/stub_responses'
+    autoload :Telemetry, 'aws-sdk-core/plugins/telemetry'
+    autoload :TransferEncoding, 'aws-sdk-core/plugins/transfer_encoding'
+    autoload :UserAgent, 'aws-sdk-core/plugins/user_agent'
+  end
+end

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

@@ -2,9 +2,15 @@
 
 module Aws
   # A credential provider that executes a given process and attempts
-  # to read its stdout to recieve a JSON payload containing the credentials.
+  # to read its stdout to receive a JSON payload containing the credentials.
   #
-  #     credentials = Aws::ProcessCredentials.new('/usr/bin/credential_proc')
+  #     credentials = Aws::ProcessCredentials.new(['/usr/bin/credential_proc'])
+  #     ec2 = Aws::EC2::Client.new(credentials: credentials)
+  #
+  # Arguments should be provided as strings in the array, for example:
+  #
+  #     process = ['/usr/bin/credential_proc', 'arg1', 'arg2']
+  #     credentials = Aws::ProcessCredentials.new(process)
   #     ec2 = Aws::EC2::Client.new(credentials: credentials)
   #
   # Automatically handles refreshing credentials if an Expiration time is
@@ -19,56 +25,69 @@ module Aws
     # Creates a new ProcessCredentials object, which allows an
     # external process to be used as a credential provider.
     #
-    # @param [String] process Invocation string for process
-    # credentials provider.
+    # @param [Array<String>, String] process An array of strings including
+    #  the process name and its arguments to execute, or a single string to be
+    #  executed by the shell (deprecated and insecure).
     def initialize(process)
+      if process.is_a?(String)
+        warn('Passing a single string to Aws::ProcessCredentials.new '\
+             'is insecure, please use use an array of system arguments instead')
+      end
       @process = process
-      @credentials = credentials_from_process(@process)
+      @credentials = credentials_from_process
       @async_refresh = false
-
+      @metrics = ['CREDENTIALS_PROCESS']
       super
     end
 
     private
-    def credentials_from_process(proc_invocation)
-      begin
-        raw_out = `#{proc_invocation}`
-        process_status = $?
-      rescue Errno::ENOENT
-        raise Errors::InvalidProcessCredentialsPayload.new("Could not find process #{proc_invocation}")
+
+    def credentials_from_process
+      r, w = IO.pipe
+      success = system(*@process, out: w)
+      w.close
+      raw_out = r.read
+      r.close
+
+      unless success
+        raise Errors::InvalidProcessCredentialsPayload.new(
+          'credential_process provider failure, the credential process had '\
+          'non zero exit status and failed to provide credentials'
+        )
       end
 
-      if process_status.success?
-        begin
-          creds_json = Aws::Json.load(raw_out)
-        rescue Aws::Json::ParseError
-          raise Errors::InvalidProcessCredentialsPayload.new("Invalid JSON response")
-        end
-        payload_version = creds_json['Version']
-        if payload_version == 1
-          _parse_payload_format_v1(creds_json)
-        else
-          raise Errors::InvalidProcessCredentialsPayload.new("Invalid version #{payload_version} for credentials payload")
-        end
-      else
-        raise Errors::InvalidProcessCredentialsPayload.new('credential_process provider failure, the credential process had non zero exit status and failed to provide credentials')
+      begin
+        creds_json = Aws::Json.load(raw_out)
+      rescue Aws::Json::ParseError
+        raise Errors::InvalidProcessCredentialsPayload.new('Invalid JSON response')
       end
+
+      payload_version = creds_json['Version']
+      return _parse_payload_format_v1(creds_json) if payload_version == 1
+
+      raise Errors::InvalidProcessCredentialsPayload.new(
+        "Invalid version #{payload_version} for credentials payload"
+      )
     end
 
     def _parse_payload_format_v1(creds_json)
       creds = Credentials.new(
         creds_json['AccessKeyId'],
         creds_json['SecretAccessKey'],
-        creds_json['SessionToken']
+        creds_json['SessionToken'],
+        account_id: creds_json['AccountId']
       )
 
       @expiration = creds_json['Expiration'] ? Time.iso8601(creds_json['Expiration']) : nil
       return creds if creds.set?
-      raise Errors::InvalidProcessCredentialsPayload.new("Invalid payload for JSON credentials version 1")
+
+      raise Errors::InvalidProcessCredentialsPayload.new(
+        'Invalid payload for JSON credentials version 1'
+      )
     end
 
     def refresh
-      @credentials = credentials_from_process(@process)
+      @credentials = credentials_from_process
     end
 
     def near_expiration?(expiration_length)

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Aws
+  # @api private
+  module Query
+    class EC2Handler < Aws::Query::Handler
+
+      def apply_params(param_list, params, rules)
+        Aws::Query::EC2ParamBuilder.new(param_list).apply(rules, params)
+      end
+
+      def parse_xml(context)
+        if (rules = context.operation.output)
+          parser = Xml::Parser.new(rules)
+          parser.parse(xml(context)) do |path, value|
+            if path.size == 2 && path.last == 'requestId'
+              context.metadata[:request_id] = value
+            end
+          end
+        else
+          EmptyStructure.new
+        end
+      end
+
+    end
+  end
+end

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

@@ -31,13 +31,11 @@ module Aws
       end
 
       def list(ref, values, prefix)
-        if values.empty?
-          set(prefix, '')
-        else
-          member_ref = ref.shape.member
-          values.each.with_index do |value, n|
-            format(member_ref, value, "#{prefix}.#{n+1}")
-          end
+        return if values.empty?
+
+        member_ref = ref.shape.member
+        values.each.with_index do |value, n|
+          format(member_ref, value, "#{prefix}.#{n + 1}")
         end
       end
 

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,30 +1,26 @@
 # frozen_string_literal: true
 
-require 'thread'
-
 module Aws
-
   # Base class used credential 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
+  # this module are expected to implement a `#refresh` method that populates
   # the following instance variables:
   #
-  # * `@access_key_id`
-  # * `@secret_access_key`
-  # * `@session_token`
-  # * `@expiration`
+  # * `@credentials` ({Credentials})
+  # * `@expiration` (Time)
   #
-  # @api private
   module RefreshingCredentials
-
     SYNC_EXPIRATION_LENGTH = 300 # 5 minutes
     ASYNC_EXPIRATION_LENGTH = 600 # 10 minutes
 
     CLIENT_EXCLUDE_OPTIONS = Set.new([:before_refresh]).freeze
 
+    # @param [Hash] options
+    # @option options [Proc] :before_refresh A Proc called before credentials are refreshed.
+    #   It accepts `self` as the only argument.
     def initialize(options = {})
       @mutex = Mutex.new
-      @before_refresh = options.delete(:before_refresh) if Hash === options
+      @before_refresh = options.delete(:before_refresh) if options.is_a?(Hash)
 
       @before_refresh.call(self) if @before_refresh
       refresh
@@ -36,12 +32,6 @@ module Aws
       @credentials
     end
 
-    # @return [Time,nil]
-    def expiration
-      refresh_if_near_expiration!
-      @expiration
-    end
-
     # Refresh credentials.
     # @return [void]
     def refresh!
@@ -54,26 +44,34 @@ 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
     # 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
+      # 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
@@ -91,6 +89,5 @@ module Aws
         true
       end
     end
-
   end
 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