aws-sdk-core 2.11.632 → 3.0.0.rc1

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

@@ -1,11 +1,11 @@
+require_relative '../../query'
+
 module Aws
   module Plugins
     module Protocols
       class Query < Seahorse::Client::Plugin
-
         handler(Aws::Query::Handler)
         handler(Xml::ErrorHandler, step: :sign)
-
       end
     end
   end

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

@@ -1,14 +1,6 @@
 module Aws
   module Plugins
-
-    # @seahorse.client.option [required, String] :region
-    #   The AWS region to connect to.  The region is used to construct
-    #   the client endpoint.  Defaults to `ENV['AWS_REGION']`.
-    #   Also checks `AMAZON_REGION` and `AWS_DEFAULT_REGION`.
-    #
-    # @seahorse.client.option [String] :endpoint A default endpoint is
-    #   constructed from the `:region`.
-    #
+    # @api private
     class RegionalEndpoint < Seahorse::Client::Plugin
 
       # raised when region is not configured
@@ -16,27 +8,38 @@ module Aws
 
       option(:profile)
 
-      option(:region) do |cfg|
+      option(:region,
+        required: true,
+        doc_type: String,
+        docstring: <<-DOCS) do |cfg|
+The AWS region to connect to.  The configured `:region` is
+used to determine the service `:endpoint`. When not passed,
+a default `:region` is search for in the following locations:
+
+* `Aws.config[:region]`
+* `ENV['AWS_REGION']`
+* `ENV['AMAZON_REGION']`
+* `ENV['AWS_DEFAULT_REGION']`
+* `~/.aws/credentials`
+* `~/.aws/config`
+        DOCS
         resolve_region(cfg)
       end
 
-      option(:regional_endpoint, false)
-
-      option(:endpoint) do |cfg|
+      option(:endpoint, doc_type: String, docstring: <<-DOCS) do |cfg|
+The client endpoint is normally constructed from the `:region`
+option. You should only configure an `:endpoint` when connecting
+to test endpoints. This should be avalid HTTP(S) URI.
+        DOCS
         endpoint_prefix = cfg.api.metadata['endpointPrefix']
         if cfg.region && endpoint_prefix
-          if cfg.respond_to?(:sts_regional_endpoints)
-            sts_regional = cfg.sts_regional_endpoints
-          end
-          EndpointProvider.resolve(cfg.region, endpoint_prefix, sts_regional)
+          Aws::Partitions::EndpointProvider.resolve(cfg.region, endpoint_prefix)
         end
       end
 
       def after_initialize(client)
         if client.config.region.nil? or client.config.region == ''
-          msg = "missing region; use :region option or "
-          msg << "export region name to ENV['AWS_REGION']"
-          raise Errors::MissingRegionError, msg
+          raise Errors::MissingRegionError
         end
       end
 

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

@@ -1,35 +1,22 @@
 module Aws
   module Plugins
+    # @api private
     class ResponsePaging < Seahorse::Client::Plugin
 
-      def add_handlers(handlers, config)
-        handlers.add(Handler,
-          operations: pageable_operations(config),
-          step: :initialize,
-          priority: 90)
-      end
-
-      private
-
-      def pageable_operations(config)
-        config.api.operations.inject([]) do |pageable, (name, operation)|
-          pageable << name if operation[:pager]
-          pageable
-        end
-      end
-
-      # @api private
       class Handler < Seahorse::Client::Handler
 
         def call(context)
           context[:original_params] = context.params
           resp = @handler.call(context)
           resp.extend(PageableResponse)
-          resp.pager = context.operation[:pager]
+          resp.pager = context.operation[:pager] || Aws::Pager::NullPager.new
           resp
         end
 
       end
+
+      handle(Handler, step: :initialize, priority: 90)
+
     end
   end
 end

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

@@ -2,16 +2,19 @@ require 'set'
 
 module Aws
   module Plugins
-
-    # @seahorse.client.option [Integer] :retry_limit (3)
-    #   The maximum number of times to retry failed requests.  Only
-    #   ~ 500 level server errors and certain ~ 400 level client errors
-    #   are retried.  Generally, these are throttling errors, data
-    #   checksum errors, networking errors, timeout errors and auth
-    #   errors from expired credentials.
+    # @api private
     class RetryErrors < Seahorse::Client::Plugin
 
-      option(:retry_limit, 3)
+      option(:retry_limit,
+        default: 3,
+        doc_type: Integer,
+        docstring: <<-DOCS)
+The maximum number of times to retry failed requests.  Only
+~ 500 level server errors and certain ~ 400 level client errors
+are retried.  Generally, these are throttling errors, data
+checksum errors, networking errors, timeout errors and auth
+errors from expired credentials.
+        DOCS
 
       option(:retry_backoff, lambda { |c| Kernel.sleep(2 ** c.retries * 0.3) })
 
