aws-sdk-core 3.46.2 → 3.47.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea0675c1b3dd6a1df7b3d1633f52557acd31fe44
-  data.tar.gz: b70038231fedd16ba86307a1ce71d962959dbc7b
+  metadata.gz: e240abd1c190c9f5b7b6dac9395342881be33c53
+  data.tar.gz: 6a08d6319fd1baef15af46a41edd756c8d23ed5a
 SHA512:
-  metadata.gz: d806391d8741594c74e188e96bf511da0c9210e47e86ca8c8d386c1146dac14fafeed7fca216aa21a3ebe6ff029250ec024fd68776cb503e5f186576b1d3ac04
-  data.tar.gz: c0a1a2a2c7f61c528cd68ed0fd0b29be6c5e13a0c054d76a5d072c76142afa4794ada5f0a3da71e09f0d4f92cbc37a7b8bc9faee35d37901438bba1165eac51a
+  metadata.gz: e8ed167ed3c41ae1e255235c7794abdb85cf60bc022c49c1dd30327d3ea1000a5a3c8f03e37dccd6a01778ae132ea365a4313e7f1e2e79e955b3e1c55f235a71
+  data.tar.gz: 421c2b9d17a58946a01a9181392af7da9e21158f9dc9b64d399ea13dfd299a1f74c5c16321098ed46f09241dd7a50019fbef89895e22f9ea9bca0b7764e11456

data/VERSION

@@ -1 +1 @@
-3.46.2
+3.47.0

data/lib/aws-sdk-core.rb

@@ -19,6 +19,7 @@ require_relative 'aws-sdk-core/process_credentials'
 # client modules
 
 require_relative 'aws-sdk-core/client_stubs'
+require_relative 'aws-sdk-core/async_client_stubs'
 require_relative 'aws-sdk-core/eager_loader'
 require_relative 'aws-sdk-core/errors'
 require_relative 'aws-sdk-core/pageable_response'

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

@@ -0,0 +1,80 @@
+module Aws
+  module AsyncClientStubs 
+
+    include Aws::ClientStubs
+
+    # @api private
+    def setup_stubbing
+      @stubs = {}
+      @stub_mutex = Mutex.new
+      if Hash === @config.stub_responses
+        @config.stub_responses.each do |operation_name, stubs|
+          apply_stubs(operation_name, Array === stubs ? stubs : [stubs])
+        end
+      end
+
+      # When a client is stubbed allow the user to access the requests made
+      @api_requests = []
+
+      # allow to access signaled events when client is stubbed
+      @send_events = []
+
+      requests = @api_requests
+      send_events = @send_events
+
+      self.handle do |context|
+        if input_stream = context[:input_event_stream_handler]
+          stub_stream = StubStream.new
+          stub_stream.send_events = send_events
+          input_stream.event_emitter.stream = stub_stream 
+          input_stream.event_emitter.validate_event = context.config.validate_params
+        end
+        requests << {
+          operation_name: context.operation_name,
+          params: context.params,
+          context: context
+        }
+        @handler.call(context)
+      end
+    end
+
+    def send_events
+      if config.stub_responses
+        @send_events
+      else
+        msg = 'This method is only implemented for stubbed clients, and is '
+        msg << 'available when you enable stubbing in the constructor with `stub_responses: true`'
+        raise NotImplementedError.new(msg)
+      end
+    end
+
+    class StubStream
+
+      def initialize
+        @state = :open
+      end
+
+      attr_accessor :send_events
+
+      attr_reader :state
+
+      def data(bytes, options = {})
+        if options[:end_stream]
+          @state = :closed
+        else
+          decoder = Aws::EventStream::Decoder.new
+          event = decoder.decode_chunk(bytes).first
+          @send_events << decoder.decode_chunk(event.payload.read).first
+        end
+      end
+
+      def closed?
+        @state == :closed
+      end
+
+      def close
+        @state = :closed
+      end
+    end
+  end
+end

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

@@ -1,3 +1,6 @@
 require_relative 'binary/decode_handler'
+require_relative 'binary/encode_handler'
 require_relative 'binary/event_stream_decoder'
+require_relative 'binary/event_stream_encoder'
+require_relative 'binary/event_builder'
 require_relative 'binary/event_parser'

data/lib/aws-sdk-core/binary/decode_handler.rb

