aws-sdk-core 3.31.0 → 3.168.4

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

@@ -0,0 +1,340 @@
+# frozen_string_literal: true
+
+module Aws
+  module Plugins
+    # @api private
+    class ChecksumAlgorithm < Seahorse::Client::Plugin
+      CHUNK_SIZE = 1 * 1024 * 1024 # one MB
+
+      # determine the set of supported client side checksum algorithms
+      # CRC32c requires aws-crt (optional sdk dependency) for support
+      CLIENT_ALGORITHMS = begin
+        supported = %w[SHA256 SHA1 CRC32]
+        begin
+          require 'aws-crt'
+          supported << 'CRC32C'
+        rescue LoadError
+        end
+        supported
+      end.freeze
+
+      # priority order of checksum algorithms to validate responses against
+      # Remove any algorithms not supported by client (ie, depending on CRT availability)
+      CHECKSUM_ALGORITHM_PRIORITIES = %w[CRC32C SHA1 CRC32 SHA256] & CLIENT_ALGORITHMS
+
+      # byte size of checksums, used in computing the trailer length
+      CHECKSUM_SIZE = {
+        'CRC32' => 16,
+        'CRC32C' => 16,
+        'SHA1' => 36,
+        'SHA256' => 52
+      }
+
+      # Interface for computing digests on request/response bodies
+      # which may be files, strings or IO like objects
+      # Applies only to digest functions that produce 32 bit integer checksums
+      # (eg CRC32)
+      class Digest32
+
+        attr_reader :value
+
+        # @param [Object] digest_fn
+        def initialize(digest_fn)
+          @digest_fn = digest_fn
+          @value = 0
+        end
+
+        def update(chunk)
+          @value = @digest_fn.call(chunk, @value)
+        end
+
+        def base64digest
+          Base64.encode64([@value].pack('N')).chomp
+        end
+      end
+
+      def add_handlers(handlers, _config)
+        handlers.add(OptionHandler, step: :initialize)
+        # priority set low to ensure checksum is computed AFTER the request is
+        # built but before it is signed
+        handlers.add(ChecksumHandler, priority: 15, step: :build)
+      end
+
+      private
+
+      def self.request_algorithm_selection(context)
+        return unless context.operation.http_checksum
+
+        input_member = context.operation.http_checksum['requestAlgorithmMember']
+        context.params[input_member.to_sym]&.upcase if input_member
+      end
+
+      def self.request_validation_mode(context)
+        return unless context.operation.http_checksum
+
+        input_member = context.operation.http_checksum['requestValidationModeMember']
+        context.params[input_member.to_sym] if input_member
+      end
+
+      def self.operation_response_algorithms(context)
+        return unless context.operation.http_checksum
+
+        context.operation.http_checksum['responseAlgorithms']
+      end
+
+
+      # @api private
+      class OptionHandler < Seahorse::Client::Handler
+        def call(context)
+          context[:http_checksum] ||= {}
+
+          # validate request configuration
+          if (request_input = ChecksumAlgorithm.request_algorithm_selection(context))
+            unless CLIENT_ALGORITHMS.include? request_input
+              if (request_input == 'CRC32C')
+                raise ArgumentError, "CRC32C requires crt support - install the aws-crt gem for support."
+              else
+                raise ArgumentError, "#{request_input} is not a supported checksum algorithm."
+              end
+            end
+          end
+
+        # validate response configuration
+          if (ChecksumAlgorithm.request_validation_mode(context))
+            # Compute an ordered list as the union between priority supported and the
+            # operation's modeled response algorithms.
+            validation_list = CHECKSUM_ALGORITHM_PRIORITIES &
+              ChecksumAlgorithm.operation_response_algorithms(context)
+            context[:http_checksum][:validation_list] = validation_list
+          end
+
+          @handler.call(context)
+        end
+      end
+
+      # @api private
+      class ChecksumHandler < Seahorse::Client::Handler
+
+        def call(context)
+          if should_calculate_request_checksum?(context)
+            request_algorithm_input = ChecksumAlgorithm.request_algorithm_selection(context)
+            context[:checksum_algorithms] = request_algorithm_input
+
+            request_checksum_property = {
+              'algorithm' => request_algorithm_input,
+              'in' => checksum_request_in(context),
+              'name' => "x-amz-checksum-#{request_algorithm_input.downcase}"
+            }
+
+            calculate_request_checksum(context, request_checksum_property)
+          end
+
+          if should_verify_response_checksum?(context)
+            add_verify_response_checksum_handlers(context)
+          end
+
+          @handler.call(context)
+        end
+
+        private
+
+        def should_calculate_request_checksum?(context)
+          context.operation.http_checksum &&
+            ChecksumAlgorithm.request_algorithm_selection(context)
+        end
+
+        def should_verify_response_checksum?(context)
+          context[:http_checksum][:validation_list] && !context[:http_checksum][:validation_list].empty?
+        end
+
+        def calculate_request_checksum(context, checksum_properties)
+          case checksum_properties['in']
+          when 'header'
+            header_name = checksum_properties['name']
+            body = context.http_request.body_contents
+            if body
+              context.http_request.headers[header_name] ||=
+                ChecksumAlgorithm.calculate_checksum(checksum_properties['algorithm'], body)
+            end
+          when 'trailer'
+            apply_request_trailer_checksum(context, checksum_properties)
+          end
+        end
+
+        def apply_request_trailer_checksum(context, checksum_properties)
+          location_name = checksum_properties['name']
+
+          # set required headers
+          headers = context.http_request.headers
+          headers['Content-Encoding'] = 'aws-chunked'
+          headers['X-Amz-Content-Sha256'] = 'STREAMING-UNSIGNED-PAYLOAD-TRAILER'
+          headers['X-Amz-Trailer'] = location_name
+
+          # We currently always compute the size in the modified body wrapper - allowing us
+          # to set the Content-Length header (set by content_length plugin).
+          # This means we cannot use Transfer-Encoding=chunked
+
+          if !context.http_request.body.respond_to?(:size)
+            raise Aws::Errors::ChecksumError, 'Could not determine length of the body'
+          end
+          headers['X-Amz-Decoded-Content-Length'] = context.http_request.body.size
+
+          context.http_request.body = AwsChunkedTrailerDigestIO.new(
+            context.http_request.body,
+            checksum_properties['algorithm'],
+            location_name
+          )
+        end
+
+        # Add events to the http_response to verify the checksum as its read
+        # This prevents the body from being read multiple times
+        # verification is done only once a successful response has completed
+        def add_verify_response_checksum_handlers(context)
+          http_response = context.http_response
+          checksum_context = { }
+          http_response.on_headers do |_status, headers|
+            header_name, algorithm = response_header_to_verify(headers, context[:http_checksum][:validation_list])
+            if header_name
+              expected = headers[header_name]
+
+              unless context[:http_checksum][:skip_on_suffix] && /-[\d]+$/.match(expected)
+                checksum_context[:algorithm] = algorithm
+                checksum_context[:header_name] = header_name
+                checksum_context[:digest] = ChecksumAlgorithm.digest_for_algorithm(algorithm)
+                checksum_context[:expected] = expected
+              end
+            end
+          end
+
+          http_response.on_data do |chunk|
+            checksum_context[:digest].update(chunk) if checksum_context[:digest]
+          end
+
+          http_response.on_success do
+            if checksum_context[:digest] &&
+              (computed = checksum_context[:digest].base64digest)
+
+              if computed != checksum_context[:expected]
+                raise Aws::Errors::ChecksumError,
+                      "Checksum validation failed on #{checksum_context[:header_name]} "\
+                      "computed: #{computed}, expected: #{checksum_context[:expected]}"
+              end
+
+              context[:http_checksum][:validated] = checksum_context[:algorithm]
+            end
+          end
+        end
+
+        # returns nil if no headers to verify
+        def response_header_to_verify(headers, validation_list)
+          validation_list.each do |algorithm|
+            header_name = "x-amz-checksum-#{algorithm}"
+            return [header_name, algorithm] if headers[header_name]
+          end
+          nil
+        end
+
+        # determine where (header vs trailer) a request checksum should be added
+        def checksum_request_in(context)
+          if context.operation['authtype'].eql?('v4-unsigned-body')
+            'trailer'
+          else
+            'header'
+          end
+        end
+
+      end
+
+      def self.calculate_checksum(algorithm, body)
+        digest = ChecksumAlgorithm.digest_for_algorithm(algorithm)
+        if body.respond_to?(:read)
+          ChecksumAlgorithm.update_in_chunks(digest, body)
+        else
+          digest.update(body)
+        end
+        digest.base64digest
+      end
+
+      def self.digest_for_algorithm(algorithm)
+        case algorithm
+        when 'CRC32'
+          Digest32.new(Zlib.method(:crc32))
+        when 'CRC32C'
+          # this will only be used if input algorithm is CRC32C AND client supports it (crt available)
+          Digest32.new(Aws::Crt::Checksums.method(:crc32c))
+        when 'SHA1'
+          Digest::SHA1.new
+        when 'SHA256'
+          Digest::SHA256.new
+        end
+      end
+
+      # The trailer size (in bytes) is the overhead + the trailer name +
+      # the length of the base64 encoded checksum
+      def self.trailer_length(algorithm, location_name)
+        CHECKSUM_SIZE[algorithm] + location_name.size
+      end
+
+      def self.update_in_chunks(digest, io)
+        loop do
+          chunk = io.read(CHUNK_SIZE)
+          break unless chunk
+          digest.update(chunk)
+        end
+        io.rewind
+      end
+
+      # Wrapper for request body that implements application-layer
+      # chunking with Digest computed on chunks + added as a trailer
+      class AwsChunkedTrailerDigestIO
+        CHUNK_SIZE = 16384
+
+        def initialize(io, algorithm, location_name)
+          @io = io
+          @location_name = location_name
+          @algorithm = algorithm
+          @digest = ChecksumAlgorithm.digest_for_algorithm(algorithm)
+          @trailer_io = nil
+        end
+
+        # the size of the application layer aws-chunked + trailer body
+        def size
+          # compute the number of chunks
+          # a full chunk has 4 + 4 bytes overhead, a partial chunk is len.to_s(16).size + 4
+          orig_body_size = @io.size
+          n_full_chunks = orig_body_size / CHUNK_SIZE
+          partial_bytes = orig_body_size % CHUNK_SIZE
+          chunked_body_size = n_full_chunks * (CHUNK_SIZE + 8)
+          chunked_body_size += partial_bytes.to_s(16).size + partial_bytes + 4 unless  partial_bytes.zero?
+          trailer_size = ChecksumAlgorithm.trailer_length(@algorithm, @location_name)
+          chunked_body_size + trailer_size
+        end
+
+        def rewind
+          @io.rewind
+        end
+
+        def read(length, buf)
+          # account for possible leftover bytes at the end, if we have trailer bytes, send them
+          if @trailer_io
+            return @trailer_io.read(length, buf)
+          end
+
+          chunk = @io.read(length)
+          if chunk
+            @digest.update(chunk)
+            application_chunked = "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n"
+            return StringIO.new(application_chunked).read(application_chunked.size, buf)
+          else
+            trailers = {}
+            trailers[@location_name] = @digest.base64digest
+            trailers = trailers.map { |k,v| "#{k}:#{v}"}.join("\r\n")
+            @trailer_io = StringIO.new("0\r\n#{trailers}\r\n\r\n")
+            chunk = @trailer_io.read(length, buf)
+          end
+          chunk
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'date'
+require_relative 'retries/error_inspector'
 
 module Aws
   module Plugins
