aws-sdk-core 2.11.212 → 3.170.0

data/lib/seahorse/client/net_http/handler.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
+require 'net/https'
 require 'openssl'
 
 module Seahorse
   module Client
+    # @api private
     module NetHttp
 
       # The default HTTP handler for Seahorse::Client.  This is based on
@@ -11,8 +15,8 @@ module Seahorse
         # @api private
         class TruncatedBodyError < IOError
           def initialize(bytes_expected, bytes_received)
-            msg = "http response body truncated, expected #{bytes_expected} "
-            msg << "bytes, received #{bytes_received} bytes"
+            msg = "http response body truncated, expected #{bytes_expected} "\
+                  "bytes, received #{bytes_received} bytes"
             super(msg)
           end
         end
@@ -21,7 +25,8 @@ module Seahorse
           SocketError, EOFError, IOError, Timeout::Error,
           Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EPIPE,
           Errno::EINVAL, Errno::ETIMEDOUT, OpenSSL::SSL::SSLError,
-          Errno::EHOSTUNREACH, Errno::ECONNREFUSED
+          Errno::EHOSTUNREACH, Errno::ECONNREFUSED,
+          Net::HTTPFatalError # for proxy connection failures
         ]
 
         # does not exist in Ruby 1.9.3
@@ -69,8 +74,9 @@ module Seahorse
         # @return [void]
         def transmit(config, req, resp)
           session(config, req) do |http|
+            # Monkey patch default content-type set by Net::HTTP
+            Thread.current[:net_http_skip_default_content_type] = true
             http.request(build_net_request(req)) do |net_resp|
-
               status_code = net_resp.code.to_i
               headers = extract_headers(net_resp)
 
@@ -91,6 +97,9 @@ module Seahorse
         rescue => error
           # not retryable
           resp.signal_error(error)
+        ensure
+          # ensure we turn off monkey patch in case of error
+          Thread.current[:net_http_skip_default_content_type] = nil
         end
 
         def complete_response(req, resp, bytes_received)
@@ -117,6 +126,9 @@ module Seahorse
 
         def session(config, req, &block)
           pool_for(config).session_for(req.endpoint) do |http|
+            # Ruby 2.5, can disable retries for idempotent operations
+            # avoid patching for Ruby 2.5 for disable retry
+            http.max_retries = 0 if http.respond_to?(:max_retries)
             http.read_timeout = config.http_read_timeout
             yield(http)
           end
@@ -139,7 +151,12 @@ module Seahorse
         def build_net_request(request)
           request_class = net_http_request_class(request)
           req = request_class.new(request.endpoint.request_uri, headers(request))
-          req.body_stream = request.body
+          # Net::HTTP adds a default Content-Type when a body is present.
+          # Set the body stream when it has an unknown size or when it is > 0.
+          if !request.body.respond_to?(:size) ||
+             (request.body.respond_to?(:size) && request.body.size > 0)
+            req.body_stream = request.body
+          end
           req
         end
 
@@ -158,8 +175,13 @@ module Seahorse
         # @return [Hash] Returns a vanilla hash of headers to send with the
         #   HTTP request.
         def headers(request)
-          # setting these to stop net/http from providing defaults
-          headers = { 'content-type' => '', 'accept-encoding' => '' }
+          # Net::HTTP adds a default header for accept-encoding (2.0.0+).
+          # Setting a default empty value defeats this.
+          #
+          # Removing this is necessary for most services to not break request
+          # signatures as well as dynamodb crc32 checks (these fail if the
+          # response is gzipped).
+          headers = { 'accept-encoding' => '' }
           request.headers.each_pair do |key, value|
             headers[key] = value
           end

data/lib/seahorse/client/net_http/patches.rb

@@ -1,97 +1,36 @@
+# frozen_string_literal: true
+
 require 'net/http'
 
 module Seahorse
   module Client
+    # @api private
     module NetHttp
 
       # @api private
       module Patches
 
         def self.apply!