@@ -23,11 +23,31 @@ module Aws
 
         context.http_response.on_headers(200) do
           protocol = context.config.api.metadata['protocol']
+          output_handler = context[:output_event_stream_handler] || context[:event_stream_handler]
           context.http_response.body = EventStreamDecoder.new(
             protocol,
             rules,
+            context.operation.output,
+            context.operation.errors,
             context.http_response.body,
-            context[:event_stream_handler])
+            output_handler)
+          if input_emitter = context[:input_event_emitter]
+            # events need to be send in order
+            # every event signature requries prior signature
+            thread = Thread.new do
+              # polling for buffered emit events until stream not active
+              while input_emitter.stream.state == :open
+                while callback = input_emitter.buffer.shift
+                  callback.call if input_emitter.stream.state == :open
+                end
+              end
+            end
+            thread.abort_on_exception = true
+            # attach thread to current stream context
+            # make sure when stream closes (#wait or #join! is called)
+            # input signal thread is also killed
+            context[:input_signal_thread] = thread
+          end
         end
 
         context.http_response.on_success(200) do

data/lib/aws-sdk-core/binary/encode_handler.rb

@@ -0,0 +1,32 @@
+module Aws
+  module Binary
+
+    # @api private
+    class EncodeHandler < Seahorse::Client::Handler
+
+      def call(context)
+        if eventstream_member = eventstream_input?(context)
+          input_es_handler = context[:input_event_stream_handler]
+          input_es_handler.event_emitter.encoder = EventStreamEncoder.new(
+            context.config.api.metadata['protocol'],
+            eventstream_member,
+            context.operation.input,
+            context.config.sigv4_signer
+          )
+          context[:input_event_emitter] = input_es_handler.event_emitter
+        end
+        @handler.call(context)
+      end
+
+      private
+
+      def eventstream_input?(ctx)
+        ctx.operation.input.shape.members.each do |_, ref|
+          return ref if ref.eventstream
+        end
+      end
+
+    end
+
+  end
+end

data/lib/aws-sdk-core/binary/event_builder.rb

@@ -0,0 +1,122 @@
+module Aws
+  module Binary
+    # @api private
+    class EventBuilder
+
+      include Seahorse::Model::Shapes
+
+      # @param [Class] parser_class
+      # @param [Seahorse::Model::ShapeRef] rules (of eventstream member)
+      def initialize(serializer_class, rules)
+        @serializer_class = serializer_class
+        @rules = rules
+      end
+
+      def apply(event_type, params)
+        event_ref = @rules.shape.member(event_type)
+        _event_stream_message(event_ref, params)
+      end
+
+      private
+
+      def _event_stream_message(event_ref, params)
+        es_headers = {}
+        payload = ""
+
+        es_headers[":message-type"] = Aws::EventStream::HeaderValue.new(
+          type: "string", value: "event")
+        es_headers[":event-type"] = Aws::EventStream::HeaderValue.new(
+          type: "string", value: event_ref.shape.name)
+
+        explicit_payload = false
+        implicit_payload_members = {}
+        event_ref.shape.members.each do |member_name, member_ref|
+          unless member_ref.eventheader
+            if member_ref.eventpayload
+              explicit_payload = true
+            else
+              implicit_payload_members[member_name] = member_ref
+            end
+          end
+        end
+
+        # implict payload
+        if !explicit_payload && !implicit_payload_members.empty?
+          if implicit_payload_members.size > 1
+            payload_shape = Shapes::StructureShape.new
+            implicit_payload_members.each do |m_name, m_ref|
+              payload_shape.add_member(m_name, m_ref)
+            end
+            payload_ref = Shapes::ShapeRef.new(shape: payload_shape)
+
+            payload = build_payload_members(payload_ref, params)
+          else
+            m_name, m_ref = implicit_payload_members.first
+            streaming, content_type = _content_type(m_ref.shape)
+
+            es_headers[":content-type"] = Aws::EventStream::HeaderValue.new(
+              type: "string", value: content_type)
+            payload = _build_payload(streaming, m_ref, params[m_name])
+          end
+        end
+        
+
+        event_ref.shape.members.each do |member_name, member_ref|
+          if member_ref.eventheader && params[member_name]
+            header_value = params[member_name]
+            es_headers[member_ref.shape.name] = Aws::EventStream::HeaderValue.new(
+              type: _header_value_type(member_ref.shape, header_value),
+              value: header_value
+            )
+          elsif member_ref.eventpayload && params[member_name]
+            # explicit payload 
+            streaming, content_type = _content_type(member_ref.shape)
+
+            es_headers[":content-type"] = Aws::EventStream::HeaderValue.new(
+              type: "string", value: content_type)
+            payload = _build_payload(streaming, member_ref, params[member_name])
+          end
+        end
+
+        Aws::EventStream::Message.new(
+          headers: es_headers,
+          payload: StringIO.new(payload)
+        )
+      end
+
+      def _content_type(shape)
+        case shape
+        when BlobShape then [true, "application/octet-stream"]
+        when StringShape then [true, "text/plain"]
+        when StructureShape then
+          if @serializer_class.name.include?('Xml')
+            [false, "text/xml"]
+          elsif @serializer_class.name.include?('Json')
+            [false, "application/json"]
+          end
+        else
+          raise Aws::Errors::EventStreamBuilderError.new(
+            "Unsupport eventpayload shape: #{shape.name}")
+        end
+      end
+        
+      def _header_value_type(shape, value)
+        case shape
+        when StringShape then "string"
+        when IntegerShape then "integer"
+        when TimestampShape then "timestamp"
+        when BlobShape then "bytes"
+        when BooleanShape then !!value ? "bool_true" : "bool_false"
+        else 
+          raise Aws::Errors::EventStreamBuilderError.new(
+            "Unsupported eventheader shape: #{shape.name}") 
+        end
+      end
+
+      def _build_payload(streaming, ref, value)
+        streaming ? value : @serializer_class.new(ref).serialize(value)
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-core/binary/event_parser.rb

