aws-sdk-core 2.4.0 → 3.53.0

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

@@ -0,0 +1,160 @@
+module Aws
+  module Plugins
+    # @api private
+    class EndpointDiscovery < Seahorse::Client::Plugin
+
+      option(:endpoint_discovery,
+        default: false,
+        doc_type: 'Boolean',
+        docstring: <<-DOCS) do |cfg|
+When set to `true`, endpoint discovery will be enabled for operations when available. Defaults to `false`.
+        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
+            # 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']
+        shared_cfg = Aws.shared_config.endpoint_discovery(profile: cfg.profile)
+        Aws::Util.str_2_bool(env) || Aws::Util.str_2_bool(shared_cfg)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+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)
+        if config.regional_endpoint && !config.disable_host_prefix_injection
+          handlers.add(Handler, priority: 90)
+        end
+      end
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          endpoint_trait = context.operation.endpoint_pattern
+          if endpoint_trait && !endpoint_trait.empty?
+            _apply_endpoint_trait(context, endpoint_trait)
+          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,30 @@
+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

@@ -31,17 +31,17 @@ module Aws
     #     Aws::EC2.new
     #     #=> raises ArgumentError: invalid configuration option `:force_path_style'
     #
-    # To avoid this issue, you can nest service specific options 
+    # To avoid this issue, you can nest service specific options
     #
     #     Aws.config[:s3] = { force_path_style: true }
     #
     #     Aws::EC2.new # no error this time
     #     Aws::S3.new.config.force_path_style #=> true
     #
+    # @api private
     class GlobalConfiguration < Seahorse::Client::Plugin
 
-      # @api private
-      IDENTIFIERS = Set.new(SERVICE_MODULE_NAMES.map(&:downcase).map(&:to_sym))
+      @identifiers = Set.new()
 
       # @api private
       def before_initialize(client_class, options)
@@ -62,18 +62,27 @@ module Aws
 
       def apply_aws_defaults(client_class, options)
         Aws.config.each do |option_name, default|
-          next if IDENTIFIERS.include?(option_name)
+          next if self.class.identifiers.include?(option_name)
           next if options.key?(option_name)
           options[option_name] = default
         end
       end
 
-    end
-  end
+      class << self
 
-  service_added do |name, _, _|
-    Plugins::GlobalConfiguration::IDENTIFIERS << name.downcase.to_sym
-  end
+        # Registers an additional service identifier.
+        # @api private
+        def add_identifier(identifier)
+          @identifiers << identifier
+        end
 
-end
+        # @return [Set<String>]
+        # @api private
+        def identifiers
+          @identifiers
+        end
 
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Aws
+  module Plugins
+    # @api private
+    class HelpfulSocketErrors < Seahorse::Client::Plugin
+
+      class Handler < Seahorse::Client::Handler
+
+        # Wrap `SocketError` errors with `Aws::Errors::NoSuchEndpointError`
+        def call(context)
+          response = @handler.call(context)
+          response.context.http_response.on_error do |error|
+            if socket_endpoint_error?(error)
+              response.error = no_such_endpoint_error(context, error)
+            end
+          end
+          response
+        end
+
+        private
+
+        def socket_endpoint_error?(error)
+          Seahorse::Client::NetworkingError === error &&
+          SocketError === error.original_error &&
+          error.original_error.message.match(/failed to open tcp connection/i) &&
+          error.original_error.message.match(/getaddrinfo: nodename nor servname provided, or not known/i)
+        end
+
+        def no_such_endpoint_error(context, error)
+          Errors::NoSuchEndpointError.new({
+            context: context,
+            original_error: error.original_error,
+          })
+        end
+
+      end
+
+      handle(Handler, step: :sign)
+
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'securerandom'
+
+module Aws
+  module Plugins
+
+    # Provides support for auto filling operation parameters
+    # that enabled with `idempotencyToken` trait  with random UUID v4
+    # when no value is provided
+    # @api private
+    class IdempotencyToken < Seahorse::Client::Plugin
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          auto_fill(context.params, context.operation.input)
+          @handler.call(context)
+        end
+
+        private
+
+        def auto_fill(params, ref)
+          ref.shape.members.each do |name, member_ref|
+            if member_ref['idempotencyToken']
+              params[name] ||= SecureRandom.uuid
+            end
+          end
+        end
+
+      end
+
+      handler(Handler, step: :initialize)
+
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,29 @@
+module Aws
+  module Plugins
+
+    # Converts input value to JSON Syntax for members with jsonvalue trait
+    class JsonvalueConverter < Seahorse::Client::Plugin
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          context.operation.input.shape.members.each do |m, ref|
+            if ref['jsonvalue']
+              param_value = context.params[m]
+              unless param_value.respond_to?(:to_json)
+                raise ArgumentError, "The value of params[#{m}] is not JSON serializable."
+              end
+              context.params[m] = param_value.to_json
+            end
+          end
+          @handler.call(context)
+        end
+
+      end
+
+      handler(Handler, step: :initialize)
+    end
+
+  end
+end