aws-sdk-core 3.39.0 → 3.54.2

data/lib/aws-sdk-sts.rb

@@ -40,6 +40,6 @@ require_relative 'aws-sdk-sts/customizations'
 # @service
 module Aws::STS
 
-  GEM_VERSION = '3.39.0'
+  GEM_VERSION = '3.54.2'
 
 end

data/lib/seahorse/client/async_base.rb

@@ -0,0 +1,50 @@
+module Seahorse
+  module Client
+    class AsyncBase < Seahorse::Client::Base
+
+      # default H2 plugins
+      @plugins = PluginList.new([
+        Plugins::Endpoint,
+        Plugins::H2,
+        Plugins::ResponseTarget
+      ])
+
+      def initialize(plugins, options)
+        super
+        @connection = H2::Connection.new(options)
+        @options = options
+      end
+
+      # @return [H2::Connection]
+      attr_reader :connection
+
+      # @return [Array<Symbol>] Returns a list of valid async request
+      #   operation names.
+      def operation_names
+        self.class.api.async_operation_names
+      end
+
+      # Closes the underlying HTTP2 Connection for the client
+      # @return [Symbol] Returns the status of the connection (:closed)
+      def close_connection
+        @connection.close!
+      end
+
+      # Creates a new HTTP2 Connection for the client
+      # @return [Seahorse::Client::H2::Connection]
+      def new_connection
+        if @connection.closed?
+          @connection = H2::Connection.new(@options)
+        else
+          @connection
+        end
+      end
+
+      def connection_errors
+        @connection.errors
+      end
+
+    end
+  end
+end
+

data/lib/seahorse/client/async_response.rb

@@ -0,0 +1,62 @@
+module Seahorse
+  module Client
+    class AsyncResponse
+
+      def initialize(options = {})
+        @response = Response.new(context: options[:context])
+        @stream = options[:stream]
+        @stream_mutex = options[:stream_mutex]
+        @close_condition = options[:close_condition]
+        @sync_queue = options[:sync_queue]
+      end
+
+      def context
+        @response.context
+      end
+
+      def error
+        @response.error
+      end
+
+      def on(range, &block)
+        @response.on(range, &block)
+        self
+      end
+
+      def on_complete(&block)
+        @response.on_complete(&block)
+        self
+      end
+
+      def wait
+        if error && context.config.raise_response_errors
+          raise error
+        elsif @stream
+          # have a sync signal that #signal can be blocked on
+          # else, if #signal is called before #wait
+          # will be waiting for a signal never arrives
+          @sync_queue << "sync_signal"
+          # now #signal is unlocked for
+          # signaling close condition when ready
+          @stream_mutex.synchronize {
+            @close_condition.wait(@stream_mutex)
+          }
+          @response
+        end
+      end
+
+      def join!
+        if error && context.config.raise_response_errors
+          raise error
+        elsif @stream
+          # close callback is waiting
+          # for the "sync_signal"
+          @sync_queue << "sync_signal"
+          @stream.close
+          @response
+        end
+      end
+
+    end
+  end
+end

data/lib/seahorse/client/base.rb

@@ -46,7 +46,7 @@ module Seahorse
       #   names. These are valid arguments to {#build_request} and are also
       #   valid methods.
       def operation_names
-        self.class.api.operation_names
+        self.class.api.operation_names - self.class.api.async_operation_names
       end
 
       private

data/lib/seahorse/client/configuration.rb

@@ -104,7 +104,7 @@ module Seahorse
       #
       # @return [self]
       def add_option(name, default = nil, &block)
-        default = DynamicDefault.new(Proc.new) if block_given?
+        default = DynamicDefault.new(block) if block_given?
         @defaults[name.to_sym] << default
         self
       end
@@ -199,7 +199,9 @@ module Seahorse
           value = @struct[opt_name]
           if value.is_a?(Defaults)
             # this config value is used by endpoint discovery
