aws-sdk-core 2.11.445 → 3.86.0

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

@@ -0,0 +1,151 @@
+if RUBY_VERSION >= '2.1'
+  begin
+    require 'http/2'
+  rescue LoadError; end
+end
+require 'securerandom'
+
+module Seahorse
+  module Client
+    # @api private
+    module H2
+
+      NETWORK_ERRORS = [
+        SocketError, EOFError, IOError, Timeout::Error,
+        Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EPIPE,
+        Errno::EINVAL, Errno::ETIMEDOUT, OpenSSL::SSL::SSLError,
+        Errno::EHOSTUNREACH, Errno::ECONNREFUSED,# OpenSSL::SSL::SSLErrorWaitReadable
+      ]
+
+      # @api private
+      DNS_ERROR_MESSAGES = [
+        'getaddrinfo: nodename nor servname provided, or not known', # MacOS
+        'getaddrinfo: Name or service not known' # GNU
+      ]
+
+      class Handler < Client::Handler
+
+        def call(context)
+          stream = nil
+          begin
+            conn = context.client.connection
+            stream = conn.new_stream
+
+            stream_mutex = Mutex.new
+            close_condition = ConditionVariable.new
+            sync_queue = Queue.new
+
+            conn.connect(context.http_request.endpoint)
+            _register_callbacks(
+              context.http_response,
+              stream,
+              stream_mutex,
+              close_condition,
+              sync_queue
+            )
+
+            conn.debug_output("sending initial request ...")
+            if input_emitter = context[:input_event_emitter]
+              _send_initial_headers(context.http_request, stream)
+
+              # prepare for sending events later
+              input_emitter.stream = stream
+              # request sigv4 serves as the initial #prior_signature
+              input_emitter.encoder.prior_signature =
+                context.http_request.headers['authorization'].split('Signature=').last
+              input_emitter.validate_event = context.config.validate_params
+            else
+              _send_initial_headers(context.http_request, stream)
+              _send_initial_data(context.http_request, stream)
+            end
+
+            conn.start(stream)
+          rescue *NETWORK_ERRORS => error
+            error = NetworkingError.new(
+              error, error_message(context.http_request, error))
+            context.http_response.signal_error(error)
+          rescue => error
+            conn.debug_output(error.inspect)
+            # not retryable
+            context.http_response.signal_error(error)
+          end
+
+          AsyncResponse.new(
+            context: context,
+            stream: stream,
+            stream_mutex: stream_mutex,
+            close_condition: close_condition,
+            sync_queue: sync_queue
+          )
+        end
+
+        private
+
+        def _register_callbacks(resp, stream, stream_mutex, close_condition, sync_queue)
+          stream.on(:headers) do |headers|
+            resp.signal_headers(headers)
+          end
+
+          stream.on(:data) do |data|
+            resp.signal_data(data)
+          end
+
+          stream.on(:close) do
+            resp.signal_done
+            # block until #wait is ready for signal
+            # else deadlock may happen because #signal happened
+            # eariler than #wait (see AsyncResponse#wait)
+            sync_queue.pop
+            stream_mutex.synchronize {
+              close_condition.signal
+            }
+          end
+        end
+
+        def _send_initial_headers(req, stream)
+          begin
+            headers = _h2_headers(req)
+            stream.headers(headers, end_stream: false)
+          rescue => e
+            raise Http2InitialRequestError.new(e)
+          end
+        end
+
+        def _send_initial_data(req, stream)
+          begin
+            data = req.body.read
+            stream.data(data, end_stream: true)
+          rescue => e
+            raise Http2InitialRequestError.new(e)
+          end
+          data
+        end
+
+        # H2 pseudo headers
+        # https://http2.github.io/http2-spec/#rfc.section.8.1.2.3
+        def _h2_headers(req)
+          headers = {}
+          headers[':method'] = req.http_method.upcase
+          headers[':scheme'] = req.endpoint.scheme
+          headers[':path'] = req.endpoint.path.empty? ? '/' : req.endpoint.path
+          if req.endpoint.query && !req.endpoint.query.empty?
+            headers[':path'] += "?#{req.endpoint.query}"
+          end
+          req.headers.each {|k, v| headers[k.downcase] = v }
+          headers
+        end
+
+        def error_message(req, error)
+          if error.is_a?(SocketError) && DNS_ERROR_MESSAGES.include?(error.message)
+            host = req.endpoint.host
+            "unable to connect to `#{host}`; SocketError: #{error.message}"
+          else
+            error.message
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/seahorse/client/handler_list_entry.rb

@@ -77,8 +77,8 @@ module Seahorse
         if options.key?(name)
           options[name]
         else
-          msg = "invalid :priority `%s', must be between 0 and 99"
-          raise ArgumentError, msg % priority.inspect
+          msg = "missing option: `%s'"
+          raise ArgumentError, msg % name.inspect
         end
       end
 

data/lib/seahorse/client/http/async_response.rb

