aws-sdk-core 2.3.23 → 3.89.1

data/lib/seahorse.rb

@@ -1,60 +1,60 @@
-module Seahorse
-
-  autoload :Util, 'seahorse/util'
-
-  module Client
-
-    autoload :Base, 'seahorse/client/base'
-    autoload :BlockIO, 'seahorse/client/block_io'
-    autoload :Configuration, 'seahorse/client/configuration'
-    autoload :Handler, 'seahorse/client/handler'
-    autoload :HandlerBuilder, 'seahorse/client/handler_builder'
-    autoload :HandlerList, 'seahorse/client/handler_list'
-    autoload :HandlerListEntry, 'seahorse/client/handler_list_entry'
-    autoload :ManagedFile, 'seahorse/client/managed_file'
-    autoload :NetworkingError, 'seahorse/client/networking_error'
-    autoload :Plugin, 'seahorse/client/plugin'
-    autoload :PluginList, 'seahorse/client/plugin_list'
-    autoload :Request, 'seahorse/client/request'
-    autoload :RequestContext, 'seahorse/client/request_context'
-    autoload :Response, 'seahorse/client/response'
-
-    module Http
-      autoload :Headers, 'seahorse/client/http/headers'
-      autoload :Request, 'seahorse/client/http/request'
-      autoload :Response, 'seahorse/client/http/response'
-    end
-
-    # The following module has been deprecated.
-    # @api private
-    module Logging
-      autoload :Handler, 'seahorse/client/logging/handler'
-      autoload :Formatter, 'seahorse/client/logging/formatter'
-    end
-
-    # @api private
-    module NetHttp
-      autoload :ConnectionPool, 'seahorse/client/net_http/connection_pool'
-      autoload :Handler, 'seahorse/client/net_http/handler'
-      autoload :Patches, 'seahorse/client/net_http/patches'
-    end
-
-    module Plugins
-      autoload :ContentLength, 'seahorse/client/plugins/content_length'
-      autoload :Endpoint, 'seahorse/client/plugins/endpoint'
-      autoload :Logging, 'seahorse/client/plugins/logging'
-      autoload :NetHttp, 'seahorse/client/plugins/net_http'
-      autoload :RaiseResponseErrors, 'seahorse/client/plugins/raise_response_errors'
-      autoload :ResponseTarget, 'seahorse/client/plugins/response_target'
-      autoload :RestfulBindings, 'seahorse/client/plugins/restful_bindings'
-    end
-
-  end
-
-  module Model
-    autoload :Api, 'seahorse/model/api'
-    autoload :Operation, 'seahorse/model/operation'
-    autoload :Shapes, 'seahorse/model/shapes'
-  end
-
-end
+require_relative 'seahorse/util'
+
+# client
+
+require_relative 'seahorse/client/block_io'
+require_relative 'seahorse/client/configuration'
+require_relative 'seahorse/client/handler'
+require_relative 'seahorse/client/handler_builder'
+require_relative 'seahorse/client/handler_list'
+require_relative 'seahorse/client/handler_list_entry'
+require_relative 'seahorse/client/managed_file'
+require_relative 'seahorse/client/networking_error'
+require_relative 'seahorse/client/plugin'
+require_relative 'seahorse/client/plugin_list'
+require_relative 'seahorse/client/request'
+require_relative 'seahorse/client/request_context'
+require_relative 'seahorse/client/response'
+require_relative 'seahorse/client/async_response'
+
+# client http
+
+require_relative 'seahorse/client/http/headers'
+require_relative 'seahorse/client/http/request'
+require_relative 'seahorse/client/http/response'
+require_relative 'seahorse/client/http/async_response'
+
+# client logging
+
+require_relative 'seahorse/client/logging/handler'
+require_relative 'seahorse/client/logging/formatter'
+
+# net http handler
+
+require_relative 'seahorse/client/net_http/connection_pool'
+require_relative 'seahorse/client/net_http/handler'
+
+# http2 handler
+
+require_relative 'seahorse/client/h2/connection'
+require_relative 'seahorse/client/h2/handler'
+
+# plugins
+
+require_relative 'seahorse/client/plugins/content_length'
+require_relative 'seahorse/client/plugins/endpoint'
+require_relative 'seahorse/client/plugins/logging'
+require_relative 'seahorse/client/plugins/net_http'
+require_relative 'seahorse/client/plugins/h2'
+require_relative 'seahorse/client/plugins/raise_response_errors'
+require_relative 'seahorse/client/plugins/response_target'
+
+# model
+
+require_relative 'seahorse/model/api'
+require_relative 'seahorse/model/operation'
+require_relative 'seahorse/model/authorizer'
+require_relative 'seahorse/model/shapes'
+
+require_relative 'seahorse/client/base'
+require_relative 'seahorse/client/async_base'

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

@@ -37,12 +37,6 @@ module Seahorse
           context_for(operation_name, params))
       end
 
-      # @param [String] name
-      # @return [Model::Operation]
-      def operation(name)
-        config.api.operation(name)
-      end
-
       # @api private
       def inspect
         "#<#{self.class.name}>"
@@ -52,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
@@ -89,7 +83,7 @@ module Seahorse
       def context_for(operation_name, params)
         RequestContext.new(
           operation_name: operation_name,
-          operation: operation(operation_name),
+          operation: config.api.operation(operation_name),
           client: self,
           params: params,
           config: config)
@@ -200,13 +194,15 @@ module Seahorse
         private
 
         def define_operation_methods
+          operations_module = Module.new
           @api.operation_names.each do |method_name|
-            define_method(method_name) do |*args, &block|
+            operations_module.send(:define_method, method_name) do |*args, &block|
               params = args[0] || {}
               options = args[1] || {}
               build_request(method_name, params).send_request(options, &block)
             end
           end
+          include(operations_module)
         end
 
         def build_plugins

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
@@ -197,7 +197,15 @@ module Seahorse
 
         def value_at(opt_name)
           value = @struct[opt_name]
-          value.is_a?(Defaults) ? resolve_defaults(opt_name, value) : value
+          if value.is_a?(Defaults)
+            # this config value is used by endpoint discovery
+            if opt_name == :endpoint && @struct.members.include?(:regional_endpoint)
+              @struct[:regional_endpoint] = true
+            end
+            resolve_defaults(opt_name, value)
+          else
+            value
+          end
         end
 
         def resolve_defaults(opt_name, defaults)

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,246 @@
+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
+          @socket = nil
+          @socket_thread = nil
+        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
+