@@ -6,6 +9,7 @@ module Aws
 
       option(:client_side_monitoring,
         default: false,
+        doc_type: 'Boolean',
         docstring: <<-DOCS) do |cfg|
 When `true`, client-side metrics will be collected for all API requests from
 this client.
@@ -15,6 +19,7 @@ this client.
 
       option(:client_side_monitoring_port,
         default: 31000,
+        doc_type: Integer,
         docstring: <<-DOCS) do |cfg|
 Required for publishing client metrics. The port that the client side monitoring
 agent is running on, where client metrics will be published via UDP.
@@ -22,8 +27,19 @@ agent is running on, where client metrics will be published via UDP.
         resolve_client_side_monitoring_port(cfg)
       end
 
+      option(:client_side_monitoring_host,
+        default: "127.0.0.1",
+        doc_type: String,
+        docstring: <<-DOCS) do |cfg|
+Allows you to specify the DNS hostname or IPv4 or IPv6 address that the client
+side monitoring agent is running on, where client metrics will be published via UDP.
+      DOCS
+        resolve_client_side_monitoring_host(cfg)
+      end
+
       option(:client_side_monitoring_publisher,
         default: ClientSideMonitoring::Publisher,
+        doc_type: Aws::ClientSideMonitoring::Publisher,
         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.
@@ -33,6 +49,7 @@ will use the Client Side Monitoring Agent Publisher.
 
       option(:client_side_monitoring_client_id,
         default: "",
+        doc_type: String,
         docstring: <<-DOCS) do |cfg|
 Allows you to provide an identifier for this client which will be attached to
 all generated client side metrics. Defaults to an empty string.
@@ -45,6 +62,7 @@ all generated client side metrics. Defaults to an empty string.
           handlers.add(Handler, step: :initialize)
           publisher = config.client_side_monitoring_publisher
           publisher.agent_port = config.client_side_monitoring_port
+          publisher.agent_host = config.client_side_monitoring_host
         end
       end
 
@@ -66,6 +84,19 @@ all generated client side metrics. Defaults to an empty string.
         end
       end
 
+      def self.resolve_client_side_monitoring_host(cfg)
+        env_source = ENV["AWS_CSM_HOST"]
+        env_source = nil if env_source == ""
+        cfg_source = Aws.shared_config.csm_host(profile: cfg.profile)
+        if env_source
+          env_source
+        elsif cfg_source
+          cfg_source
+        else
+          "127.0.0.1"
+        end
+      end
+
       def self.resolve_client_side_monitoring(cfg)
         env_source = ENV["AWS_CSM_ENABLED"]
         env_source = nil if env_source == ""
@@ -103,11 +134,23 @@ all generated client side metrics. Defaults to an empty string.
             timestamp: DateTime.now.strftime('%Q').to_i,
           )
           context.metadata[:client_metrics] = request_metrics