-          if RUBY_VERSION >= '2.0'
-            Net::HTTP.send(:include, Ruby_2)
-            Net::HTTP::IDEMPOTENT_METHODS_.clear
-          elsif RUBY_VERSION >= '1.9.3'
-            Net::HTTP.send(:include, Ruby_1_9_3)
-          end
-          Net::HTTP.send(:alias_method, :old_transport_request, :transport_request)
-          Net::HTTP.send(:alias_method, :transport_request, :new_transport_request)
-        end
-
-        module Ruby_2
-          def new_transport_request(req)
-            count = 0
-            begin
-              begin_transport req
-              res = catch(:response) {
-                req.exec @socket, @curr_http_version, edit_path(req.path)
-                begin
-                  res = Net::HTTPResponse.read_new(@socket)
-                  res.decode_content = req.decode_content
-                end while res.kind_of?(Net::HTTPContinue)
+          Net::HTTPGenericRequest.prepend(PatchDefaultContentType)
+          return unless RUBY_VERSION < '2.5'
 
-                res.uri = req.uri
-
-                res
-              }
-              res.reading_body(@socket, req.response_body_permitted?) {
-                yield res if block_given?
-              }
-            rescue Net::OpenTimeout
-              raise
-            rescue Net::ReadTimeout, IOError, EOFError,
-                   Errno::ECONNRESET, Errno::ECONNABORTED, Errno::EPIPE,
-                   # avoid a dependency on OpenSSL
-                   defined?(OpenSSL::SSL) ? OpenSSL::SSL::SSLError : IOError,
-                   Timeout::Error => exception
-              if count == 0 && Net::HTTP::IDEMPOTENT_METHODS_.include?(req.method)
-                count += 1
-                @socket.close if @socket and not @socket.closed?
-                D "Conn close because of error #{exception}, and retry"
-                if req.body_stream
-                  if req.body_stream.respond_to?(:rewind)
-                    req.body_stream.rewind
-                  else
-                    raise
-                  end
-                end
-                retry
-              end
-              D "Conn close because of error #{exception}"
-              @socket.close if @socket and not @socket.closed?
-              raise
-            end
-
-            end_transport req, res
-            res
-          rescue => exception
-            D "Conn close because of error #{exception}"
-            @socket.close if @socket and not @socket.closed?
-            raise exception
-          end
+          Net::HTTP::IDEMPOTENT_METHODS_.clear
         end
 
-        module Ruby_1_9_3
-          def new_transport_request(req)
-            begin_transport req
-            res = catch(:response) {
-              req.exec @socket, @curr_http_version, edit_path(req.path)
-              begin
-                res = Net::HTTPResponse.read_new(@socket)
-              end while res.kind_of?(Net::HTTPContinue)
-              res
-            }
-            res.reading_body(@socket, req.response_body_permitted?) {
-              yield res if block_given?
-            }
-            end_transport req, res
-            res
-          rescue => exception
-            D "Conn close because of error #{exception}"
-            @socket.close if @socket and not @socket.closed?
-            raise exception
+        # For requests with bodys, Net::HTTP sets a default content type of:
+        #   'application/x-www-form-urlencoded'
+        # There are cases where we should not send content type at all.
+        # Even when no body is supplied, Net::HTTP uses a default empty body
+        # and sets it anyway. This patch disables the behavior when a Thread
+        # local variable is set.
+        module PatchDefaultContentType
+          def supply_default_content_type
+            return if Thread.current[:net_http_skip_default_content_type]
+
+            super
           end
         end
+
       end
     end
   end

data/lib/seahorse/client/networking_error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seahorse
   module Client
     class NetworkingError < StandardError
@@ -11,5 +13,33 @@ module Seahorse
       attr_reader :original_error
 
     end
+
+    # Raised when sending initial headers and data failed
+    # for event stream requests over Http2
+    class Http2InitialRequestError < StandardError
+
+      def initialize(error)
+        @original_error = error
+      end
+
+      # @return [HTTP2::Error]
+      attr_reader :original_error
+
+    end
+
+    # Raised when connection failed to initialize a new stream
+    class Http2StreamInitializeError < StandardError
+
+      def initialize(error)
+        @original_error = error
+      end
+
+      # @return [HTTP2::Error]
+      attr_reader :original_error
+
+    end
+
+    # Rasied when trying to use an closed connection
+    class Http2ConnectionClosedError < StandardError; end
   end
 end

data/lib/seahorse/client/plugin.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seahorse
   module Client
     class Plugin
@@ -7,8 +9,12 @@ module Seahorse
       # @param [Configuration] config
       # @return [void]
       def add_options(config)
-        self.class.options.each do |args, block|
-          config.add_option(*args, &block)
+        self.class.options.each do |option|
+          if option.default_block
+            config.add_option(option.name, &option.default_block)
+          else
+            config.add_option(option.name, option.default)
+          end
         end
       end
 