@@ -6,10 +6,14 @@ module Aws
       include Seahorse::Model::Shapes
 
       # @param [Class] parser_class
-      # @param [Seahorse::Model::ShapeRef] rules
-      def initialize(parser_class, rules)
+      # @param [Seahorse::Model::ShapeRef] rules (of eventstream member)
+      # @param [Array] error_refs array of errors ShapeRef
+      # @param [Seahorse::Model::ShapeRef] output_ref
+      def initialize(parser_class, rules, error_refs, output_ref)
         @parser_class = parser_class
         @rules = rules
+        @error_refs = error_refs
+        @output_ref = output_ref
       end
 
       # Parse raw event message into event struct
@@ -31,9 +35,7 @@ module Aws
           when 'event'
             parse_event(raw_event)
           when 'exception'
-            # Pending
-            raise Aws::Errors::EventStreamParserError.new(
-              ':exception event parsing is not supported')
+            parse_exception(raw_event)
           else
             raise Aws::Errors::EventStreamParserError.new(
               'Unrecognized :message-type value for the event')
@@ -44,6 +46,15 @@ module Aws
         end
       end
 
+      def parse_exception(raw_event)
+        exception_type = raw_event.headers.delete(":exception-type").value
+        name, ref = @rules.shape.member_by_location_name(exception_type)
+        # exception lives in payload implictly
+        exception = parse_payload(raw_event.payload.read, ref)
+        exception.event_type = name
+        exception
+      end
+
       def parse_error_event(raw_event)
         error_code = raw_event.headers.delete(":error-code")
         error_message = raw_event.headers.delete(":error-message")
@@ -58,35 +69,54 @@ module Aws
         event_type = raw_event.headers.delete(":event-type").value
         # content_type = raw_event.headers.delete(":content-type").value
 
-        # Pending
         if event_type == 'initial-response'
-          raise Aws::Errors::EventStreamParserError.new(
-            'non eventstream member at response is not supported yet'
-          )
+          event = Struct.new(:event_type, :response).new
+          event.event_type = :initial_response
+          event.response = parse_payload(raw_event.payload.read, @output_ref)
+          return event
         end
 
         # locate event from eventstream
         name, ref = @rules.shape.member_by_location_name(event_type)
-        raise "Non event member found at eventstream" unless ref.event
+        unless ref.event
+          raise Aws::Errors::EventStreamParserError.new(
+            "Failed to locate event shape for the event")
+        end
 
         event = ref.shape.struct_class.new