-          start_time = Time.now
+          start_time = Aws::Util.monotonic_milliseconds
+          final_error_retryable = false
+          final_aws_exception = nil
+          final_aws_exception_message = nil
+          final_sdk_exception = nil
+          final_sdk_exception_message = nil
           begin
             @handler.call(context)
           rescue StandardError => e
             # Handle SDK Exceptions
+            inspector = Retries::ErrorInspector.new(
+              e,
+              context.http_response.status_code
+            )
+            if inspector.retryable?(context)
+              final_error_retryable = true
+            end
             if request_metrics.api_call_attempts.empty?
               attempt = request_metrics.build_call_attempt
               attempt.sdk_exception = e.class.to_s
@@ -125,13 +168,29 @@ all generated client side metrics. Defaults to an empty string.
               attempt.sdk_exception = e.class.to_s
               attempt.sdk_exception_msg = e.message
             end # Else we don't have an SDK exception and are done.
+            final_attempt = request_metrics.api_call_attempts.last
+            final_aws_exception = final_attempt.aws_exception
+            final_aws_exception_message = final_attempt.aws_exception_msg
+            final_sdk_exception = final_attempt.sdk_exception
+            final_sdk_exception_message = final_attempt.sdk_exception_msg
             raise e
           ensure
-            end_time = Time.now
-            request_metrics.api_call.complete(
-              latency: ((end_time - start_time) * 1000).to_i,
-              attempt_count: context.retries + 1
-            )
+            end_time = Aws::Util.monotonic_milliseconds
+            complete_opts = {
+              latency: end_time - start_time,
+              attempt_count: context.retries + 1,
+              user_agent: context.http_request.headers["user-agent"],
+              final_error_retryable: final_error_retryable,
+              final_http_status_code: context.http_response.status_code,
+              final_aws_exception: final_aws_exception,
+              final_aws_exception_message: final_aws_exception_message,
+              final_sdk_exception: final_sdk_exception,
+              final_sdk_exception_message: final_sdk_exception_message
+            }
+            if context.metadata[:redirect_region]
+              complete_opts[:region] = context.metadata[:redirect_region]
+            end
+            request_metrics.api_call.complete(complete_opts)
             # Report the metrics by passing the complete RequestMetrics object
             if publisher
               publisher.publish(request_metrics)

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'date'
 
 module Aws