@@ -0,0 +1,42 @@
+module Seahorse
+  module Client
+    module Http
+      class AsyncResponse < Seahorse::Client::Http::Response
+
+        def initialize(options = {})
+          super
+        end
+
+        def signal_headers(headers)
+          # H2 headers arrive as array of pair
+          hash = headers.inject({}) do |h, pair|
+            key, value = pair
+            h[key] = value
+            h
+          end
+          @status_code = hash[":status"].to_i
+          @headers = Headers.new(hash)
+          emit(:headers, @status_code, @headers)
+        end
+
+        def signal_done(options = {})
+          # H2 only has header and body
+          # ':status' header will be sent back
+          if options.keys.sort == [:body, :headers]
+            signal_headers(options[:headers])
+            signal_data(options[:body])
+            signal_done
+          elsif options.empty?
+            @body.rewind if @body.respond_to?(:rewind)
+            @done = true
+            emit(:done)
+          else
+            msg = "options must be empty or must contain :headers and :body"
+            raise ArgumentError, msg
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/seahorse/client/http/response.rb

@@ -40,12 +40,17 @@ module Seahorse
           end
         end
 
-        # @return [String]
+        # @return [String|Array]
         def body_contents
-          body.rewind
-          contents = body.read
-          body.rewind
-          contents
+          if body.is_a?(Array)
+            # an array of parsed events
+            body
+          else
+            body.rewind
+            contents = body.read
+            body.rewind
+            contents
+          end
         end
 
         # @param [Integer] status_code

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

@@ -2,6 +2,8 @@ require 'pathname'
 
 module Seahorse
   module Client
+    # @deprecated Use Aws::Logging instead.
+    # @api private
     module Logging
 
       # A log formatter receives a {Response} object and return
@@ -171,9 +173,11 @@ module Seahorse
         end
 
         def _http_response_body(response)
-          response.context.http_response.body.respond_to?(:rewind) ?
-            summarize_value(response.context.http_response.body_contents) :
+          if response.context.http_response.body.respond_to?(:rewind)
+            summarize_value(response.context.http_response.body_contents)
+          else
             ''
+          end
         end
 
         def _error_class(response)

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

@@ -1,5 +1,7 @@
 module Seahorse
   module Client
+    # @deprecated Use Aws::Logging instead.
+    # @api private
     module Logging
       class Handler < Client::Handler
 

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

@@ -1,13 +1,17 @@
+require 'cgi'
 require 'net/http'
 require 'net/https'
 require 'delegate'
 require 'thread'
 require 'logger'
 
+require_relative 'patches'
+
 Seahorse::Client::NetHttp::Patches.apply!
 
 module Seahorse
   module Client
+    # @api private
     module NetHttp
 
       class ConnectionPool
@@ -249,6 +253,17 @@ module Seahorse
 
         private
 
+        # Extract the parts of the http_proxy URI
+        # @return [Array(String)]
+        def http_proxy_parts
+          return [
+            http_proxy.host,
+            http_proxy.port,
+            (http_proxy.user && CGI::unescape(http_proxy.user)),
+            (http_proxy.password && CGI::unescape(http_proxy.password))
+          ]
+        end
+
         # Starts and returns a new HTTP(S) session.
         # @param [String] endpoint
         # @return [Net::HTTPSession]
@@ -259,10 +274,7 @@ module Seahorse
           args = []
           args << endpoint.host
           args << endpoint.port
-          args << http_proxy.host
-          args << http_proxy.port
-          args << http_proxy.user
-          args << http_proxy.password
+          args += http_proxy_parts
 
           http = ExtendedSession.new(Net::HTTP.new(*args.compact))
           http.set_debug_output(logger) if http_wire_trace?

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

@@ -1,7 +1,9 @@
+require 'net/https'
 require 'openssl'
 
 module Seahorse
   module Client
+    # @api private
     module NetHttp
 
       # The default HTTP handler for Seahorse::Client.  This is based on
@@ -117,6 +119,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

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

@@ -2,12 +2,20 @@ require 'net/http'
 
 module Seahorse
   module Client
+    # @api private
     module NetHttp
 
       # @api private
       module Patches
 
         def self.apply!
+          return unless RUBY_VERSION < '2.5'
+          if RUBY_VERSION >= '2.3'
+            Net::HTTP::IDEMPOTENT_METHODS_.clear
+            return
+          end
+          # no further patches needed for above versions
+
           if RUBY_VERSION >= '2.0'
             Net::HTTP.send(:include, Ruby_2)
             Net::HTTP::IDEMPOTENT_METHODS_.clear
@@ -28,7 +36,7 @@ module Seahorse
                 begin
                   res = Net::HTTPResponse.read_new(@socket)
                   res.decode_content = req.decode_content
-                end while res.kind_of?(Net::HTTPContinue)
+                end while res.kind_of?(Net::HTTPInformation)
 
                 res.uri = req.uri
 

data/lib/seahorse/client/networking_error.rb

@@ -11,5 +11,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

@@ -7,8 +7,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 +42,24 @@ module Seahorse
 
       class << self
 
-        def option(name, default = nil, &block)
-          if block_given?
-            options << [[name], block]
+        # @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 Hash === default
+            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 +90,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
+          if @doc_default.nil? && !default.is_a?(Proc)
+            default
+          else
+            @doc_default
+          end
+        end
+
+        def documented?
+          !!docstring
+        end
+
       end
     end
   end