aws-sdk-core 3.0.0 → 3.129.1

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Aws
+  module Plugins
+    class ClientMetricsSendPlugin < Seahorse::Client::Plugin
+
+      def add_handlers(handlers, config)
+        if config.client_side_monitoring && config.client_side_monitoring_port
+          # AttemptHandler comes just before we would retry an error.
+          # 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
+      end
+
+      class LatencyHandler < Seahorse::Client::Handler
+        def call(context)
+          start_time = Aws::Util.monotonic_milliseconds
+          resp = @handler.call(context)
+          end_time = Aws::Util.monotonic_milliseconds
+          latency = end_time - start_time
+          context.metadata[:current_call_attempt].request_latency = latency
+          resp
+        end
+      end
+
+      class AttemptHandler < Seahorse::Client::Handler
+        def call(context)
+          request_metrics = context.metadata[:client_metrics]
+          attempt_opts = {
+            timestamp: DateTime.now.strftime('%Q').to_i,
+            fqdn: context.http_request.endpoint.host,
+            region: context.config.region,
+            user_agent: context.http_request.headers["user-agent"],
+          }
+          # It will generally cause an error, but it is semantically valid for
+          # credentials to not exist.
+          if context.config.credentials
+            attempt_opts[:access_key] =
+              context.config.credentials.credentials.access_key_id
+            attempt_opts[:session_token] =
+              context.config.credentials.credentials.session_token
+          end
+          call_attempt = request_metrics.build_call_attempt(attempt_opts)
+          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"]
+          end
+          if headers.include?("x-amz-request-id")
+            call_attempt.x_amz_request_id = headers["x-amz-request-id"]
+          end
+          if headers.include?("x-amzn-request-id")
+            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
+            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
+          else
+            error.class.name.to_s
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Aws
+  module Plugins
+    # @api private
+    class EndpointDiscovery < Seahorse::Client::Plugin
+
+      option(:endpoint_discovery,
+        doc_default: Proc.new { |options| options[:require_endpoint_discovery] },
+        doc_type: 'Boolean',
+        docstring: <<-DOCS) do |cfg|
+When set to `true`, endpoint discovery will be enabled for operations when available.
+        DOCS
+        resolve_endpoint_discovery(cfg)
+      end
+
+      option(:endpoint_cache_max_entries,
+        default: 1000,
+        doc_type: Integer,
+        docstring: <<-DOCS
+Used for the maximum size limit of the LRU cache storing endpoints data
+for endpoint discovery enabled operations. Defaults to 1000.
+        DOCS
+      )
+
+      option(:endpoint_cache_max_threads,
+        default: 10,
+        doc_type: Integer,
+        docstring: <<-DOCS
+Used for the maximum threads in use for polling endpoints to be cached, defaults to 10.
+        DOCS
+      )
+
+      option(:endpoint_cache_poll_interval,
+        default: 60,
+        doc_type: Integer,
+        docstring: <<-DOCS
+When :endpoint_discovery and :active_endpoint_cache is enabled,
+Use this option to config the time interval in seconds for making
+requests fetching endpoints information. Defaults to 60 sec.
+        DOCS
+      )
+
+      option(:endpoint_cache) do |cfg|
+        Aws::EndpointCache.new(
+          max_entries: cfg.endpoint_cache_max_entries,
+          max_threads: cfg.endpoint_cache_max_threads
+        )
+      end
+
+      option(:active_endpoint_cache,
+        default: false,
+        doc_type: 'Boolean',
+        docstring: <<-DOCS
+When set to `true`, a thread polling for endpoints will be running in
+the background every 60 secs (default). Defaults to `false`.
+        DOCS
+      )
+
+      def add_handlers(handlers, config)
+        handlers.add(Handler, priority: 90) if config.regional_endpoint
+      end
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          if context.operation.endpoint_operation
+            context.http_request.headers['x-amz-api-version'] = context.config.api.version
+            _apply_endpoint_discovery_user_agent(context)
+          elsif discovery_cfg = context.operation.endpoint_discovery
+            endpoint = _discover_endpoint(
+              context,
+              Aws::Util.str_2_bool(discovery_cfg["required"])
+            )
+            context.http_request.endpoint = _valid_uri(endpoint.address) if endpoint
+            if endpoint || context.config.endpoint_discovery
+              _apply_endpoint_discovery_user_agent(context)
+            end
+          end
+          @handler.call(context)
+        end
+
+        private
+
+        def _valid_uri(address)
+          # returned address can be missing scheme
+          if address.start_with?('http')
+            URI.parse(address)
+          else
+            URI.parse("https://" + address)
+          end
+        end
+
+        def _apply_endpoint_discovery_user_agent(ctx)
+          if ctx.config.user_agent_suffix.nil?
+            ctx.config.user_agent_suffix = "endpoint-discovery"
+          elsif !ctx.config.user_agent_suffix.include? "endpoint-discovery"
+            ctx.config.user_agent_suffix += "endpoint-discovery"
+          end
+        end
+
+        def _discover_endpoint(ctx, required)
+          cache = ctx.config.endpoint_cache 
+          key = cache.extract_key(ctx)
+
+          if required
+            unless ctx.config.endpoint_discovery
+              raise ArgumentError, "Operation #{ctx.operation.name} requires "\
+                'endpoint_discovery to be enabled.'
+            end
+            # required for the operation
+            unless cache.key?(key)
+              cache.update(key, ctx)
+            end
+            endpoint = cache[key]
+            # hard fail if endpoint is not discovered
+            raise Aws::Errors::EndpointDiscoveryError.new unless endpoint
+            endpoint
+          elsif ctx.config.endpoint_discovery
+            # not required for the operation
+            # but enabled
+            if cache.key?(key)
+              cache[key]
+            elsif ctx.config.active_endpoint_cache
+              # enabled active cache pull
+              interval = ctx.config.endpoint_cache_poll_interval
+              if key.include?('_')
+                # identifier related, kill the previous polling thread by key
+                # because endpoint req params might be changed
+                cache.delete_polling_thread(key)
+              end
+
+              # start a thread for polling endpoints when non-exist
+              unless cache.threads_key?(key)
+                thread = Thread.new do
+                  while !cache.key?(key) do
+                    cache.update(key, ctx)
+                    sleep(interval)
+                  end
+                end
+                cache.update_polling_pool(key, thread)
+              end
+
+              cache[key]
+            else
+              # disabled active cache pull
+              # attempt, buit fail soft
+              cache.update(key, ctx)
+              cache[key]
+            end
+          end
+        end
+
+      end
+
+      private
+
+      def self.resolve_endpoint_discovery(cfg)
+        env = ENV['AWS_ENABLE_ENDPOINT_DISCOVERY']
+        default = cfg.api.require_endpoint_discovery
+        shared_cfg = Aws.shared_config.endpoint_discovery_enabled(profile: cfg.profile)
+        resolved = Aws::Util.str_2_bool(env) || Aws::Util.str_2_bool(shared_cfg)
+        env.nil? && shared_cfg.nil? ? default : !!resolved
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Aws
+  module Plugins
+    # @api private
+    class EndpointPattern < Seahorse::Client::Plugin
+
+      option(:disable_host_prefix_injection,
+        default: false,
+        doc_type: 'Boolean',
+        docstring: <<-DOCS
+Set to true to disable SDK automatically adding host prefix
+to default service endpoint when available.
+        DOCS
+      )
+
+      def add_handlers(handlers, config)
+        handlers.add(Handler, priority: 10)
+      end
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          if !context.config.disable_host_prefix_injection
+            endpoint_trait = context.operation.endpoint_pattern
+            if endpoint_trait && !endpoint_trait.empty?
+              _apply_endpoint_trait(context, endpoint_trait)
+            end
+          end
+          @handler.call(context)
+        end
+
+        private
+
+        def _apply_endpoint_trait(context, trait)
+          # currently only support host pattern
+          ori_host = context.http_request.endpoint.host
+          if pattern = trait['hostPrefix']
+            host_prefix = pattern.gsub(/\{.+?\}/) do |label|
+              label = label.delete("{}")
+              _replace_label_value(
+                ori_host, label, context.operation.input, context.params)
+            end
+            context.http_request.endpoint.host = host_prefix + context.http_request.endpoint.host
+          end
+        end
+
+        def _replace_label_value(ori, label, input_ref, params)
+          name = nil
+          input_ref.shape.members.each do |m_name, ref|
+            if ref['hostLabel'] && ref['hostLabelName'] == label
+              name = m_name
+            end
+          end
+          if name.nil? || params[name].nil?
+            raise Errors::MissingEndpointHostLabelValue.new(name)
+          end
+          params[name]
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Aws
+  module Plugins
+
+    class EventStreamConfiguration < Seahorse::Client::Plugin
+      
+      option(:event_stream_handler,
+        default: nil,
+        doc_type: 'Proc',
+        docstring: <<-DOCS)
+When an EventStream or Proc object is provided, it will be used as callback for each chunk of event stream response received along the way.
+      DOCS
+
+      option(:input_event_stream_handler,
+        default: nil,
+        doc_type: 'Proc',
+        docstring: <<-DOCS)
+When an EventStream or Proc object is provided, it can be used for sending events for the event stream.
+      DOCS
+
+      option(:output_event_stream_handler,
+        default: nil,
+        doc_type: 'Proc',
+        docstring: <<-DOCS)
+When an EventStream or Proc object is provided, it will be used as callback for each chunk of event stream response received along the way.
+      DOCS
+
+    end
+
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 
 module Aws

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws
   module Plugins
     # @api private

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'openssl'
+
+module Aws
+  module Plugins
+    # @api private
+    class HttpChecksum < Seahorse::Client::Plugin
+      # @api private
+      class Handler < Seahorse::Client::Handler
+        CHUNK_SIZE = 1 * 1024 * 1024 # one MB
+
+        def call(context)
+          if checksum_required?(context) &&
+             !context[:checksum_algorithms] # skip in favor of flexible checksum
+            body = context.http_request.body
+            context.http_request.headers['Content-Md5'] ||= md5(body)
+          end
+          @handler.call(context)
+        end
+
+        private
+
+        def checksum_required?(context)
+          context.operation.http_checksum_required ||
+            (context.operation.http_checksum &&
+              context.operation.http_checksum['requestChecksumRequired'])
+        end
+
+        # @param [File, Tempfile, IO#read, String] value
+        # @return [String<MD5>]
+        def md5(value)
+          if (value.is_a?(File) || value.is_a?(Tempfile)) &&
+             !value.path.nil? && File.exist?(value.path)
+            OpenSSL::Digest::MD5.file(value).base64digest
+          elsif value.respond_to?(:read)
+            md5 = OpenSSL::Digest::MD5.new
+            update_in_chunks(md5, value)
+            md5.base64digest
+          else
+            OpenSSL::Digest::MD5.digest(value).base64digest
+          end
+        end
+
+        def update_in_chunks(digest, io)
+          loop do
+            chunk = io.read(CHUNK_SIZE)
+            break unless chunk
+            digest.update(chunk)
+          end
+          io.rewind
+        end
+
+      end
+
+      def add_handlers(handlers, _config)
+        # priority set low to ensure checksum is computed AFTER the request is
+        # built but before it is signed
+        handlers.add(Handler, priority: 10, step: :build)
+      end
+
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'securerandom'
 
 module Aws

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Aws
+  module Plugins
+
+    # @api private
+    class InvocationId < Seahorse::Client::Plugin
+
+      # @api private
+      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
+        end
+
+      end
+
+      handler(Handler, step: :initialize)
+
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws
   module Plugins
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws
   module Plugins
     # @see Log::Formatter

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws
   module Plugins
     # @api private

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws
   module Plugins
     # @api private

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Aws
+  module Plugins
+    module Protocols
+      class ApiGateway < 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
+
+        handler(Rest::Handler)
+        handler(ContentTypeHandler, priority: 30)
+        handler(Json::ErrorHandler, step: :sign)
+      end
+
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../query'
 
 module Aws

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws
   module Plugins
     module Protocols

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../query'
 
 module Aws

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

@@ -1,12 +1,29 @@
+# frozen_string_literal: true
+
 module Aws
   module Plugins
     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
+
         handler(Rest::Handler)
+        handler(ContentTypeHandler, priority: 30)
         handler(Json::ErrorHandler, step: :sign)
-
       end
+
     end
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws
   module Plugins
     module Protocols