@@ -38,12 +44,24 @@ module Seahorse
 
       class << self
 
-        def option(name, default = nil, &block)
-          if block_given?
-            options << [[name], Proc.new]
+        # @overload option(name, options = {}, &block)
+        # @option options [Object] :default Can also be set by passing a block.
+        # @option options [String] :doc_default
+        # @option options [Boolean] :required
+        # @option options [String] :doc_type
+        # @option options [String] :docs
+        # @return [void]
+        def option(name, default = nil, options = {}, &block)
+          # For backwards-compat reasons, the default value can be passed as 2nd
+          # positional argument (before the options hash) or as the `:default` option
+          # in the options hash.
+          if default.is_a? Hash
+            options = default
           else
-            options << [[name, default]]
+            options[:default] = default
           end
+          options[:default_block] = block if block_given?
+          self.options << PluginOption.new(name, options)
         end
 
         def before_initialize(&block)
@@ -74,6 +92,51 @@ module Seahorse
           @after_initialize_hooks ||= []
         end
 
+        # @api private
+        def literal(string)
+          CodeLiteral.new(string)
+        end
+
+        # @api private
+        class CodeLiteral < String
+          def inspect
+            to_s
+          end
+        end
+
+      end
+
+      # @api private
+      class PluginOption
+
+        def initialize(name, options = {})
+          @name = name
+          @doc_default = nil
+          options.each_pair do |opt_name, opt_value|
+            self.send("#{opt_name}=", opt_value)
+          end
+        end
+
+        attr_reader :name
+        attr_accessor :default
+        attr_accessor :default_block
+        attr_accessor :required
+        attr_accessor :doc_type
+        attr_writer :doc_default
+        attr_accessor :docstring
+
+        def doc_default(options)
+          if @doc_default.nil? && !default.is_a?(Proc)
+            default
+          else
+            @doc_default.respond_to?(:call) ? @doc_default.call(options) : @doc_default
+          end
+        end
+
+        def documented?
+          !!docstring
+        end
+
       end
     end
   end

data/lib/seahorse/client/plugin_list.rb

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

data/lib/seahorse/client/plugins/content_length.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seahorse
   module Client
     module Plugins
@@ -5,13 +7,22 @@ module Seahorse
 
         # @api private
         class Handler < Client::Handler
+          # https://github.com/ruby/net-http/blob/master/lib/net/http/requests.rb
+          # Methods without body are forwards compatible, because content-length
+          # may be set for requests without body but is technically incorrect.
+          METHODS_WITHOUT_BODY = Set.new(
+            %w[GET HEAD DELETE OPTIONS TRACE COPY MOVE]
+          )
 
           def call(context)
-            length = context.http_request.body.size
-            context.http_request.headers['Content-Length'] = length
+            body = context.http_request.body
+            method = context.http_request.http_method
+            # We use Net::HTTP with body_stream which doesn't do this by default
+            if body.respond_to?(:size) && !METHODS_WITHOUT_BODY.include?(method)
+              context.http_request.headers['Content-Length'] = body.size
+            end
             @handler.call(context)
           end
-
         end
 
         handler(Handler, step: :sign, priority: 0)

data/lib/seahorse/client/plugins/endpoint.rb

@@ -1,24 +1,30 @@
+# frozen_string_literal: true
+
 module Seahorse
   module Client
     module Plugins
-      # @seahorse.client.option [String] :endpoint
-      #    The HTTP or HTTPS endpoint to send requests to.
-      #    For example:
-      #
-      #        'http://example.com'
-      #        'https://example.com'
-      #        'http://example.com:123'
-      #
       class Endpoint < Plugin
 
-        option(:endpoint)
+        option(:endpoint,
+          doc_type: 'String, URI::HTTPS, URI::HTTP',
+          docstring: <<-DOCS)
+Normally you should not configure the `:endpoint` option
+directly. This is normally constructed from the `:region`
+option. Configuring `:endpoint` is normally reserved for
+connecting to test or custom endpoints. The endpoint should
+be a URI formatted like:
+
+    'http://example.com'
+    'https://example.com'
+    'http://example.com:123'
+
+          DOCS
 
         def add_handlers(handlers, config)
           handlers.add(Handler, priority: 90)
         end
 
         def after_initialize(client)
-
           endpoint = client.config.endpoint
           if endpoint.nil?
             msg = "missing required option `:endpoint'"

