aws-sdk-core 3.152.0 → 3.234.0

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

@@ -7,37 +7,78 @@ module Seahorse
     module Plugins
       class NetHttp < Plugin
 
-        option(:http_proxy, default: nil, doc_type: String, docstring: '')
-
-        option(:http_open_timeout, default: 15, doc_type: Integer, docstring: '') do |cfg|
+        option(:http_proxy, default: nil, doc_type: "URI::HTTP,String", docstring: <<-DOCS)
+A proxy to send requests through.  Formatted like 'http://proxy.com:123'.
+        DOCS
+
+        option(:http_open_timeout, default: 15, doc_type: Float, docstring: <<-DOCS) do |cfg|
+The default number of seconds to wait for response data.
+This value can safely be set per-request on the session.
+        DOCS
           resolve_http_open_timeout(cfg)
         end
 
-        option(:http_read_timeout, default: 60, doc_type: Integer, docstring: '') do |cfg|
+        option(:http_read_timeout, default: 60, doc_type: Float, docstring: <<-DOCS) do |cfg|
+The default number of seconds to wait for response data.
+This value can safely be set per-request on the session.
+        DOCS
           resolve_http_read_timeout(cfg)
         end
 
-        option(:http_idle_timeout, default: 5, doc_type: Integer, docstring: '')
-
-        option(:http_continue_timeout, default: 1, doc_type: Integer, docstring: '')
-
-        option(:http_wire_trace, default: false, doc_type: 'Boolean', docstring: '')
-
-        option(:ssl_verify_peer, default: true, doc_type: 'Boolean', docstring: '')
-
-        option(:ssl_ca_bundle, doc_type: String, docstring: '') do |cfg|
+        option(:http_idle_timeout, default: 5, doc_type: Float, docstring: <<-DOCS)
+The number of 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.
+        DOCS
+
+        option(:http_continue_timeout, default: 1, doc_type: Float, docstring: <<-DOCS)
+The number of seconds to wait for a 100-continue response before sending the 
+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.
+          DOCS
+
+        option(:http_wire_trace, default: false, doc_type: 'Boolean', docstring: <<-DOCS)
+When `true`,  HTTP debug output will be sent to the `:logger`.
+        DOCS
+
+        option(:ssl_verify_peer, default: true, doc_type: 'Boolean', docstring: <<-DOCS)
+When `true`, SSL peer certificates are verified when establishing a connection.
+        DOCS
+
+        option(:ssl_ca_bundle, 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_bundle` or 
+`:ssl_ca_directory` the 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: '')
+        option(:ssl_ca_directory, default: nil, doc_type: String, docstring: <<-DOCS)
+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 system 
+default will be used if available.
+        DOCS
 
-        option(:ssl_ca_store, default: nil, doc_type: String, docstring: '')
+        option(:ssl_ca_store, default: nil, doc_type: String, docstring: <<-DOCS)
+Sets the X509::Store to verify peer certificate.
+        DOCS
 
-        option(:ssl_timeout, default: nil, doc_type: Float, docstring: '') do |cfg|
+        option(:ssl_timeout, default: nil, doc_type: Float, docstring: 'Sets the SSL timeout in seconds') do |cfg|
           resolve_ssl_timeout(cfg)
         end
 
+        option(:ssl_cert, default: nil, doc_type: OpenSSL::X509::Certificate, docstring: <<-DOCS)
+Sets a client certificate when creating http connections.
+        DOCS
+
+
+        option(:ssl_key, default: nil, doc_type: OpenSSL::PKey, docstring: <<-DOCS)
+Sets a client key when creating http connections.
+        DOCS
+
         option(:logger) # for backwards compat
 
         handler(Client::NetHttp::Handler, step: :send)

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

@@ -60,6 +60,16 @@ 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)
@@ -68,8 +78,29 @@ bytes in the body.
             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
@@ -80,18 +111,18 @@ bytes in the body.
                 context.http_request.body,
                 callback
               )
-              add_event_listeners(context)
+              @handler.call(context).tap do
+                unwrap_callback_body(context)
+              end
+            else
+              @handler.call(context)
             end
-            @handler.call(context)
           end
 
-          def add_event_listeners(context)
-            # unwrap the request body as soon as we start receiving a response
-            context.http_response.on_headers do
-              body = context.http_request.body
-              if body.is_a? ReadCallbackIO
-                context.http_request.body = body.io
-              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

data/lib/seahorse/client/request_context.rb

@@ -5,15 +5,18 @@ require 'stringio'
 module Seahorse
   module Client
     class RequestContext
-
+      # @param [Hash] options
       # @option options [required,Symbol] :operation_name (nil)
       # @option options [required,Model::Operation] :operation (nil)
       # @option options [Model::Authorizer] :authorizer (nil)
+      # @option options [Client] :client (nil)
       # @option options [Hash] :params ({})
       # @option options [Configuration] :config (nil)
       # @option options [Http::Request] :http_request (Http::Request.new)
       # @option options [Http::Response] :http_response (Http::Response.new)
-      #   and #rewind.
+      # @option options [Integer] :retries (0)
+      # @option options [Aws::Telemetry::TracerBase] :tracer (Aws::Telemetry::NoOpTracer.new)
+      # @option options [Hash] :metadata ({})
       def initialize(options = {})
         @operation_name = options[:operation_name]
         @operation = options[:operation]
@@ -24,6 +27,7 @@ module Seahorse
         @http_request = options[:http_request] || Http::Request.new
         @http_response = options[:http_response] || Http::Response.new
         @retries = 0
+        @tracer = options[:tracer] || Aws::Telemetry::NoOpTracer.new
         @metadata = {}
       end
 
@@ -54,6 +58,9 @@ module Seahorse
       # @return [Integer]
       attr_accessor :retries
 
+      # @return [Tracer]
+      attr_accessor :tracer
+
       # @return [Hash]
       attr_reader :metadata
 

data/lib/seahorse/client/response.rb

@@ -30,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.
@@ -69,6 +75,8 @@ module Seahorse
       # Necessary to define as a subclass of Delegator
       # @api private
       def __getobj__
+        return yield if block_given? && !defined?(@data)
+
         @data
       end
 

data/lib/seahorse/model/operation.rb

@@ -28,6 +28,9 @@ module Seahorse
       # @return [Hash]
       attr_accessor :http_checksum
 
+      # @return [Hash]
+      attr_accessor :request_compression
+
       # @return [Boolean]
       attr_accessor :deprecated
 

data/lib/seahorse/model/shapes.rb

@@ -75,7 +75,7 @@ module Seahorse
 
         # @return [String, nil]
         def location_name
-          @location_name || (shape && shape[:location_name])
+          @location_name || (shape && shape['locationName'])
         end
 
         def location_name= location_name
@@ -86,7 +86,7 @@ module Seahorse
         def [](key)
           if @metadata.key?(key.to_s)
             @metadata[key.to_s]
-          else
+          elsif @shape
             @shape[key.to_s]
           end
         end

data/lib/seahorse/util.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'cgi'
+require "cgi/escape"
+require "cgi/util" if RUBY_VERSION < "3.5"
 
 module Seahorse
   # @api private
@@ -14,6 +15,10 @@ 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

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

@@ -0,0 +1,21 @@
+module Aws
+  module AsyncClientStubs
+    include ClientStubs
+
+    def send_events: () -> untyped
+
+    class StubsStream
+      def initialize: () -> void
+
+      attr_accessor send_events: untyped
+
+      attr_reader state: Symbol
+
+      def data: (untyped bytes, ?::Hash[untyped, untyped] options) -> untyped
+
+      def closed?: () -> bool
+
+      def close: () -> void
+    end
+  end
+end

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/telemetry/base.rbs

@@ -0,0 +1,46 @@
+module Aws
+  module Telemetry
+    class TelemetryProviderBase
+      def initialize: (?tracer_provider: TracerProviderBase, ?context_manager: ContextManagerBase) -> void
+      attr_reader tracer_provider: TracerProviderBase
+
+      attr_reader context_manager: ContextManagerBase
+    end
+
+    class TracerProviderBase
+      def tracer: (?String name) -> TracerBase
+    end
+
+    class TracerBase
+      def start_span: (String name, ?untyped with_parent, ?Hash[String, untyped] attributes, ?SpanKind kind) -> SpanBase
+
+      def in_span: (String name, ?Hash[String, untyped] attributes, ?SpanKind kind) -> SpanBase
+
+      def current_span: () -> SpanBase
+    end
+
+    class SpanBase
+      def set_attribute: (String key, untyped value) -> self
+      alias []= set_attribute
+
+      def add_attributes: (Hash[String, untyped] attributes) -> self
+
+      def add_event: (String name, ?Hash[String, untyped] attributes) -> self
+
+      def status=: (SpanStatus status) -> void
+
+      def finish: (?Time end_timestamp) -> self
+
+      def record_exception: (untyped exception, ?Hash[String, untyped] attributes) -> void
+    end
+
+    class ContextManagerBase
+      def current: () -> untyped
+
+      def attach: (untyped context) -> untyped
+
+      def detach: (untyped token) -> bool
+    end
+
+  end
+end

data/sig/aws-sdk-core/telemetry/otel.rbs

@@ -0,0 +1,22 @@
+module Aws
+  module Telemetry
+    class OTelProvider < TelemetryProviderBase
+      def initialize: () -> void
+    end
+
+    class OTelTracerProvider < TracerProviderBase
+      def initialize: () -> void
+    end
+
+    class OTelTracer < TracerBase
+      def initialize: (untyped tracer) -> void
+    end
+
+    class OTelSpan < SpanBase
+      def initialize: (untyped span) -> void
+    end
+
+    class OTelContextManager < ContextManagerBase
+    end
+  end
+end

data/sig/aws-sdk-core/telemetry/span_kind.rbs

@@ -0,0 +1,15 @@
+module Aws
+  module Telemetry
+    module SpanKind
+      INTERNAL: :internal
+
+      SERVER: :server
+
+      CLIENT: :client
+
+      CONSUMER: :consumer
+
+      PRODUCER: :producer
+    end
+  end
+end

data/sig/aws-sdk-core/telemetry/span_status.rbs

@@ -0,0 +1,24 @@
+module Aws
+  module Telemetry
+    class SpanStatus
+
+      def self.unset: (?::String description) -> SpanStatus
+
+      def self.ok: (?::String description) -> SpanStatus
+
+      def self.error: (?::String description) -> SpanStatus
+
+      def initialize: (Integer code, ?description: ::String) -> void
+
+      attr_reader code: Integer
+
+      attr_reader description: String
+
+      OK: 0
+
+      UNSET: 1
+
+      ERROR: 2
+    end
+  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/async_base.rbs

@@ -0,0 +1,18 @@
+module Seahorse
+  module Client
+    class AsyncBase < Base
+
+      def self.new: (?untyped options) -> instance
+
+      attr_reader connection: untyped
+
+      def operation_names: () -> Array[Symbol]
+
+      def close_connection: () -> Symbol
+
+      def new_connection: () -> untyped
+
+      def connection_errors: () -> Array[untyped]
+    end
+  end
+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

data/sig/seahorse/client/response.rbs

@@ -0,0 +1,61 @@
+module Seahorse
+  module Client
+    # RBS does not support Delegator.
+    # the behavior is mimicked `Seahorse::Client::Response` as much as possible.
+    interface _ResponseCommon
+      def context: () -> untyped
+
+      def checksum_validated: () -> ::String?
+
+      def on: (Integer) { (self) -> void } -> self
+            | (Range[Integer]) { (self) -> void } -> self
+
+      def on_success: () { (self) -> void } -> self
+
+      def successful?: () -> bool
+    end
+
+    # The interface for response success
+    # An interface representing response is provided for each operation,
+    # and _ResponseSuccess is embedded in this interface.
+    # @example client.rbs
+    #
+    #   interface _OperationResponseSuccess
+    #     include ::Seahorse::Client::_ResponseSuccess[Types::OperationOutput]
+    #     def foo: () -> ::String
+    #     def bar: () -> ::Integer
+    #   end
+    #   @client.operation: () -> _OperationResponseSuccess
+    interface _ResponseSuccess[DATA]
+      include _ResponseCommon
+
+      def data: () -> DATA
+
+      def data=: (DATA) -> DATA
+
+      def error: () -> nil
+
+      def error=: (nil) -> nil
+    end
+
+    # The interface for response error
+    # It is useful to use annotation on ruby code
+    # @example foo.rb
+    #
+    #   client = Client.new(raise_response_errors: false)
+    #   # @type var response: ::Seahorse::Client::_ResponseError
+    #   response = client.operation()
+    #   response.error.message
+    interface _ResponseError
+      include _ResponseCommon
+
+      def data: () -> nil
+
+      def data=: (nil) -> nil
+
+      def error: () -> StandardError
+
+      def error=: (StandardError) -> StandardError
+    end
+  end
+end