@@ -7,7 +9,8 @@ module Aws
       def add_handlers(handlers, config)
         if config.client_side_monitoring && config.client_side_monitoring_port
           # AttemptHandler comes just before we would retry an error.
-          handlers.add(AttemptHandler, step: :sign, priority: 95)
+          # Or before we would follow redirects.
+          handlers.add(AttemptHandler, step: :sign, priority: 39)
           # LatencyHandler is as close to sending as possible.
           handlers.add(LatencyHandler, step: :sign, priority: 0)
         end
@@ -15,10 +18,10 @@ module Aws
 
       class LatencyHandler < Seahorse::Client::Handler
         def call(context)
-          start_time = Time.now
+          start_time = Aws::Util.monotonic_milliseconds
           resp = @handler.call(context)
-          end_time = Time.now
-          latency = ((end_time - start_time) * 1000).to_i
+          end_time = Aws::Util.monotonic_milliseconds
+          latency = end_time - start_time
           context.metadata[:current_call_attempt].request_latency = latency
           resp
         end
@@ -45,6 +48,9 @@ module Aws
           context.metadata[:current_call_attempt] = call_attempt
 
           resp = @handler.call(context)
+          if context.metadata[:redirect_region]
+            call_attempt.region = context.metadata[:redirect_region]
+          end
           headers = context.http_response.headers
           if headers.include?("x-amz-id-2")
             call_attempt.x_amz_id_2 = headers["x-amz-id-2"]

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws
   # @api private
   module Plugins