data/lib/seahorse/client/plugins/h2.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'seahorse/client/h2/handler'
+
+module Seahorse
+  module Client
+    module Plugins
+      class H2 < Plugin
+
+        # H2 Client
+        option(:max_concurrent_streams, default: 100, doc_type: Integer, docstring: <<-DOCS)
+Maximum concurrent streams used in HTTP2 connection, defaults to 100. Note that server may send back
+:settings_max_concurrent_streams value which will take priority when initializing new streams.
+        DOCS
+
+        option(:connection_timeout, default: 60, doc_type: Integer, docstring: <<-DOCS)
+Connection timeout in seconds, defaults to 60 sec.
+        DOCS
+
+        option(:connection_read_timeout, default: 60, doc_type: Integer, docstring: <<-DOCS)
+Connection read timeout in seconds, defaults to 60 sec.
+        DOCS
+
+        option(:read_chunk_size, default: 1024, doc_type: Integer, docstring: '')
+
+        option(:raise_response_errors, default: true, doc_type: 'Boolean', docstring: <<-DOCS)
+Defaults to `true`, raises errors if exist when #wait or #join! is called upon async response.
+        DOCS
+
+        # SSL Context
+        option(:ssl_ca_bundle, default: nil, doc_type: String, docstring: <<-DOCS) do |cfg|
+Full path to the SSL certificate authority bundle file that should be used when
+verifying peer certificates. If you do not pass `:ssl_ca_directory` or `:ssl_ca_bundle`
+the system default will be used if available.
+        DOCS
+          ENV['AWS_CA_BUNDLE'] ||
+            Aws.shared_config.ca_bundle(profile: cfg.profile) if cfg.respond_to?(:profile)
+        end
+
+        option(:ssl_ca_directory, default: nil, doc_type: String, docstring: <<-DOCS)
+Full path of the directory that contains the unbundled SSL certificate authority
+files for verifying peer certificates. If you do not pass `:ssl_ca_bundle` or
+`:ssl_ca_directory` the system default will be used if available.
+        DOCS
+
+        option(:ssl_ca_store, default: nil, doc_type: String, docstring: '')
+
+        option(:ssl_verify_peer, default: true, doc_type: 'Boolean', docstring: <<-DOCS)
+When `true`, SSL peer certificates are verified when establishing a connection.
+        DOCS
+
+        option(:http_wire_trace, default: false, doc_type:  'Boolean', docstring: <<-DOCS)
+When `true`, HTTP2 debug output will be sent to the `:logger`.
+        DOCS
+
+        option(:enable_alpn, default: false, doc_type: 'Boolean', docstring: <<-DOCS)
+Setting to `true` to enable ALPN in HTTP2 over TLS, requires Ruby version >= 2.3 and
+Openssl version >= 1.0.2. Defaults to false. Note: not all service HTTP2 operations
+supports ALPN on server side, please refer to service documentation.
+        DOCS
+
+        option(:logger)
+
+        handler(Client::H2::Handler, step: :send)
+
+      end
+    end
+  end
+end

data/lib/seahorse/client/plugins/logging.rb

@@ -1,29 +1,29 @@
+# frozen_string_literal: true
+
 module Seahorse
   module Client
     module Plugins
-
-      # Enables logging for all requests.  This plugin allows you to configure
-      # your logging device, the log format and the level to log messages at.
-      #
-      # @see Logging::Formatter
-      #
-      # @seahorse.client.option [Logger] :logger (nil) The Logger instance
-      #   to send log messages to.  If this option is not set, logging
-      #   will be disabled.
-      #
-      # @seahorse.client.option [Symbol] :log_level (:info) The log level
-      #   to send messages to the logger at.
-      #
-      # @seahorse.client.option [Logging::LogFormatter] :log_formatter The log
-      #   formatter.  Defaults to {Seahorse::Client::Logging::Formatter.default}.
-      #
+      # @api private
       class Logging < Plugin
 
-        option(:logger, nil)
+        option(:logger,
+          default: nil,
+          doc_type: 'Logger',
+          docstring: <<-DOCS)
+The Logger instance to send log messages to. If this option
+is not set, logging is disabled.
+          DOCS
 
-        option(:log_level, :info)
+        option(:log_level,
+          default: :info,
+          doc_type: Symbol,
+          docstring: 'The log level to send messages to the logger at.')
 
