aws-sdk-core 3.100.0 → 3.191.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'seahorse/client/h2/handler'
 
 module Seahorse
@@ -26,11 +28,14 @@ Defaults to `true`, raises errors if exist when #wait or #join! is called upon a
         DOCS
 
         # SSL Context
-        option(:ssl_ca_bundle, default: nil, doc_type: String, docstring: <<-DOCS)
+        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
@@ -49,9 +54,9 @@ 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.
+Set to `true` to enable ALPN in HTTP2 over TLS. Requires 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)

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

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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'seahorse/client/net_http/handler'
 
 module Seahorse
@@ -7,9 +9,13 @@ module Seahorse
 
         option(:http_proxy, default: nil, doc_type: String, docstring: '')
 
-        option(:http_open_timeout, default: 15, doc_type: Integer, 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: '')
+        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: '')
 
@@ -19,16 +25,46 @@ module Seahorse
 
         option(:ssl_verify_peer, default: true, doc_type: 'Boolean', docstring: '')
 
-        option(:ssl_ca_bundle, default: nil, doc_type: String, 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,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seahorse
   module Client
     module Plugins

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'forwardable'
+
+module Seahorse
+  module Client
+    module Plugins
+
+      # @api private
+      class ReadCallbackIO
+        extend Forwardable
+        def_delegators :@io, :size
+
+        def initialize(io, on_read = nil)
+          @io = io
+          @on_read = on_read if on_read.is_a? Proc
+          @bytes_read = 0
+
+          # Some IO objects support readpartial - IO.copy_stream used by the
+          # request will call readpartial if available, so define a wrapper
+          # for it if the underlying IO supports it.
+          if @io.respond_to?(:readpartial)
+            def self.readpartial(*args)
+              @io.readpartial(*args).tap do |chunk|
+                handle_chunk(chunk)
+              end
+            end
+          end
+        end
+
+        attr_reader :io
+
+        def read(*args)
+          @io.read(*args).tap do |chunk|
+            handle_chunk(chunk)
+          end
+        end
+
+        private
+
+        def handle_chunk(chunk)
+          @bytes_read += chunk.bytesize if chunk && chunk.respond_to?(:bytesize)
+          total_size = @io.respond_to?(:size) ? @io.size : nil
+          @on_read.call(chunk, @bytes_read, total_size) if @on_read
+        end
+      end
+
+      # @api private
+      class RequestCallback < Plugin
+
+        option(
+          :on_chunk_sent,
+           default: nil,
+           doc_type: 'Proc',
+           docstring: <<-DOCS)
+When a Proc object is provided, it will be used as callback when each chunk 
+of the request body is sent. It provides three arguments: the chunk,
+the number of bytes read from the body, and the total number of 
+bytes in the body.
+          DOCS
+
+        option(:on_chunk_received,
+          default: nil,
+          doc_type: 'Proc',
+          docstring: <<-DOCS)
+When a Proc object is provided, it will be used as callback when each chunk 
+of the response body is received. It provides three arguments: the chunk,
+the number of bytes received, and the total number of 
+bytes in the response (or nil if the server did not send a `content-length`).
+        DOCS
+
+        # @api private
+        class OptionHandler < Client::Handler
+          def call(context)
+            if context.params.is_a?(Hash) && context.params[:on_chunk_sent]
+              on_chunk_sent = context.params.delete(:on_chunk_sent)
+            end
+            on_chunk_sent = context.config.on_chunk_sent if on_chunk_sent.nil?
+            context[:on_chunk_sent] = on_chunk_sent if on_chunk_sent
+
+            if context.params.is_a?(Hash) && context.params[:on_chunk_received]
+              on_chunk_received = context.params.delete(:on_chunk_received)
+            end
+            on_chunk_received = context.config.on_chunk_received if on_chunk_received.nil?
+
+            add_response_events(on_chunk_received, context) if on_chunk_received
+
+            @handler.call(context)
+          end
+
+          def add_response_events(on_chunk_received, context)
+            shared_data = {bytes_received: 0}
+
+            context.http_response.on_headers do |_status, headers|
+              shared_data[:content_length] = headers['content-length']&.to_i
+            end
+
+            context.http_response.on_data do |chunk|
+              shared_data[:bytes_received] += chunk.bytesize if chunk && chunk.respond_to?(:bytesize)
+              on_chunk_received.call(chunk, shared_data[:bytes_received], shared_data[:content_length])
+            end
+          end
+        end
+
+        # @api private
+        class ReadCallbackHandler < Client::Handler
+          def call(context)
+            if (callback = context[:on_chunk_sent])
+              context.http_request.body = ReadCallbackIO.new(
+                context.http_request.body,
+                callback
+              )
+              @handler.call(context).tap do
+                unwrap_callback_body(context)
+              end
+            else
+              @handler.call(context)
+            end
+          end
+
+          def unwrap_callback_body(context)
+            body = context.http_request.body
+            if body.is_a? ReadCallbackIO
+              context.http_request.body = body.io
+            end
+          end
+        end
+
+        # OptionHandler is needed to remove :on_chunk_sent
+        # from the params before build
+        handler(OptionHandler, step: :initialize)
+
+        # ReadCallbackHandlerneeds to go late in the call stack
+        # other plugins including Sigv4 and content_md5 read the request body
+        # and rewind it
+        handler(ReadCallbackHandler, step: :sign, priority: 0)
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'pathname'
 
 module Seahorse
@@ -15,10 +17,9 @@ module Seahorse
 
           def call(context)
             if context.params.is_a?(Hash) && context.params[:response_target]
-              target = context.params.delete(:response_target)
-            else
-              target = context[:response_target]
+              context[:response_target] = context.params.delete(:response_target)
             end
+            target = context[:response_target]
             add_event_listeners(context, target) if target
             @handler.call(context)
           end
@@ -26,20 +27,19 @@ module Seahorse
           private
 
           def add_event_listeners(context, target)
-            handler = self
             context.http_response.on_headers(200..299) do
               # In a fresh response body will be a StringIO
               # However, when a request is retried we may have
               # an existing ManagedFile or BlockIO and those
               # should be reused.
               if context.http_response.body.is_a? StringIO
-                context.http_response.body = handler.send(:io, target)
+                context.http_response.body = io(target, context.http_response.headers)
               end
             end
 
             context.http_response.on_success(200..299) do
               body = context.http_response.body
-              if ManagedFile === body && body.open?
+              if body.is_a?(ManagedFile) && body.open?
                 body.close
               end
             end
@@ -61,9 +61,9 @@ module Seahorse
             end
           end
 
-          def io(target)
+          def io(target, headers)
             case target
-            when Proc then BlockIO.new(&target)
+            when Proc then BlockIO.new(headers, &target)
             when String, Pathname then ManagedFile.new(target, 'w+b')
             else target
             end

data/lib/seahorse/client/request.rb

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

data/lib/seahorse/client/request_context.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'stringio'
 
 module Seahorse

data/lib/seahorse/client/response.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'delegate'
 
 module Seahorse
@@ -28,6 +30,12 @@ module Seahorse
       # @return [StandardError, nil]
       attr_accessor :error
 
+      # @return [String, nil] returns the algorithm used to validate
+      #   the response checksum.  Returns nil if no verification was done.
+      def checksum_validated
+        context[:http_checksum][:validated] if context[:http_checksum]
+      end
+
       # @overload on(status_code, &block)
       #   @param [Integer] status_code The block will be
       #     triggered only for responses with the given status code.

data/lib/seahorse/model/api.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seahorse
   module Model
     class Api

data/lib/seahorse/model/authorizer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seahorse
   module Model
     class Authorizer

data/lib/seahorse/model/operation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seahorse
   module Model
     class Operation
@@ -23,6 +25,12 @@ module Seahorse
       # @return [Boolean]
       attr_accessor :http_checksum_required
 
+      # @return [Hash]
+      attr_accessor :http_checksum
+
+      # @return [Hash]
+      attr_accessor :request_compression
+
       # @return [Boolean]
       attr_accessor :deprecated
 

data/lib/seahorse/model/shapes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 
 module Seahorse
@@ -59,6 +61,9 @@ module Seahorse
         # @return [Boolean]
         attr_accessor :eventheader_type
 
+        # @return [Boolean]
+        attr_accessor :document
+
         # @return [String, nil]
         def location
           @location || (shape && shape[:location])
@@ -112,6 +117,9 @@ module Seahorse
         # @return [String, nil]
         attr_accessor :documentation
 
+        # @return [Boolean]
+        attr_accessor :union
+
         # Gets metadata for the given `key`.
         def [](key)
           @metadata[key.to_s]
@@ -262,8 +270,27 @@ module Seahorse
 
       end
 
+      class UnionShape < StructureShape
+        def initialize(options = {})
+          @member_subclasses = {}
+          super options.merge(union: true)
+        end
+
+        # @api private
+        def member_subclass(member)
+          @member_subclasses[member]
+        end
+
+        # @api private
+        def add_member_subclass(member, subclass)
+          @member_subclasses[member] = subclass
+        end
+      end
+
       class TimestampShape < Shape; end
 
+      class DocumentShape < Shape; end
+
     end
   end
 end

data/lib/seahorse/util.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 require 'cgi'
 
 module Seahorse
   # @api private
   module Util
     class << self
-
       def uri_escape(string)
         CGI.escape(string.to_s.encode('UTF-8')).gsub('+', '%20').gsub('%7E', '~')
       end
@@ -13,6 +14,16 @@ module Seahorse
         path.gsub(/[^\/]+/) { |part| uri_escape(part) }
       end
 
+      def escape_header_list_string(s)
+        s.include?('"') || s.include?(',') ? "\"#{s.gsub('"', '\"')}\"" : s
+      end
+
+      # Checks for a valid host label
+      # @see https://tools.ietf.org/html/rfc3986#section-3.2.2
+      # @see https://tools.ietf.org/html/rfc1123#page-13
+      def host_label?(str)
+        str =~ /^(?!-)[a-zA-Z0-9-]{1,63}(?<!-)$/
+      end
     end
   end
 end

data/lib/seahorse/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seahorse
   VERSION = '0.1.0'
 end

data/lib/seahorse.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'seahorse/util'
 
 # client
@@ -48,6 +50,7 @@ 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'
+require_relative 'seahorse/client/plugins/request_callback'
 
 # model
 

data/sig/aws-sdk-core/client_stubs.rbs

@@ -0,0 +1,10 @@
+module Aws
+  module ClientStubs
+    def stub_responses: (Symbol operation_name, *untyped stubs) -> void
+
+    def api_requests: (?exclude_presign: bool) -> Array[{ operation_name: Symbol, params: untyped, context: untyped }]
+                    | (?Hash[:exclude_presign, bool] options) -> Array[{ operation_name: Symbol, params: untyped, context: untyped }]
+
+    def stub_data: (Symbol operation_name, ?untyped data) -> untyped
+  end
+end

data/sig/aws-sdk-core/errors.rbs

@@ -0,0 +1,22 @@
+module Aws
+  module Errors
+    class NonSupportedRubyVersionError < RuntimeError
+    end
+
+    # The base class for all errors returned by an Amazon Web Service.
+    # All ~400 level client errors and ~500 level server errors are raised
+    # as service errors.  This indicates it was an error returned from the
+    # service and not one generated by the client.
+    class ServiceError < RuntimeError
+      def initialize: (untyped context, String? message, ?untyped data) -> void
+
+      attr_reader code: String
+
+      attr_reader context: untyped
+
+      attr_reader data: untyped
+
+      attr_accessor self.code: String?
+    end
+  end
+end

data/sig/aws-sdk-core/resources/collection.rbs

@@ -0,0 +1,21 @@
+module Aws
+  module Resources
+    class Collection[T]
+      include Enumerable[T]
+
+      def initialize: (Enumerable[Enumerable[T]] batches, ?size: Integer, ?limit: Integer) -> void
+
+      def each: () -> Enumerator[T, untyped]
+              | () { (T) -> untyped } -> Enumerator[T, untyped]
+
+      def size: () -> Integer?
+
+      alias length size
+
+      def first: () -> T?
+               | (Integer) -> self
+
+      def limit: (Integer) -> self
+    end
+  end
+end

data/sig/aws-sdk-core/structure.rbs

@@ -0,0 +1,4 @@
+module Aws
+  class EmptyStructure
+  end
+end

data/sig/aws-sdk-core/waiters/errors.rbs

@@ -0,0 +1,20 @@
+module Aws
+  module Waiters
+    module Errors
+      class WaiterFailed < StandardError
+      end
+
+      class FailureStateError < WaiterFailed
+      end
+
+      class TooManyAttemptsError < WaiterFailed
+      end
+
+      class UnexpectedError < WaiterFailed
+      end
+
+      class NoSuchWaiterError < ArgumentError
+      end
+    end
+  end
+end

data/sig/aws-sdk-core.rbs

@@ -0,0 +1,7 @@
+module Aws
+  attr_reader self.config: Hash[Symbol, untyped]
+
+  def self.config=: (Hash[Symbol, untyped] config) -> Hash[Symbol, untyped]
+
+  def self.use_bundled_cert!: () -> String
+end

data/sig/seahorse/client/base.rbs

@@ -0,0 +1,25 @@
+module Seahorse
+  module Client
+    class Base
+      include HandlerBuilder
+
+      def self.new: (?untyped options) -> instance
+      def self.add_plugin: (untyped plugin) -> untyped
+      def self.remove_plugin: (untyped plugin) -> untyped
+      def self.clear_plugins: () -> untyped
+      def self.set_plugins: (Array[untyped] plugins) -> untyped
+      def self.plugins: () -> Array[untyped]
+      def self.api: () -> untyped
+      def self.set_api: (untyped api) -> untyped
+      def self.define: (?untyped options) -> untyped
+
+      attr_reader config: untyped
+
+      attr_reader handlers: untyped
+
+      def build_request: (_ToS operation_name, ?untyped params) -> untyped
+
+      def operation_names: () -> Array[Symbol]
+    end
+  end
+end

data/sig/seahorse/client/handler_builder.rbs

@@ -0,0 +1,16 @@
+module Seahorse
+  module Client
+    # This module provides the ability to add handlers to a class or
+    # module.  The including class or extending module must respond to
+    # `#handlers`, returning a {HandlerList}.
+    module HandlerBuilder
+      def handle_request: (*untyped) { (untyped context) -> void } -> untyped
+
+      def handle_response: (*untyped) { (untyped resp) -> void } -> untyped
+
+      def handle: (*untyped) ?{ (untyped context) -> void } -> untyped
+
+      alias handler handle
+    end
+  end
+end