@@ -28,13 +30,28 @@ following classes:
 * `Aws::Credentials` - Used for configuring static, non-refreshing
   credentials.
 
+* `Aws::SharedCredentials` - Used for loading static credentials from a
+  shared file, such as `~/.aws/config`.
+
+* `Aws::AssumeRoleCredentials` - Used when you need to assume a role.
+
+* `Aws::AssumeRoleWebIdentityCredentials` - Used when you need to
+  assume a role after providing credentials via the web.
+
+* `Aws::SSOCredentials` - Used for loading credentials from AWS SSO using an
+  access token generated from `aws login`.
+
+* `Aws::ProcessCredentials` - Used for loading credentials from a
+  process that outputs to stdout.
+
 * `Aws::InstanceProfileCredentials` - Used for loading credentials
   from an EC2 IMDS on an EC2 instance.
 
-* `Aws::SharedCredentials` - Used for loading credentials from a
-  shared file, such as `~/.aws/config`.
+* `Aws::ECSCredentials` - Used for loading credentials from
+  instances running in ECS.
 
-* `Aws::AssumeRoleCredentials` - Used when you need to assume a role.
+* `Aws::CognitoIdentityCredentials` - Used for loading credentials
+  from the Cognito Identity service.
 
 When `:credentials` are not configured directly, the following
 locations will be searched for credentials:
@@ -44,10 +61,12 @@ locations will be searched for credentials:
 * ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY']
 * `~/.aws/credentials`
 * `~/.aws/config`
-* EC2 IMDS instance profile - When used by default, the timeouts are
-  very aggressive. Construct and pass an instance of
-  `Aws::InstanceProfileCredentails` to enable retries and extended
-  timeouts.
+* 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
+  enable retries and extended timeouts. Instance profile credential
+  fetching can be disabled by setting ENV['AWS_EC2_METADATA_DISABLED']
+  to true.
         DOCS
       ) do |config|
         CredentialProviderChain.new(config).resolve
@@ -57,6 +76,30 @@ locations will be searched for credentials:
 
       option(:instance_profile_credentials_timeout, 1)
 
+      option(:token_provider,
+             required: false,
+             doc_type: 'Aws::TokenProvider',
+             docstring: <<-DOCS
+A Bearer Token Provider. This can be an instance of any one of the
+following classes:
+
+* `Aws::StaticTokenProvider` - Used for configuring static, non-refreshing
+  tokens.
+
+* `Aws::SSOTokenProvider` - Used for loading tokens from AWS SSO using an
+  access token generated from `aws login`.
+
+When `:token_provider` is not configured directly, the `Aws::TokenProviderChain`
+will be used to search for tokens configured for your profile in shared configuration files.
+      DOCS
+      ) do |config|
+        if config.stub_responses
+          StaticTokenProvider.new('token')
+        else
+          TokenProviderChain.new(config).resolve
+        end
+      end
+
     end
   end
 end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Aws
+  # @api private
+  module Plugins
+    # @api private
+    class DefaultsMode < Seahorse::Client::Plugin
+
+      option(:defaults_mode,
+             default: 'legacy',
+             doc_type: String,
+             docstring: <<-DOCS
+See {Aws::DefaultsModeConfiguration} for a list of the 
+accepted modes and the configuration defaults that are included.
+      DOCS
+      ) do |cfg|
+        resolve_defaults_mode(cfg)
+      end
+
+      option(:defaults_mode_config_resolver,
+             doc_type: 'Aws::DefaultsModeConfigResolver') do |cfg|
+        Aws::DefaultsModeConfigResolver.new(
+          Aws::DefaultsModeConfiguration::SDK_DEFAULT_CONFIGURATION, cfg)
+      end
+
+      class << self
+        private
+
+        def resolve_defaults_mode(cfg)
+          value = ENV['AWS_DEFAULTS_MODE']
+          value ||= Aws.shared_config.defaults_mode(
+            profile: cfg.profile
+          )
+          value&.downcase || "legacy"
+        end
+      end
+
+    end
+  end
+end