-        option(:log_formatter, Client::Logging::Formatter.default)
+        option(:log_formatter,
+          default: Seahorse::Client::Logging::Formatter.default,
+          doc_default: 'Aws::Log::Formatter.default',
+          doc_type: 'Aws::Log::Formatter',
+          docstring: 'The log formatter.')
 
         def add_handlers(handlers, config)
           if config.logger

data/lib/seahorse/client/plugins/net_http.rb

@@ -1,26 +1,70 @@
+# frozen_string_literal: true
+
+require 'seahorse/client/net_http/handler'
+
 module Seahorse
   module Client
     module Plugins
-
-      # @seahorse.client.option [String] :http_proxy
-      # @seahorse.client.option [Integer] :http_open_timeout (15)
-      # @seahorse.client.option [Integer] :http_read_timeout (60)
-      # @seahorse.client.option [Integer] :http_idle_timeout (5)
-      # @seahorse.client.option [Float] :http_continue_timeout (1)
-      # @seahorse.client.option [Boolean] :http_wire_trace (false)
-      # @seahorse.client.option [Logger] :logger (nil)
-      # @seahorse.client.option [Boolean] :ssl_verify_peer (true)
-      # @seahorse.client.option [String] :ssl_ca_bundle
-      # @seahorse.client.option [String] :ssl_ca_directory
-      # @seahorse.client.option [String] :ssl_ca_store
       class NetHttp < Plugin
 
-        Client::NetHttp::ConnectionPool::OPTIONS.each_pair do |name, default|
-          option(name, default)
+        option(:http_proxy, default: nil, doc_type: String, docstring: '')
+
+        option(:http_open_timeout, default: 15, doc_type: Integer, docstring: '') do |cfg|
+          resolve_http_open_timeout(cfg)
+        end
+
+        option(:http_read_timeout, default: 60, doc_type: Integer, docstring: '') do |cfg|
+          resolve_http_read_timeout(cfg)
+        end
+
+        option(:http_idle_timeout, default: 5, doc_type: Integer, docstring: '')
+
+        option(:http_continue_timeout, default: 1, doc_type: Integer, docstring: '')
+
+        option(:http_wire_trace, default: false, doc_type: 'Boolean', docstring: '')
+
+        option(:ssl_verify_peer, default: true, doc_type: 'Boolean', docstring: '')
+
+        option(:ssl_ca_bundle, doc_type: String, docstring: '') do |cfg|
+          ENV['AWS_CA_BUNDLE'] ||
+            Aws.shared_config.ca_bundle(profile: cfg.profile) if cfg.respond_to?(:profile)
+        end
+
+        option(:ssl_ca_directory, default: nil, doc_type: String, docstring: '')
+
+        option(:ssl_ca_store, default: nil, doc_type: String, docstring: '')
+
+        option(:ssl_timeout, default: nil, doc_type: Float, docstring: '') do |cfg|
+          resolve_ssl_timeout(cfg)
         end
 
+        option(:logger) # for backwards compat
+
         handler(Client::NetHttp::Handler, step: :send)
 
+        def self.resolve_http_open_timeout(cfg)
+          default_mode_value =
+            if cfg.respond_to?(:defaults_mode_config_resolver)
+              cfg.defaults_mode_config_resolver.resolve(:http_open_timeout)
+            end
+          default_mode_value || 15
+        end
+
+        def self.resolve_http_read_timeout(cfg)
+          default_mode_value =
+            if cfg.respond_to?(:defaults_mode_config_resolver)
+              cfg.defaults_mode_config_resolver.resolve(:http_read_timeout)
+            end
+          default_mode_value || 60
+        end
+
+        def self.resolve_ssl_timeout(cfg)
+          default_mode_value =
+            if cfg.respond_to?(:defaults_mode_config_resolver)
+              cfg.defaults_mode_config_resolver.resolve(:ssl_timeout)
+            end
+          default_mode_value || nil
+        end
       end
     end
   end

data/lib/seahorse/client/plugins/operation_methods.rb

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

data/lib/seahorse/client/plugins/raise_response_errors.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module Seahorse
   module Client
     module Plugins
-
-      # @seahorse.client.option [Boolean] :raise_response_errors (true)
-      #   When `true`, response errors are raised.
       class RaiseResponseErrors < Plugin
 
-        option(:raise_response_errors, true)
+        option(:raise_response_errors,
+          default: true,
+          doc_type: 'Boolean',
+          docstring: 'When `true`, response errors are raised.')
 
         # @api private
         class Handler < Client::Handler