-            @struct[:regional_endpoint] = true if opt_name == :endpoint
+            if opt_name == :endpoint && @struct.members.include?(:regional_endpoint)
+              @struct[:regional_endpoint] = true
+            end
             resolve_defaults(opt_name, value)
           else
             value

data/lib/seahorse/client/events.rb

@@ -9,7 +9,7 @@ module Seahorse
 
       def emit(event_name, *args, &block)
         @listeners[event_name] ||= []
-        @listeners[event_name] << Proc.new
+        @listeners[event_name] << block if block_given?
       end
 
       def signal(event, *args)

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

@@ -0,0 +1,244 @@
+if RUBY_VERSION >= '2.1'
+  begin
+    require 'http/2'
+  rescue LoadError; end
+end
+require 'openssl'
+require 'socket'
+
+module Seahorse
+  module Client
+    # @api private
+    module H2
+
+      # H2 Connection build on top of `http/2` gem
+      # (requires Ruby >= 2.1)
+      # with TLS layer plus ALPN, requires:
+      # Ruby >= 2.3 and OpenSSL >= 1.0.2
+      class Connection
+
+        OPTIONS = {
+          max_concurrent_streams: 100,
+          connection_timeout: 60,
+          connection_read_timeout: 60,
+          http_wire_trace: false,
+          logger: nil,
+          ssl_verify_peer: true,
+          ssl_ca_bundle: nil,
+          ssl_ca_directory: nil,
+          ssl_ca_store: nil,
+          enable_alpn: false
+        }
+
+        # chunk read size at socket
+        CHUNKSIZE = 1024
+
+        SOCKET_FAMILY = ::Socket::AF_INET
+
+        def initialize(options = {})
+          OPTIONS.each_pair do |opt_name, default_value|
+            value = options[opt_name].nil? ? default_value : options[opt_name]
+            instance_variable_set("@#{opt_name}", value)
+          end
+          @h2_client = HTTP2::Client.new(
+            settings_max_concurrent_streams: max_concurrent_streams
+          )
+          @logger = options[:logger] || Logger.new($stdout) if @http_wire_trace
+          @chunk_size = options[:read_chunk_size] || CHUNKSIZE
+          @errors = []
+          @status = :ready
+          @mutex = Mutex.new # connection can be shared across requests
+        end
+
+        OPTIONS.keys.each do |attr_name|
+          attr_reader(attr_name)
+        end
+
+        alias ssl_verify_peer? ssl_verify_peer
+
+        attr_reader :errors
+
+        attr_accessor :input_signal_thread
+
+        def new_stream
+          begin
+            @h2_client.new_stream
+          rescue => error
+            raise Http2StreamInitializeError.new(error)
+          end
+        end
+
+        def connect(endpoint)
+          @mutex.synchronize {
+            if @status == :ready
+              tcp, addr = _tcp_socket(endpoint) 
+              debug_output("opening connection to #{endpoint.host}:#{endpoint.port} ...")
+              _nonblocking_connect(tcp, addr)
+              debug_output("opened")
+
+              @socket = OpenSSL::SSL::SSLSocket.new(tcp, _tls_context)
+              @socket.sync_close = true
+              @socket.hostname = endpoint.host
+
+              debug_output("starting TLS for #{endpoint.host}:#{endpoint.port} ...")
+              @socket.connect
+              debug_output("TLS established")
+              _register_h2_callbacks
+              @status = :active
+            elsif @status == :closed
+              msg = "Async Client HTTP2 Connection is closed, you may"\
+                " use #new_connection to create a new HTTP2 Connection for this client"
+              raise Http2ConnectionClosedError.new(msg)
+            end
+          }
+        end
+
+        def start(stream)
+          @mutex.synchronize {
+            return if @socket_thread
+            @socket_thread = Thread.new do
+              while !@socket.closed?
+                begin
+                  data = @socket.read_nonblock(@chunk_size)
+                  @h2_client << data
+                rescue IO::WaitReadable
+                  begin
+                    unless IO.select([@socket], nil, nil, connection_read_timeout)
+                      self.debug_output("socket connection read time out")
+                      self.close!
+                    else
+                      # available, retry to start reading
+                      retry
+                    end
+                  rescue
+                    # error can happen when closing the socket
+                    # while it's waiting for read
+                    self.close!
+                  end
+                rescue EOFError
+                  self.close!
+                rescue => error
+                  self.debug_output(error.inspect)
+                  @errors << error
+                  self.close!
+                end
+              end
+            end
+            @socket_thread.abort_on_exception = true
+          }
+        end
+
+        def close!
+          @mutex.synchronize {
+            self.debug_output("closing connection ...")
+            if @socket
+              @socket.close
+              @socket = nil
+            end
+            if @socket_thread
+              Thread.kill(@socket_thread)
+              @socket_thread = nil
+            end
+            @status = :closed
+          }
+        end
+
+        def closed?
+          @status == :closed
+        end
+
+        def debug_output(msg, type = nil)
+          prefix = case type
+            when :send then "-> "
+            when :receive then "<- "
+            else
+              ""
+            end
+          return unless @logger
+          _debug_entry(prefix + msg)
+        end
+
+        private
+
+        def _debug_entry(str)
+          @logger << str
+          @logger << "\n"
+        end
+
+        def _register_h2_callbacks
+          @h2_client.on(:frame) do |bytes|
+            if @socket.nil?
+              msg = "Connection is closed due to errors, "\
+                "you can find errors at async_client.connection.errors"
+              raise Http2ConnectionClosedError.new(msg)
+            else
+              @socket.print(bytes)
+              @socket.flush
+            end
+          end
+          @h2_client.on(:frame_sent) do |frame|
+            debug_output("frame: #{frame.inspect}", :send)
+          end
+          @h2_client.on(:frame_received) do |frame|
+            debug_output("frame: #{frame.inspect}", :receive)
+          end
+        end
+
+        def _tcp_socket(endpoint)
+          tcp = ::Socket.new(SOCKET_FAMILY, ::Socket::SOCK_STREAM, 0)
+          tcp.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+
+          address = ::Socket.getaddrinfo(endpoint.host, nil, SOCKET_FAMILY).first[3]
+          sockaddr = ::Socket.sockaddr_in(endpoint.port, address)
+
+          [tcp, sockaddr]
+        end
+
+        def _nonblocking_connect(tcp, addr)
+          begin
+            tcp.connect_nonblock(addr)
+          rescue IO::WaitWritable
+            unless IO.select(nil, [tcp], nil, connection_timeout)
+              tcp.close
+              raise
+            end
+            begin
+              tcp.connect_nonblock(addr)
+            rescue Errno::EISCONN
+              # tcp socket connected, continue
+            end
+          end
+        end
+
+        def _tls_context
+          ssl_ctx = OpenSSL::SSL::SSLContext.new(:TLSv1_2)
+          if ssl_verify_peer?
+            ssl_ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+            ssl_ctx.ca_file = ssl_ca_bundle ? ssl_ca_bundle : _default_ca_bundle
+            ssl_ctx.ca_path = ssl_ca_directory ? ssl_ca_directory : _default_ca_directory
+            ssl_ctx.cert_store = ssl_ca_store if ssl_ca_store
+          else
+            ssl_ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+          if enable_alpn
+            debug_output("enabling ALPN for TLS ...")
+            ssl_ctx.alpn_protocols = ['h2']
+          end
+          ssl_ctx
+        end
+
+        def _default_ca_bundle
+          File.exist?(OpenSSL::X509::DEFAULT_CERT_FILE) ?
+            OpenSSL::X509::DEFAULT_CERT_FILE : nil
+        end
+
+        def _default_ca_directory
+          Dir.exist?(OpenSSL::X509::DEFAULT_CERT_DIR) ?
+            OpenSSL::X509::DEFAULT_CERT_DIR : nil
+        end
+
+      end
+    end
+  end
+end
+

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/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/net_http/patches.rb

@@ -10,6 +10,12 @@ module Seahorse
 
         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
@@ -30,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