aws-sdk-core 2.3.23 → 3.89.1

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
@@ -117,15 +122,15 @@ module Seahorse
         end
 
         def on_headers(status_code_range = nil, &block)
-          @listeners[:headers] << listener(status_code_range, Proc.new)
+          @listeners[:headers] << listener(status_code_range, block)
         end
 
         def on_data(&callback)
-          @listeners[:data] << Proc.new
+          @listeners[:data] << callback
         end
 
         def on_done(status_code_range = nil, &callback)
-          listener = listener(status_code_range, Proc.new)
+          listener = listener(status_code_range, callback)
           if @done
             listener.call
           else

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,7 +173,11 @@ module Seahorse
         end
 
         def _http_response_body(response)
-          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,19 +1,24 @@
+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
 
         @pools_mutex = Mutex.new
         @pools = {}
+        @default_logger = Logger.new($stdout)
 
         OPTIONS = {
           http_proxy: nil,
@@ -36,10 +41,7 @@ module Seahorse
             instance_variable_set("@#{opt_name}", value)
           end
           @pool_mutex = Mutex.new
-          @pool = Hash.new do |pool, endpoint|
-            pool[endpoint] = []
-            pool[endpoint]
-          end
+          @pool = {}
         end
 
         OPTIONS.keys.each do |attr_name|
@@ -51,14 +53,14 @@ module Seahorse
 
         # Makes an HTTP request, yielding a Net::HTTPResponse object.
         #
-        #   pool.request('http://domain', Net::HTTP::Get.new('/')) do |resp|
+        #   pool.request(URI.parse('http://domain'), Net::HTTP::Get.new('/')) do |resp|
         #     puts resp.code # status code
         #     puts resp.to_h.inspect # dump the headers
         #     puts resp.body
         #   end
         #
-        # @param [String] endpoint The HTTP(S) endpoint to
-        #    connect to (e.g. 'https://domain.com').
+        # @param [URI::HTTP, URI::HTTPS] endpoint The HTTP(S) endpoint
+        #    to connect to (e.g. 'https://domain.com').
         #
         # @param [Net::HTTPRequest] request The request to make.  This can be
         #   any request object from Net::HTTP (e.g. Net::HTTP::Get,
@@ -86,7 +88,9 @@ module Seahorse
           # attempt to recycle an already open session
           @pool_mutex.synchronize do
             _clean
-            session = @pool[endpoint].shift
+            if @pool.key?(endpoint)
+              session = @pool[endpoint].shift
+            end
           end
 
           begin
@@ -100,7 +104,10 @@ module Seahorse
             raise
           else
             # No error raised? Good, check the session into the pool.
-            @pool_mutex.synchronize { @pool[endpoint] << session }
+            @pool_mutex.synchronize do
+              @pool[endpoint] = [] unless @pool.key?(endpoint)
+              @pool[endpoint] << session
+            end
           end
           nil
         end
@@ -125,7 +132,7 @@ module Seahorse
           nil
         end
 
-        # Closes and removes removes all sessions from the pool.
+        # Closes and removes all sessions from the pool.
         # If empty! is called while there are outstanding requests they may
         # get checked back into the pool, leaving the pool in a non-empty
         # state.
@@ -159,16 +166,16 @@ module Seahorse
           #   requests through.  Formatted like 'http://proxy.com:123'.
           #
           # @option options [Float] :http_open_timeout (15) The number of
-          #   seconds to wait when opening a HTTP session before rasing a
+          #   seconds to wait when opening an HTTP session before raising a
           #   `Timeout::Error`.
           #
           # @option options [Integer] :http_read_timeout (60) The default
           #   number of seconds to wait for response data.  This value can
           #   safely be set
-          #   per-request on the session yeidled by {#session_for}.
+          #   per-request on the session yielded by {#session_for}.
           #
           # @option options [Float] :http_idle_timeout (5) The number of
-          #   seconds a connection is allowed to sit idble before it is
+          #   seconds a connection is allowed to sit idle before it is
           #   considered stale.  Stale connections are closed and removed
           #   from the pool before making a request.
           #
@@ -177,7 +184,7 @@ module Seahorse
           #   request body.  This option has no effect unless the request has
           #   "Expect" header set to "100-continue".  Defaults to `nil` which
           #   disables this behaviour.  This value can safely be set per
-          #   request on the session yeidled by {#session_for}.
+          #   request on the session yielded by {#session_for}.
           #
           # @option options [Boolean] :http_wire_trace (false) When `true`,
           #   HTTP debug output will be sent to the `:logger`.
@@ -194,13 +201,13 @@ module Seahorse
           # @option options [String] :ssl_ca_bundle Full path to the SSL
           #   certificate authority bundle file that should be used when
           #   verifying peer certificates.  If you do not pass
-          #   `:ssl_ca_bundle` or `:ssl_ca_directory` the the system default
+          #   `:ssl_ca_bundle` or `:ssl_ca_directory` the system default
           #   will be used if available.
           #
           # @option options [String] :ssl_ca_directory 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 the
+          #   not pass `:ssl_ca_bundle` or `:ssl_ca_directory` the
           #   system default will be used if available.
           #
           # @return [ConnectionPool]
@@ -211,10 +218,12 @@ module Seahorse
             end
           end
 
-          # @return [Array<ConnectionPool>] Returns a list of of the
+          # @return [Array<ConnectionPool>] Returns a list of the
           #   constructed connection pools.
           def pools
-            @pools.values
+            @pools_mutex.synchronize do
+              @pools.values
+            end
           end
 
           private
@@ -223,7 +232,7 @@ module Seahorse
           # @return [Hash]
           def pool_options options
             wire_trace = !!options[:http_wire_trace]
-            logger = options[:logger] || Logger.new($stdout) if wire_trace
+            logger = options[:logger] || @default_logger if wire_trace
             verify_peer = options.key?(:ssl_verify_peer) ?
               !!options[:ssl_verify_peer] : true
             {
@@ -245,6 +254,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]
@@ -255,14 +275,12 @@ 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?
           http.open_timeout = http_open_timeout
+          http.keep_alive_timeout = http_idle_timeout if http.respond_to?(:keep_alive_timeout=)
 
           if endpoint.scheme == 'https'
             http.use_ssl = true
@@ -285,12 +303,12 @@ module Seahorse
         # Removes stale sessions from the pool.  This method *must* be called
         # @note **Must** be called behind a `@pool_mutex` synchronize block.
         def _clean
-          now = Time.now
+          now = Aws::Util.monotonic_milliseconds
           @pool.each_pair do |endpoint,sessions|
             sessions.delete_if do |session|
               if
                 session.last_used.nil? or
-                now - session.last_used > http_idle_timeout
+                now - session.last_used > http_idle_timeout * 1000
               then
                 session.finish
                 true
@@ -299,7 +317,7 @@ module Seahorse
           end
         end
 
-        # Helper methods extended onto Net::HTTPSession objects opend by the
+        # Helper methods extended onto Net::HTTPSession objects opened by the
         # connection pool.
         # @api private
         class ExtendedSession < Delegator
@@ -309,7 +327,7 @@ module Seahorse
             @http = http
           end
 
-          # @return [Time,nil]
+          # @return [Integer,nil]
           attr_reader :last_used
 
           def __getobj__
@@ -322,8 +340,8 @@ module Seahorse
 
           # Sends the request and tracks that this session has been used.
           def request(*args, &block)
-            @last_used = Time.now
             @http.request(*args, &block)
+            @last_used = Aws::Util.monotonic_milliseconds
           end
 
           # Attempts to close/finish the session without raising an error.