aws-sdk-core 3.185.1 → 3.214.0

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

@@ -117,7 +117,8 @@ module Aws
 
         def call(context)
           if should_calculate_request_checksum?(context)
-            request_algorithm_input = ChecksumAlgorithm.request_algorithm_selection(context)
+            request_algorithm_input = ChecksumAlgorithm.request_algorithm_selection(context) ||
+                                      context[:default_request_checksum_algorithm]
             context[:checksum_algorithms] = request_algorithm_input
 
             request_checksum_property = {
@@ -140,7 +141,8 @@ module Aws
 
         def should_calculate_request_checksum?(context)
           context.operation.http_checksum &&
-            ChecksumAlgorithm.request_algorithm_selection(context)
+            (ChecksumAlgorithm.request_algorithm_selection(context) ||
+              context[:default_request_checksum_algorithm])
         end
 
         def should_verify_response_checksum?(context)
@@ -236,7 +238,8 @@ module Aws
 
         # determine where (header vs trailer) a request checksum should be added
         def checksum_request_in(context)
-          if context.operation['authtype'].eql?('v4-unsigned-body')
+          if context.operation['unsignedPayload'] ||
+             context.operation['authtype'] == 'v4-unsigned-body'
             'trailer'
           else
             'header'

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

@@ -40,6 +40,7 @@ side monitoring agent is running on, where client metrics will be published via
       option(:client_side_monitoring_publisher,
         default: ClientSideMonitoring::Publisher,
         doc_type: Aws::ClientSideMonitoring::Publisher,
+        rbs_type: 'untyped',
         docstring: <<-DOCS) do |cfg|
 Allows you to provide a custom client-side monitoring publisher class. By default,
 will use the Client Side Monitoring Agent Publisher.

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

@@ -11,6 +11,8 @@ module Aws
           # AttemptHandler comes just before we would retry an error.
           # Or before we would follow redirects.
           handlers.add(AttemptHandler, step: :sign, priority: 39)
+          # ErrorHandler comes after we have parsed an error.
+          handlers.add(ErrorHandler, step: :sign, priority: 95)
           # LatencyHandler is as close to sending as possible.
           handlers.add(LatencyHandler, step: :sign, priority: 0)
         end
@@ -62,17 +64,27 @@ module Aws
             call_attempt.x_amzn_request_id = headers["x-amzn-request-id"]
           end
           call_attempt.http_status_code = context.http_response.status_code
-          if e = resp.error
+          context.metadata[:current_call_attempt] = call_attempt
+          request_metrics.add_call_attempt(call_attempt)
+          resp
+        end
+      end
+
+      class ErrorHandler < Seahorse::Client::Handler
+        def call(context)
+          resp = @handler.call(context)
+          call_attempt = context.metadata[:current_call_attempt]
+          if (e = resp.error)
             e_name = _extract_error_name(e)
             e_msg = e.message
             call_attempt.aws_exception = "#{e_name}"
             call_attempt.aws_exception_msg = "#{e_msg}"
           end
-          request_metrics.add_call_attempt(call_attempt)
           resp
         end
 
         private
+
         def _extract_error_name(error)
           if error.is_a?(Aws::Errors::ServiceError)
             error.class.code

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

@@ -12,6 +12,8 @@ module Aws
 
       option(:session_token, doc_type: String, docstring: '')
 
+      option(:account_id, doc_type: String, docstring: '')
+
       option(:profile,
         doc_default: 'default',
         doc_type: String,
@@ -23,6 +25,7 @@ at HOME/.aws/credentials.  When not specified, 'default' is used.
       option(:credentials,
         required: true,
         doc_type: 'Aws::CredentialProvider',
+        rbs_type: 'untyped',
         docstring: <<-DOCS
 Your AWS credentials. This can be an instance of any one of the
 following classes:
@@ -57,13 +60,15 @@ When `:credentials` are not configured directly, the following
 locations will be searched for credentials:
 
 * `Aws.config[:credentials]`
-* The `:access_key_id`, `:secret_access_key`, and `:session_token` options.
-* ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY']
+* The `:access_key_id`, `:secret_access_key`, `:session_token`, and
+  `:account_id` options.
+* ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY'],
+  ENV['AWS_SESSION_TOKEN'], and ENV['AWS_ACCOUNT_ID']
 * `~/.aws/credentials`
 * `~/.aws/config`
 * EC2/ECS IMDS instance profile - When used by default, the timeouts
   are very aggressive. Construct and pass an instance of
-  `Aws::InstanceProfileCredentails` or `Aws::ECSCredentials` to
+  `Aws::InstanceProfileCredentials` or `Aws::ECSCredentials` to
   enable retries and extended timeouts. Instance profile credential
   fetching can be disabled by setting ENV['AWS_EC2_METADATA_DISABLED']
   to true.
@@ -79,6 +84,7 @@ locations will be searched for credentials:
       option(:token_provider,
              required: false,
              doc_type: 'Aws::TokenProvider',
+             rbs_type: 'untyped',
              docstring: <<-DOCS
 A Bearer Token Provider. This can be an instance of any one of the
 following classes:

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

@@ -43,7 +43,7 @@ module Aws
     # @api private
     class GlobalConfiguration < Seahorse::Client::Plugin
 
-      @identifiers = Set.new()
+      @identifiers = Set.new
 
       # @api private
       def before_initialize(client_class, options)
@@ -55,17 +55,18 @@ module Aws
       private
 
       def apply_service_defaults(client_class, options)
-        if defaults = Aws.config[client_class.identifier]
-          defaults.each do |option_name, default|
-            options[option_name] = default unless options.key?(option_name)
-          end
+        return unless (defaults = Aws.config[client_class.identifier])
+
+        defaults.each do |option_name, default|
+          options[option_name] = default unless options.key?(option_name)
         end
       end
 
-      def apply_aws_defaults(client_class, options)
+      def apply_aws_defaults(_client_class, options)
         Aws.config.each do |option_name, default|
           next if self.class.identifiers.include?(option_name)
           next if options.key?(option_name)
+
           options[option_name] = default
         end
       end
@@ -80,9 +81,7 @@ module Aws
 
         # @return [Set<String>]
         # @api private
-        def identifiers
-          @identifiers
-        end
+        attr_reader :identifiers
 
       end
     end

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

@@ -12,7 +12,8 @@ module Aws
 
         def call(context)
           if checksum_required?(context) &&
-             !context[:checksum_algorithms] # skip in favor of flexible checksum
+             !context[:checksum_algorithms] && # skip in favor of flexible checksum
+             !context[:s3_express_endpoint] # s3 express endpoints do not support md5
             body = context.http_request.body
             context.http_request.headers['Content-Md5'] ||= md5(body)
           end

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

@@ -12,18 +12,8 @@ module Aws
       class Handler < Seahorse::Client::Handler
 
         def call(context)
-          apply_invocation_id(context)
-          @handler.call(context)
-        end
-
-        private
-
-        def apply_invocation_id(context)
           context.http_request.headers['amz-sdk-invocation-id'] = SecureRandom.uuid
-          if context[:input_event_emitter]
-            # only used for eventstreaming at input
-            context.http_request.headers['x-amz-content-sha256'] = 'STREAMING-AWS4-HMAC-SHA256-EVENTS'
-          end
+          @handler.call(context)
         end
 
       end

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

@@ -8,6 +8,7 @@ module Aws
 
       option(:logger,
         doc_type: 'Logger',
+        rbs_type: 'untyped',
         docstring: <<-DOCS
 The Logger instance to send log messages to.  If this option
 is not set, logging will be disabled.
@@ -22,6 +23,7 @@ is not set, logging will be disabled.
 
       option(:log_formatter,
         doc_type: 'Aws::Log::Formatter',
+        rbs_type: 'untyped',
         doc_default: literal('Aws::Log::Formatter.default'),
         docstring: 'The log formatter.'
       ) do |config|

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

@@ -5,6 +5,8 @@ module Aws
     module Protocols
       class ApiGateway < Seahorse::Client::Plugin
 
+        option(:protocol, 'api-gateway')
+
         class ContentTypeHandler < Seahorse::Client::Handler
           def call(context)
             body = context.http_request.body
@@ -22,8 +24,8 @@ module Aws
         handler(Rest::Handler)
         handler(ContentTypeHandler, priority: 30)
         handler(Json::ErrorHandler, step: :sign)
-      end
 
+      end
     end
   end
 end

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

@@ -1,35 +1,13 @@
 # frozen_string_literal: true
 
-require_relative '../../query'
-
 module Aws
   module Plugins
     module Protocols
       class EC2 < Seahorse::Client::Plugin
 
-        class Handler < 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)
-              data = parser.parse(xml(context)) do |path, value|
-                if path.size == 2 && path.last == 'requestId'
-                  context.metadata[:request_id] = value
-                end
-              end
-              data
-            else
-              EmptyStructure.new
-            end
-          end
-
-        end
+        option(:protocol, 'ec2')
 
-        handler(Handler)
+        handler(Aws::Query::EC2Handler)
         handler(Xml::ErrorHandler, step: :sign)
 
       end

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

@@ -5,18 +5,17 @@ module Aws
     module Protocols
       class JsonRpc < Seahorse::Client::Plugin
 
+        option(:protocol, 'json')
+
         option(:simple_json,
           default: false,
           doc_type: 'Boolean',
           docstring: <<-DOCS)
 Disables request parameter conversion, validation, and formatting.
-Also disable response data type conversions. This option is useful
-when you want to ensure the highest level of performance by
-avoiding overhead of walking request parameters and response data
-structures.
-
-When `:simple_json` is enabled, the request parameters hash must
-be formatted exactly as the DynamoDB API expects.
+Also disables response data type conversions. The request parameters
+hash must be formatted exactly as the API expects.This option is useful
+when you want to ensure the highest level of performance by avoiding
+overhead of walking request parameters and response data structures.
           DOCS
 
         option(:validate_params) { |config| !config.simple_json }
@@ -24,7 +23,6 @@ be formatted exactly as the DynamoDB API expects.
         option(:convert_params) { |config| !config.simple_json }
 
         handler(Json::Handler)
-
         handler(Json::ErrorHandler, step: :sign)
 
       end

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

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
-require_relative '../../query'
-
 module Aws
   module Plugins
     module Protocols
       class Query < Seahorse::Client::Plugin
+
+        option(:protocol, 'query')
+
         handler(Aws::Query::Handler)
         handler(Xml::ErrorHandler, step: :sign)
+
       end
     end
   end

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

@@ -5,25 +5,13 @@ module Aws
     module Protocols
       class RestJson < Seahorse::Client::Plugin
 
-        class ContentTypeHandler < Seahorse::Client::Handler
-          def call(context)
-            body = context.http_request.body
-            # Rest::Handler will set a default JSON body, so size can be checked
-            # if this handler is run after serialization.
-            if !body.respond_to?(:size) ||
-               (body.respond_to?(:size) && body.size > 0)
-              context.http_request.headers['Content-Type'] ||=
-                'application/json'
-            end
-            @handler.call(context)
-          end
-        end
+        option(:protocol, 'rest-json')
 
         handler(Rest::Handler)
-        handler(ContentTypeHandler, priority: 30)
+        handler(Rest::ContentTypeHandler, priority: 30)
         handler(Json::ErrorHandler, step: :sign)
-      end
 
+      end
     end
   end
 end

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

@@ -5,7 +5,10 @@ module Aws
     module Protocols
       class RestXml < Seahorse::Client::Plugin
 
+        option(:protocol, 'rest-xml')
+
         handler(Rest::Handler)
+        handler(Rest::ContentTypeHandler, priority: 30)
         handler(Xml::ErrorHandler, step: :sign)
 
       end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Aws
+  module Plugins
+    module Protocols
+      class RpcV2 < Seahorse::Client::Plugin
+
+        option(:protocol, 'smithy-rpc-v2-cbor')
+
+        handler(Aws::RpcV2::Handler)
+        handler(Aws::RpcV2::ContentTypeHandler, priority: 30)
+        handler(Aws::RpcV2::ErrorHandler, step: :sign)
+
+      end
+    end
+  end
+end

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

@@ -20,16 +20,31 @@ a default `:region` is searched for in the following locations:
 * `ENV['AWS_DEFAULT_REGION']`
 * `~/.aws/credentials`
 * `~/.aws/config`
-        DOCS
+             DOCS
         resolve_region(cfg)
       end
 
+      option(:sigv4a_signing_region_set,
+             doc_type: Array,
+             rbs_type: 'Array[String]',
+             docstring: <<-DOCS) do |cfg|
+A list of regions that should be signed with SigV4a signing. When
+not passed, a default `:sigv4a_signing_region_set` is searched for
+in the following locations:
+
+* `Aws.config[:sigv4a_signing_region_set]`
+* `ENV['AWS_SIGV4A_SIGNING_REGION_SET']`
+* `~/.aws/config`
+             DOCS
+        resolve_sigv4a_signing_region_set(cfg)
+      end
+
       option(:use_dualstack_endpoint,
         doc_type: 'Boolean',
         docstring: <<-DOCS) do |cfg|
 When set to `true`, dualstack enabled endpoints (with `.aws` TLD)
 will be used if available.
-        DOCS
+             DOCS
         resolve_use_dualstack_endpoint(cfg)
       end
 
@@ -39,7 +54,7 @@ will be used if available.
 When set to `true`, fips compatible endpoints will be used if available.
 When a `fips` region is used, the region is normalized and this config
 is set to `true`.
-        DOCS
+             DOCS
         resolve_use_fips_endpoint(cfg)
       end
 
@@ -52,7 +67,7 @@ is set to `true`.
         docstring: <<-DOCS) do |cfg|
 Setting to true disables use of endpoint URLs provided via environment 
 variables and the shared configuration file.
-        DOCS
+             DOCS
         resolve_ignore_configured_endpoint_urls(cfg)
       end
 
@@ -60,14 +75,58 @@ variables and the shared configuration file.
 The client endpoint is normally constructed from the `:region`
 option. You should only configure an `:endpoint` when connecting
 to test or custom endpoints. This should be a valid HTTP(S) URI.
-        DOCS
+      DOCS
         resolve_endpoint(cfg)
       end
 
       def after_initialize(client)
-        if client.config.region.nil? || client.config.region == ''
-          raise Errors::MissingRegionError
+        region = client.config.region
+        raise Errors::MissingRegionError if region.nil? || region == ''
+
+        # resolve a default endpoint to preserve legacy behavior
+        initialize_default_endpoint(client) if client.config.endpoint.nil?
+
+        region_set = client.config.sigv4a_signing_region_set
+        return if region_set.nil?
+        raise Errors::InvalidRegionSetError unless region_set.is_a?(Array)
+
+        region_set = region_set.compact.reject(&:empty?)
+        raise Errors::InvalidRegionSetError if region_set.empty?
+
+        client.config.sigv4a_signing_region_set = region_set
+      end
+
+      private
+
+      def initialize_default_endpoint(client)
+        client_module = Object.const_get(client.class.name.rpartition('::').first)
+        param_class = client_module.const_get(:EndpointParameters)
+        endpoint_provider = client.config.endpoint_provider
+        params = param_class.create(client.config)
+        endpoint = endpoint_provider.resolve_endpoint(params)
+        client.config.endpoint = endpoint.url
+      rescue ArgumentError, NameError
+        # fallback to legacy
+        client.config.endpoint = resolve_legacy_endpoint(client.config)
+      end
+
+      # set a default endpoint in config using legacy (endpoints.json) resolver
+      def resolve_legacy_endpoint(cfg)
+        endpoint_prefix = cfg.api.metadata['endpointPrefix']
+        if cfg.respond_to?(:sts_regional_endpoints)
+          sts_regional = cfg.sts_regional_endpoints
         end
+
+        endpoint = Aws::Partitions::EndpointProvider.resolve(
+          cfg.region,
+          endpoint_prefix,
+          sts_regional,
+          {
+            dualstack: cfg.use_dualstack_endpoint,
+            fips: cfg.use_fips_endpoint
+          }
+        )
+        URI(endpoint)
       end
 
       class << self
@@ -81,6 +140,12 @@ to test or custom endpoints. This should be a valid HTTP(S) URI.
           env_region || cfg_region
         end
 
+        def resolve_sigv4a_signing_region_set(cfg)
+          value = ENV['AWS_SIGV4A_SIGNING_REGION_SET']
+          value ||= Aws.shared_config.sigv4a_signing_region_set(profile: cfg.profile)
+          value.split(',') if value
+        end
+
         def resolve_use_dualstack_endpoint(cfg)
           value = ENV['AWS_USE_DUALSTACK_ENDPOINT']
           value ||= Aws.shared_config.use_dualstack_endpoint(
@@ -121,7 +186,8 @@ to test or custom endpoints. This should be a valid HTTP(S) URI.
           # that a custom endpoint has NOT been configured by the user
           cfg.override_config(:regional_endpoint, true)
 
-          resolve_legacy_endpoint(cfg)
+          # a default endpoint is resolved in after_initialize
+          nil
         end
 
         # get a custom configured endpoint from ENV or configuration
@@ -176,23 +242,6 @@ to test or custom endpoints. This should be a valid HTTP(S) URI.
             cfg.override_config(:region, new_region)
           end
         end
-        # set a default endpoint in config using legacy (endpoints.json) resolver
-        def resolve_legacy_endpoint(cfg)
-          endpoint_prefix = cfg.api.metadata['endpointPrefix']
-          if cfg.respond_to?(:sts_regional_endpoints)
-            sts_regional = cfg.sts_regional_endpoints
-          end
-
-          Aws::Partitions::EndpointProvider.resolve(
-            cfg.region,
-            endpoint_prefix,
-            sts_regional,
-            {
-              dualstack: cfg.use_dualstack_endpoint,
-              fips: cfg.use_fips_endpoint
-            }
-          )
-        end
       end
     end
   end

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

@@ -91,11 +91,20 @@ and 10485780 bytes inclusive.
               end
             end
           end
-          @handler.call(context)
+          with_metric(selected_encoding) { @handler.call(context) }
         end
 
         private
 
+        def with_metric(encoding, &block)
+          case encoding
+          when 'gzip'
+            Aws::Plugins::UserAgent.metric('GZIP_REQUEST_COMPRESSION', &block)
+          else
+            block.call
+          end
+        end
+
         def request_encoding_selection(context)
           encoding_list = context.operation.request_compression['encodings']
           encoding_list.find { |encoding| RequestCompression::SUPPORTED_ENCODINGS.include?(encoding) }
@@ -104,7 +113,7 @@ and 10485780 bytes inclusive.
         def update_content_encoding(encoding, context)
           headers = context.http_request.headers
           if headers['Content-Encoding']
-            headers['Content-Encoding'] += ',' + encoding
+            headers['Content-Encoding'] += ", #{encoding}"
           else
             headers['Content-Encoding'] = encoding
           end

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

@@ -73,6 +73,7 @@ is only used in the `legacy` retry mode.
         :retry_jitter,
         default: :none,
         doc_type: Symbol,
+        rbs_type: '(:none | :equal | :full | ^(Integer) -> Integer)',
         docstring: <<-DOCS)
 A delay randomiser function used by the default backoff function.
 Some predefined functions can be referenced by name - :none, :equal, :full,
@@ -97,6 +98,7 @@ This option is only used in the `legacy` retry mode.
         :retry_mode,
         default: 'legacy',
         doc_type: String,
+        rbs_type: '("legacy" | "standard" | "adaptive")',
         docstring: <<-DOCS) do |cfg|
 Specifies which retry algorithm to use. Values are:
 
@@ -111,7 +113,6 @@ Specifies which retry algorithm to use. Values are:
   functionality of `standard` mode along with automatic client side
   throttling.  This is a provisional mode that may change behavior
   in the future.
-
         DOCS
         resolve_retry_mode(cfg)
       end
@@ -233,7 +234,7 @@ a clock skew correction and retry requests with skewed client clocks.
 
           get_send_token(config)
           add_retry_headers(context)
-          response = @handler.call(context)
+          response = with_metric(config.retry_mode) { @handler.call(context) }
           error_inspector = Retries::ErrorInspector.new(
             response.error, response.context.http_response.status_code
           )
@@ -270,6 +271,10 @@ a clock skew correction and retry requests with skewed client clocks.
 
         private
 
+        def with_metric(retry_mode, &block)
+          Aws::Plugins::UserAgent.metric("RETRY_MODE_#{retry_mode.upcase}", &block)
+        end
+
         def get_send_token(config)
           # either fail fast or block until a token becomes available
           # must be configurable
@@ -357,7 +362,7 @@ a clock skew correction and retry requests with skewed client clocks.
       class LegacyHandler < Seahorse::Client::Handler
 
         def call(context)
-          response = @handler.call(context)
+          response = with_metric { @handler.call(context) }
           if response.error
             error_inspector = Retries::ErrorInspector.new(
               response.error, response.context.http_response.status_code
@@ -376,6 +381,10 @@ a clock skew correction and retry requests with skewed client clocks.
 
         private
 
+        def with_metric(&block)
+          Aws::Plugins::UserAgent.metric('RETRY_MODE_LEGACY', &block)
+        end
+
         def retry_if_possible(response, error_inspector)
           context = response.context
           if should_retry?(context, error_inspector)