aws-sdk-core 3.46.2 → 3.47.0

data/lib/aws-sdk-core/client_stubs.rb

@@ -291,7 +291,7 @@ module Aws
     def data_to_http_resp(operation_name, data)
       api = config.api
       operation = api.operation(operation_name)
-      ParamValidator.validate!(operation.output, data)
+      ParamValidator.new(operation.output, input: false).validate!(data)
       protocol_helper.stub_data(api, operation, data)
     end
 

data/lib/aws-sdk-core/errors.rb

@@ -62,6 +62,10 @@ module Aws
     # a raw event message
     class EventStreamParserError < RuntimeError; end
 
+    # Raise when EventStream Builder failed to build
+    # an event message with parameters provided
+    class EventStreamBuilderError < RuntimeError; end
+
     # Error event in an event stream which has event_type :error
     # error code and error message can be retrieved when available.
     #

data/lib/aws-sdk-core/event_emitter.rb

@@ -3,8 +3,18 @@ module Aws
 
     def initialize
       @listeners = {}
+      @validate_event = true
+      @buffer = Queue.new
     end
 
+    attr_accessor :stream
+
+    attr_accessor :encoder
+
+    attr_accessor :validate_event
+
+    attr_reader :buffer
+
     def on(type, callback)
       (@listeners[type] ||= []) << callback
     end
@@ -16,5 +26,37 @@ module Aws
       end
     end
 
+    def emit(type, params)
+      @buffer << Proc.new do
+        if @validate_event && type != :end_stream
+          Aws::ParamValidator.validate!(
+            @encoder.rules.shape.member(type), params)
+        end
+        @stream.data(
+          @encoder.encode(type, params),
+          end_stream: type == :end_stream
+        )
+      end
+    end
+
+    private
+
+    class Queue
+
+      def initialize(procs = [])
+        @procs = procs
+        @mutex = Mutex.new
+      end
+
+      def <<(callback)
+        @mutex.synchronize { @procs << callback }
+      end
+
+      def shift
+        @mutex.synchronize { @procs.shift }
+      end
+
+    end
+
   end
 end

data/lib/aws-sdk-core/json/handler.rb

@@ -40,7 +40,25 @@ module Aws
           Json.load(context.http_response.body_contents)
         elsif rules = context.operation.output
           json = context.http_response.body_contents
-          Parser.new(rules).parse(json == '' ? '{}' : json)
+          if json.is_a?(Array)
+            # an array of emitted events
+            if json[0].respond_to?(:response)
+              # initial response exists
+              # it must be the first event arrived
+              resp_struct = json.shift.response
+            else
+              resp_struct = context.operation.output.shape.struct_class.new
+            end
+
+            rules.shape.members.each do |name, ref|
+              if ref.eventstream
+                resp_struct.send("#{name}=", json.to_enum)
+              end
+            end
+            resp_struct
+          else
+            Parser.new(rules).parse(json == '' ? '{}' : json)
+          end
         else
           EmptyStructure.new
         end

data/lib/aws-sdk-core/param_validator.rb

@@ -22,6 +22,7 @@ module Aws
         ShapeRef.new(shape: shape)
       end
       @validate_required = options[:validate_required] != false
+      @input = options[:input].nil? ? true : !!options[:input]
     end
 
     # @param [Hash] params
@@ -39,6 +40,7 @@ module Aws
       return unless correct_type?(ref, values, errors, context)
 
       if ref.eventstream
+        # input eventstream is provided from event signals
         values.each do |value|
           # each event is structure type
           case value[:message_type]
@@ -58,7 +60,8 @@ module Aws
         # ensure required members are present
         if @validate_required
           shape.required.each do |member_name|
-            if values[member_name].nil?
+            input_eventstream = ref.shape.member(member_name).eventstream && @input
+            if values[member_name].nil? && !input_eventstream
               param = "#{context}[#{member_name.inspect}]"
               errors << "missing required parameter #{param}"
             end
@@ -147,6 +150,11 @@ module Aws
     end
 
     def correct_type?(ref, value, errors, context)
+      if ref.eventstream && @input
+        errors << "instead of providing value directly for eventstreams at input,"\
+          " expected to use #signal events per stream"
+        return false
+      end
       case value
       when Hash then true
       when ref.shape.struct_class then true

data/lib/aws-sdk-core/plugins/event_stream_configuration.rb

@@ -10,6 +10,20 @@ module Aws
 When an EventStream or Proc object is provided, it will be used as callback for each chunk of event stream response received along the way.
       DOCS
 
+      option(:input_event_stream_handler,
+        default: nil,
+        doc_type: 'Proc',
+        docstring: <<-DOCS)
+When an EventStream or Proc object is provided, it can be used for sending events for the event stream.
+      DOCS
+
+      option(:output_event_stream_handler,
+        default: nil,
+        doc_type: 'Proc',
+        docstring: <<-DOCS)
+When an EventStream or Proc object is provided, it will be used as callback for each chunk of event stream response received along the way.
+      DOCS
+
     end
 
   end

data/lib/aws-sdk-core/plugins/invocation_id.rb