@@ -32,8 +35,6 @@ module Aws
           'ProvisionedThroughputExceededException', # dynamodb
           'RequestLimitExceeded',                   # ec2
           'BandwidthLimitExceeded',                 # cloud search
-          'LimitExceededException',                 # kinesis
-          'TooManyRequestsException',               # batch
         ])
 
         CHECKSUM_ERRORS = Set.new([
@@ -71,25 +72,6 @@ module Aws
           (500..599).include?(@http_status_code)
         end
 
-        def endpoint_discovery?(context)
-          return false unless context.operation.endpoint_discovery
-
-          if @http_status_code == 421 ||
-            extract_name(@error) == 'InvalidEndpointException'
-            @error = Errors::EndpointDiscoveryError.new
-          end
-
-          # When endpoint discovery error occurs
-          # evict the endpoint from cache
-          if @error.is_a?(Errors::EndpointDiscoveryError)
-            key = context.config.endpoint_cache.extract_key(context)
-            context.config.endpoint_cache.delete(key)
-            true
-          else
-            false
-          end
-        end
-
         private
 
         def extract_name(error)
@@ -154,8 +136,7 @@ module Aws
           error.throttling_error? or
           error.checksum? or
           error.networking? or
-          error.server? or
-          error.endpoint_discovery?(context)
+          error.server?
         end
 
         def refreshable_credentials?(context)

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

@@ -0,0 +1,51 @@
+module Aws
+  module Plugins
+    # @api private
+    class SignatureV2 < Seahorse::Client::Plugin
+
+      option(:v2_signer) do |cfg|
+        Aws::Sigv2::Signer.new(credentials_provider: cfg.credentials)
+      end
+
+      def add_handlers(handlers, _)
+        handlers.add(Handler, step: :sign)
+      end
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          apply_signature(
+            context.http_request,
+            context.config.v2_signer
+          )
+          @handler.call(context)
+        end
+
+        private
+
+        def apply_signature(req, signer)
+
+          param_list = req.body.param_list
+          param_list.delete('Timestamp') # in case of re-signing
+
+          signature = signer.sign_request(
+            http_method: req.http_method,
+            url: req.endpoint,
+            params: param_list.inject({}) do |hash, param|
+              hash[param.name] = param.value
+              hash
+            end
+          )
+
+          # apply signature
+          signature.each_pair do |param_name, param_value|
+            param_list.set(param_name, param_value)
+          end
+
+          req.body = param_list.to_io
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+require 'aws-sigv4'
+
+module Aws
+  module Plugins
+    # @api private
+    class SignatureV4 < Seahorse::Client::Plugin
+
+      option(:sigv4_signer) do |cfg|
+        SignatureV4.build_signer(cfg)
+      end
+
+      option(:sigv4_name) do |cfg|
+        cfg.api.metadata['signingName'] || cfg.api.metadata['endpointPrefix']
+      end
+
+      option(:sigv4_region) do |cfg|
+
+        # The signature version 4 signing region is most
+        # commonly the configured region. There are a few
+        # notable exceptions:
+        #
+        # * Some services have a global endpoint to the entire
+        #   partition. For example, when constructing a route53
+        #   client for a region like "us-west-2", we will
+        #   always use "route53.amazonaws.com". This endpoint
+        #   is actually global to the entire partition,
+        #   and must be signed as "us-east-1".
+        #
+        # * When the region is configured, but it is configured
+        #   to a non region, such as "aws-global". This is similar
+        #   to the previous case. We use the Aws::Partitions::EndpointProvider
+        #   to resolve to the actual signing region.
+        #
+        prefix = cfg.api.metadata['endpointPrefix']
+        if prefix && cfg.endpoint.to_s.match(/#{prefix}\.amazonaws\.com/)
+          'us-east-1'
+        elsif cfg.region
+          Aws::Partitions::EndpointProvider.signing_region(cfg.region, cfg.sigv4_name)
+        end
+      end
+
+      option(:unsigned_operations) do |cfg|
+        cfg.api.operation_names.inject([]) do |unsigned, operation_name|
+          if cfg.api.operation(operation_name)['authtype'] != 'none'
+            unsigned
+          else
+            unsigned << operation_name
+          end
+        end
+      end
+
+      def add_handlers(handlers, cfg)
+        if cfg.unsigned_operations.empty?
+          handlers.add(Handler, step: :sign)
+        else
+          operations = cfg.api.operation_names - cfg.unsigned_operations
+          handlers.add(Handler, step: :sign, operations: operations)
+        end
+      end
+
+      class Handler < Seahorse::Client::Handler
+        def call(context)
+          SignatureV4.apply_signature(context: context)
+          @handler.call(context)
+        end
+      end
+
+      class MissingCredentialsSigner
+        def sign_request(*args)
+          raise Errors::MissingCredentialsError
+        end
+      end
+
+      class << self
+
+        # @api private
+        def build_signer(cfg)
+          if cfg.credentials && cfg.sigv4_region
+            Aws::Sigv4::Signer.new(
+              service: cfg.sigv4_name,
+              region: cfg.sigv4_region,
+              credentials_provider: cfg.credentials,
+              unsigned_headers: ['content-length', 'user-agent']
+            )
+          elsif cfg.credentials
+            raise Errors::MissingRegionError
+          elsif cfg.sigv4_region
+            # Instead of raising now, we return a signer that raises only
+            # if you attempt to sign a request. Some services have unsigned
+            # operations and it okay to initialize clients for these services
+            # without credentials. Unsigned operations have an "authtype"
+            # trait of "none".
+            MissingCredentialsSigner.new
+          end
+        end
+
+        # @api private
+        def apply_signature(options = {})
+          context = options[:context]
+          signer = options[:signer] || context.config.sigv4_signer
+          req = context.http_request
+
+          # in case this request is being re-signed
+          req.headers.delete('Authorization')
+          req.headers.delete('X-Amz-Security-Token')
+          req.headers.delete('X-Amz-Date')
+
+          # compute the signature
+          begin
+            signature = signer.sign_request(
+              http_method: req.http_method,
+              url: req.endpoint,
+              headers: req.headers,
+              body: req.body
+            )
+          rescue Aws::Sigv4::Errors::MissingCredentialsError
+            raise Aws::Errors::MissingCredentialsError
+          end
+
+          # apply signature headers
+          req.headers.update(signature.headers)
+
+          # add request metadata with signature components for debugging
+          context[:canonical_request] = signature.canonical_request
+          context[:string_to_sign] = signature.string_to_sign
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,18 +1,20 @@
 module Aws
   module Plugins
-
-    # @seahorse.client.option [Boolean] :stub_responses (false)
-    #   Causes the client to return stubbed responses. By default
-    #   fake responses are generated and returned. You can specify
-    #   the response data to return or errors to raise by calling
-    #   {ClientStubs#stub_responses}. See {ClientStubs} for more information.
-    #
-    #   ** Please note ** When response stubbing is enabled, no HTTP
-    #   requests are made, and retries are disabled.
-    #
+    # @api private
     class StubResponses < Seahorse::Client::Plugin
 
-      option(:stub_responses, false)
+      option(:stub_responses,
+        default: false,
+        doc_type: 'Boolean',
+        docstring: <<-DOCS)
+Causes the client to return stubbed responses. By default
+fake responses are generated and returned. You can specify
+the response data to return or errors to raise by calling
+{ClientStubs#stub_responses}. See {ClientStubs} for more information.
+
+** Please note ** When response stubbing is enabled, no HTTP
+requests are made, and retries are disabled.
+        DOCS
 
       option(:region) do |config|
         'us-stubbed-1' if config.stub_responses

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

@@ -1,5 +1,6 @@
 module Aws
   module Plugins
+    # @api private
     class UserAgent < Seahorse::Client::Plugin
 
       option(:user_agent_suffix)
@@ -13,12 +14,21 @@ module Aws
         end
 
         def set_user_agent(context)
-          ua = "aws-sdk-ruby2/#{VERSION} %s/%s %s %s" % [
-            (RUBY_ENGINE rescue nil or "ruby"),
-            RUBY_VERSION,
-            RUBY_PLATFORM,
-            context.config.user_agent_suffix,
-          ]
+          ua = "aws-sdk-ruby3/#{CORE_GEM_VERSION}"
+
+          begin
+            ua += " #{RUBY_ENGINE}"
+          rescue
+          end
+
+          ua += " #{RUBY_VERSION}/#{RUBY_PLATFORM}"
+
+          if context[:gem_name] && context[:gem_version]
+            ua += " #{context[:gem_name]}/#{context[:gem_version]}"
+          end
+
+          ua += " #{context.config.user_agent_suffix}" if context.config.user_agent_suffix
+
           context.http_request.headers['User-Agent'] = ua.strip
         end
 

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

@@ -0,0 +1,5 @@
+require_relative 'query/ec2_param_builder'
+require_relative 'query/handler'
+require_relative 'query/param'
+require_relative 'query/param_builder'
+require_relative 'query/param_list'