+
+        explicit_payload = false
+        implicit_payload_members = {}
+        ref.shape.members.each do |member_name, member_ref|
+          unless member_ref.eventheader
+            if member_ref.eventpayload
+              explicit_payload = true
+            else
+              implicit_payload_members[member_name] = member_ref
+            end
+          end
+        end
+
+        # implicit payload
+        if !explicit_payload && !implicit_payload_members.empty?
+          event = parse_payload(raw_event.payload.read, ref)
+        end
         event.event_type = name
+
         # locate payload and headers in the event
         ref.shape.members.each do |member_name, member_ref|
-          if member_ref.eventpayload
-            eventpayload_streaming?(member_ref) ?
-             event.send("#{member_name}=", raw_event.payload) :
-             event.send("#{member_name}=", parse_payload(raw_event.payload.read, member_ref))
-          elsif member_ref.eventheader
+          if member_ref.eventheader
             # allow incomplete event members in response
             if raw_event.headers.key?(member_ref.location_name)
               event.send("#{member_name}=", raw_event.headers[member_ref.location_name].value)
             end
-          else
-            raise "Non eventpayload or eventheader member found at event"
+          elsif member_ref.eventpayload
+            # explicit payload
+            eventpayload_streaming?(member_ref) ?
+             event.send("#{member_name}=", raw_event.payload) :
+             event.send("#{member_name}=", parse_payload(raw_event.payload.read, member_ref))
           end
         end
-
         event
       end
 

data/lib/aws-sdk-core/binary/event_stream_decoder.rb

@@ -7,11 +7,13 @@ module Aws
 
       # @param [String] protocol
       # @param [ShapeRef] rules ShapeRef of the eventstream member
+      # @param [ShapeRef] output_ref ShapeRef of output shape
+      # @param [Array] error_refs array of ShapeRefs for errors
       # @param [EventStream|nil] event_stream_handler A Service EventStream object
       # that registered with callbacks for processing events when they arrive
-      def initialize(protocol, rules, io, event_stream_handler = nil)
+      def initialize(protocol, rules, output_ref, error_refs, io, event_stream_handler = nil)
         @decoder = Aws::EventStream::Decoder.new
-        @event_parser = EventParser.new(parser_class(protocol), rules)
+        @event_parser = EventParser.new(parser_class(protocol), rules, error_refs, output_ref)
         @stream_class = extract_stream_class(rules.shape.struct_class)
         @emitter = event_stream_handler.event_emitter
         @events = []
@@ -42,6 +44,7 @@ module Aws
         case protocol
         when 'rest-xml' then Aws::Xml::Parser
         when 'rest-json' then Aws::Json::Parser
+        when 'json' then Aws::Json::Parser
         else raise "unsupported protocol #{protocol} for event stream"
         end
       end

data/lib/aws-sdk-core/binary/event_stream_encoder.rb

@@ -0,0 +1,53 @@
+require 'aws-eventstream'
+
+module Aws
+  module Binary
+    # @api private
+    class EventStreamEncoder
+
+      # @param [String] protocol
+      # @param [ShapeRef] rules ShapeRef of the eventstream member
+      # @param [ShapeRef] input_ref ShapeRef of the input shape
+      # @param [Aws::Sigv4::Signer] signer
+      def initialize(protocol, rules, input_ref, signer)
+        @encoder = Aws::EventStream::Encoder.new
+        @event_builder = EventBuilder.new(serializer_class(protocol), rules)
+        @input_ref = input_ref
+        @rules = rules
+        @signer = signer
+        @prior_signature = nil
+      end
+
+      attr_reader :rules
+
+      attr_accessor :prior_signature
+
+      def encode(event_type, params)
+        if event_type == :end_stream
+          payload = ''
+        else
+          payload = @encoder.encode(@event_builder.apply(event_type, params))
+        end
+        headers, signature = @signer.sign_event(@prior_signature, payload, @encoder)
+        @prior_signature = signature
+        message = Aws::EventStream::Message.new(
+          headers: headers,
+          payload: StringIO.new(payload)
+        )
+        @encoder.encode(message)
+      end
+
+      private
+
+      def serializer_class(protocol)
+        case protocol
+        when 'rest-xml' then Xml::Builder
+        when 'rest-json' then Json::Builder
+        when 'json' then Json::Builder
+        else raise "unsupported protocol #{protocol} for event stream"
+        end
+      end
+
+    end
+  end
+end