@@ -0,0 +1,33 @@
+require 'securerandom'
+
+module Aws
+  module Plugins
+
+    # @api private
+    class InvocationId < Seahorse::Client::Plugin
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          apply_invocation_id(context)
+          @handler.call(context)
+        end
+
+        private
+
+        def apply_invocation_id(context)
+          context.http_request.headers['amz-sdk-invocation-id'] = SecureRandom.uuid
+          if context[:input_event_emitter]
+            # only used for eventstreaming at input
+            context.http_request.headers['x-amz-content-sha256'] = 'STREAMING-AWS4-HMAC-SHA256-EVENTS'
+          end
+        end
+
+      end
+
+      handler(Handler, step: :initialize)
+
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/stub_responses.rb

@@ -45,15 +45,18 @@ requests are made, and retries are disabled.
         def call(context)
           stub = context.client.next_stub(context)
           resp = Seahorse::Client::Response.new(context: context)
-          apply_stub(stub, resp)
-          resp
+          async_mode = context.client.is_a? Seahorse::Client::AsyncBase
+          apply_stub(stub, resp, async_mode)
+
+          async_mode ? Seahorse::Client::AsyncResponse.new(
+            context: context, stream: context[:input_event_stream_handler].event_emitter.stream, sync_queue: Queue.new) : resp
         end
 
-        def apply_stub(stub, response)
+        def apply_stub(stub, response, async_mode = false)
           http_resp = response.context.http_response
           case
           when stub[:error] then signal_error(stub[:error], http_resp)
-          when stub[:http] then signal_http(stub[:http], http_resp)
+          when stub[:http] then signal_http(stub[:http], http_resp, async_mode)
           when stub[:data] then response.data = stub[:data]
           end
         end
@@ -67,9 +70,18 @@ requests are made, and retries are disabled.
         end
 
         # @param [Seahorse::Client::Http::Response] stub
-        # @param [Seahorse::Client::Http::Response] http_resp
-        def signal_http(stub, http_resp)
-          http_resp.signal_headers(stub.status_code, stub.headers.to_h)
+        # @param [Seahorse::Client::Http::Response | Seahorse::Client::Http::AsyncResponse] http_resp
+        # @param [Boolean] async_mode
+        def signal_http(stub, http_resp, async_mode = false)
+          if async_mode
+            h2_headers = stub.headers.to_h.inject([]) do |arr, (k, v)|
+              arr << [k, v]
+            end
+            h2_headers << [":status", stub.status_code]
+            http_resp.signal_headers(h2_headers)
+          else
+            http_resp.signal_headers(stub.status_code, stub.headers.to_h)
+          end
           while chunk = stub.body.read(1024 * 1024)
             http_resp.signal_data(chunk)
           end

data/lib/aws-sdk-core/stubbing/protocols/rest.rb

@@ -118,6 +118,25 @@ module Aws
 
         def encode_event(opts, rules, event_data, builder)
           event_ref = rules.shape.member(event_data.delete(:event_type))
+          explicit_payload = false
+          implicit_payload_members = {}
+          event_ref.shape.members.each do |name, ref|
+            if ref.eventpayload
+              explicit_payload = true
+            else
+              implicit_payload_members[name] = ref
+            end
+          end
+
+          if !explicit_payload && !implicit_payload_members.empty?
+            unless implicit_payload_members.size > 1
+              m_name, _ = implicit_payload_members.first
+              value = {}
+              value[m_name] = event_data[m_name]
+              opts[:payload] = StringIO.new(builder.new(event_ref).serialize(value))
+            end
+          end
+
           event_data.each do |k, v|
             member_ref = event_ref.shape.member(k)
             if member_ref.eventheader

data/lib/aws-sdk-core/stubbing/stub_data.rb

@@ -30,7 +30,7 @@ module Aws
       end
 
       def apply_data(data, stub)
-        ParamValidator.new(@rules, validate_required:false).validate!(data)
+        ParamValidator.new(@rules, validate_required: false, input: false).validate!(data)
         DataApplicator.new(@rules).apply_data(data, stub)
       end
     end

data/lib/aws-sdk-sts.rb

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

data/lib/aws-sdk-sts/client.rb

@@ -1535,7 +1535,7 @@ module Aws::STS
         params: params,
         config: config)
       context[:gem_name] = 'aws-sdk-core'
-      context[:gem_version] = '3.46.2'
+      context[:gem_version] = '3.47.0'
       Seahorse::Client::Request.new(handlers, context)
     end
 

data/lib/seahorse.rb

@@ -15,12 +15,14 @@ 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
 
@@ -32,12 +34,18 @@ require_relative 'seahorse/client/logging/formatter'
 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'
 
@@ -49,3 +57,4 @@ 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,73 @@
+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)
+          }
+          _kill_input_thread
+          @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
+          _kill_input_thread
+          @response
+        end
+      end
+
+      private
+
+      def _kill_input_thread
+        if thread = context[:input_signal_thread]
+          Thread.kill(thread)
+        end
+        nil
+      end
+
+    end
+  end
+end