aws-sdk-core 3.20.2 → 3.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: efaec09c7ee51c9d33f4ed340797d37512360e73
-  data.tar.gz: 2a7a2853113d145e50f001011184841783863209
+  metadata.gz: e3a585a1201cb947b02277c975d145eaccd64a2d
+  data.tar.gz: 3291a88b44edce997e8fec94a138f9de101720f6
 SHA512:
-  metadata.gz: 8d425634611c8e298877452b0a0ee49d6765b7999e77c5a9c70f5fcd9d2e4d8667ea7bec7bb6566187dddef0720316f0c5b0ee6e18625c122e5acf30f6fee7fd
-  data.tar.gz: 007c6ed14f300708ff9d55e47b06e58f11642f6f35768338ee706bfacff5b7c7784fc150856ad163c5f1d4ddd757c2e376c33a9a3ca2e6bf8a8cf6fa832f4202
+  metadata.gz: 2e346bb0c9d68b0fd570ce16b18496399659d373b2f480b6f7bd80a4b6c2fd9d392b7d3ae0e4cabb1bf135c13d9c5c2450dbd81a7a2594af6fad4646a45a05ca
+  data.tar.gz: ff787ba1c2d818247b7d2ff4552a54b9b3b9573b7f4c19a5793bad2e5196a8c958e1ef1d5d62c4290bd2d6eb93a47339203baf90cb242c71334160c7678a642d

data/VERSION

@@ -1 +1 @@
-3.20.2
+3.21.0

data/lib/aws-sdk-core.rb

@@ -62,6 +62,10 @@ require_relative 'aws-sdk-core/rest'
 require_relative 'aws-sdk-core/xml'
 require_relative 'aws-sdk-core/json'
 
+# event stream
+require_relative 'aws-sdk-core/binary'
+require_relative 'aws-sdk-core/event_emitter'
+
 # aws-sdk-sts is vendored to support Aws::AssumeRoleCredentials
 
 require 'aws-sdk-sts'

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

@@ -0,0 +1,3 @@
+require_relative 'binary/decode_handler'
+require_relative 'binary/event_stream_decoder'
+require_relative 'binary/event_parser'

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

@@ -0,0 +1,46 @@
+module Aws
+  module Binary
+
+    # @api private
+    class DecodeHandler < Seahorse::Client::Handler
+
+      def call(context)
+        if eventstream_member = eventstream?(context)
+          attach_eventstream_listeners(context, eventstream_member)
+        end
+        @handler.call(context)
+      end
+
+      private
+
+      def eventstream?(ctx)
+        ctx.operation.output.shape.members.each do |_, ref|
+          return ref if ref.eventstream
+        end
+      end
+
+      def attach_eventstream_listeners(context, rules)
+
+        context.http_response.on_headers(200) do
+          protocol = context.config.api.metadata['protocol']
+          context.http_response.body = EventStreamDecoder.new(
+            protocol,
+            rules,
+            context.http_response.body,
+            context[:event_stream_handler])
+        end
+
+        context.http_response.on_success(200) do
+          context.http_response.body = context.http_response.body.events
+        end
+
+        context.http_response.on_error do
+          context.http_response.body = context.http_response.raw_stream
+        end
+
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,104 @@
+module Aws
+  module Binary
+    # @api private
+    class EventParser
+
+      include Seahorse::Model::Shapes
+
+      # @param [Class] parser_class
+      # @param [Seahorse::Model::ShapeRef] rules
+      def initialize(parser_class, rules)
+        @parser_class = parser_class
+        @rules = rules
+      end
+
+      # Parse raw event message into event struct
+      # based on its ShapeRef
+      #
+      # @return [Struct] Event Struct
+      def apply(raw_event)
+        parse(raw_event)
+      end
+
+      private
+
+      def parse(raw_event)
+        message_type = raw_event.headers.delete(":message-type")
+        if message_type
+          case message_type.value
+          when 'error'
+            parse_error_event(raw_event)
+          when 'event'
+            parse_event(raw_event)
+          when 'exception'
+            # Pending
+            raise Aws::Errors::EventStreamParserError.new(
+              ':exception event parsing is not supported')
+          else
+            raise Aws::Errors::EventStreamParserError.new(
+              'Unrecognized :message-type value for the event')
+          end
+        else
+          # no :message-type header, regular event by default
+          parse_event(raw_event)
+        end
+      end
+
+      def parse_error_event(raw_event)
+        error_code = raw_event.headers.delete(":error-code")
+        error_message = raw_event.headers.delete(":error-message")
+        Aws::Errors::EventError.new(
+          :error,
+          error_code ? error_code.value : error_code,
+          error_message ? error_message.value : error_message
+        )
+      end
+
+      def parse_event(raw_event)
+        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'
+          )
+        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
+
+        event = ref.shape.struct_class.new
+        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
+            # 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"
+          end
+        end
+
+        event
+      end
+
+      def eventpayload_streaming?(ref)
+        BlobShape === ref.shape || StringShape === ref.shape
+      end
+
+      def parse_payload(body, rules)
+        @parser_class.new(rules).parse(body) if body.size > 0
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,59 @@
+require 'aws-eventstream'
+
+module Aws
+  module Binary
+    # @api private
+    class EventStreamDecoder
+
+      # @param [String] protocol
+      # @param [ShapeRef] rules ShapeRef of the eventstream member
+      # @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)
+        @decoder = Aws::EventStream::Decoder.new
+        @event_parser = EventParser.new(parser_class(protocol), rules)
+        @stream_class = extract_stream_class(rules.shape.struct_class)
+        @emitter = event_stream_handler.event_emitter
+        @events = []
+      end
+
+      # @return [Array] events Array of arrived event objects
+      attr_reader :events
+
+      def write(chunk)
+        raw_event, eof = @decoder.decode_chunk(chunk)
+        emit_event(raw_event) if raw_event
+        while !eof
+          # exhaust message_buffer data
+          raw_event, eof = @decoder.decode_chunk
+          emit_event(raw_event) if raw_event
+        end
+      end
+
+      private
+
+      def emit_event(raw_event)
+        event = @event_parser.apply(raw_event)
+        @events << event
+        @emitter.signal(event.event_type, event) unless @emitter.nil?
+      end
+
+      def parser_class(protocol)
+        case protocol
+        when 'rest-xml' then Aws::Xml::Parser
+        when 'rest-json' then Aws::Json::Parser
+        else raise "unsupported protocol #{protocol} for event stream"
+        end
+      end
+
+      def extract_stream_class(type_class)
+        parts = type_class.to_s.split('::')
+        parts.inject(Kernel) do |const, part_name|
+          part_name == 'Types' ? const.const_get('EventStreams')
+            : const.const_get(part_name)
+        end
+      end
+    end
+
+  end
+end

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

@@ -34,6 +34,41 @@ module Aws
       end
     end
 
+    # Raised when EventStream Parser failed to parse
+    # a raw event message
+    class EventStreamParserError < RuntimeError; end
+
+    # Error event in an event stream which has event_type :error
+    # error code and error message can be retrieved when available.
+    #
+    # example usage:
+    #
+    #   client.stream_foo(name: 'bar') do |event|
+    #     stream.on_error_event do |event|
+    #       puts "Error #{event.error_code}: #{event.error_message}"
+    #       raise event
+    #     end
+    #   end
+    #
+    class EventError < RuntimeError
+
+      def initialize(event_type, code, message)
+        @event_type = event_type
+        @error_code = code
+        @error_message = message
+      end
+
+      # @return [Symbol]
+      attr_reader :event_type
+
+      # @return [String]
+      attr_reader :error_code
+
+      # @return [String]
+      attr_reader :error_message
+
+    end
+
     # Various plugins perform client-side checksums of responses.
     # This error indicates a checksum failed.
     class ChecksumError < RuntimeError; end

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

@@ -0,0 +1,18 @@
+class EventEmitter
+
+  def initialize
+    @listeners = {}
+  end
+
+  def on(type, callback)
+    (@listeners[type] ||= []) << callback
+  end
+
+  def signal(type, event)
+    return unless @listeners[type]
+    @listeners[type].each do |listener|
+      listener.call(event) if event.event_type == type
+    end
+  end
+
+end

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

@@ -38,28 +38,48 @@ module Aws
       # ensure the value is hash like
       return unless correct_type?(ref, values, errors, context)
 
-      shape = ref.shape
-
-      # ensure required members are present
-      if @validate_required
-        shape.required.each do |member_name|
-          if values[member_name].nil?
-            param = "#{context}[#{member_name.inspect}]"
-            errors << "missing required parameter #{param}"
+      if ref.eventstream
+        values.each do |value|
+          # each event is structure type
+          case value[:message_type]
+          when 'event'
+            val = value.dup
+            val.delete(:message_type)
+            structure(ref.shape.member(val[:event_type]), val, errors, context)
+          when 'error' # Error is unmodeled
+          when 'exception' # Pending
+            raise Aws::Errors::EventStreamParserError.new(
+              ':exception event validation is not supported')
+          end
+        end
+      else
+        shape = ref.shape
+
+        # ensure required members are present
+        if @validate_required
+          shape.required.each do |member_name|
+            if values[member_name].nil?
+              param = "#{context}[#{member_name.inspect}]"
+              errors << "missing required parameter #{param}"
+            end
           end
         end
-      end
 
-      # validate non-nil members
-      values.each_pair do |name, value|
-        unless value.nil?
-          if shape.member?(name)
-            member_ref = shape.member(name)
-            shape(member_ref, value, errors, context + "[#{name.inspect}]")
-          else
-            errors << "unexpected value at #{context}[#{name.inspect}]"
+        # validate non-nil members
+        values.each_pair do |name, value|
+          unless value.nil?
+            # :event_type is not modeled
+            # and also needed when construct body
+            next if name == :event_type
+            if shape.member?(name)
+              member_ref = shape.member(name)
+              shape(member_ref, value, errors, context + "[#{name.inspect}]")
+            else
+              errors << "unexpected value at #{context}[#{name.inspect}]"
+            end
           end
         end
+
       end
     end
 
@@ -130,6 +150,7 @@ module Aws
       case value
       when Hash then true
       when ref.shape.struct_class then true
+      when Enumerator then ref.eventstream && value.respond_to?(:event_types)
       else
         errors << expected_got(context, "a hash", value)
         false

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

@@ -0,0 +1,16 @@
+module Aws
+  module Plugins
+
+    class EventStreamConfiguration < Seahorse::Client::Plugin
+      
+      option(: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
+end

data/lib/aws-sdk-core/rest/response/body.rb

@@ -15,7 +15,9 @@ module Aws
         # @param [IO] body
         # @param [Hash, Struct] data
         def apply(body, data)
-          if streaming?
+          if event_stream?
+            data[@rules[:payload]] = parse_eventstream(body)
+          elsif streaming?
             data[@rules[:payload]] = body
           elsif @rules[:payload]
             data[@rules[:payload]] = parse(body.read, @rules[:payload_member])
@@ -26,6 +28,10 @@ module Aws
 
         private
 
+        def event_stream?
+          @rules[:payload] && @rules[:payload_member].eventstream
+        end
+
         def streaming?
           @rules[:payload] && (
             BlobShape === @rules[:payload_member].shape ||
@@ -37,6 +43,13 @@ module Aws
           @parser_class.new(rules).parse(body, target) if body.size > 0
         end
 
+        def parse_eventstream(body)
+          # body contains an array of parsed event when they arrive
+          @rules[:payload_member].shape.struct_class.new do |payload|
+            body.each { |event| payload << event }
+          end
+        end
+
       end
     end
   end

data/lib/aws-sdk-core/rest/response/parser.rb

@@ -29,7 +29,10 @@ module Aws
 
         def extract_body(rules, response)
           Body.new(parser_class(response), rules).
-            apply(response.context.http_response.body, response.data)
+            apply(
+              response.context.http_response.body,
+              response.data
+            )
         end
 
         def parser_class(response)

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

@@ -36,7 +36,10 @@ module Aws
 
       def stub_structure(ref, visited)
         ref.shape.members.inject(ref.shape.struct_class.new) do |struct, (mname, mref)|
-          struct[mname] = stub_ref(mref, visited)
+          # For eventstream shape, it returns an Enumerator
+          unless mref.eventstream
+            struct[mname] = stub_ref(mref, visited)
+          end
           struct
         end
       end

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

@@ -1,3 +1,5 @@
+require 'aws-eventstream'
+
 module Aws
   module Stubbing
     module Protocols
@@ -74,6 +76,77 @@ module Aws
           operation.http_method == "HEAD"
         end
 
+        def eventstream?(rules)
+          rules.eventstream
+        end
+
+        def encode_eventstream_response(rules, data, builder)
+          data.inject('') do |stream, event_data|
+            # construct message headers and payload
+            opts = {headers: {}}
+            case event_data.delete(:message_type)
+            when 'event'
+              encode_event(opts, rules, event_data, builder)
+            when 'error'
+              # errors are unmodeled
+              encode_error(opts, event_data)
+            when 'exception'
+              # Pending
+              raise 'Stubbing :exception event is not supported'
+            end
+            stream << Aws::EventStream::Encoder.new.encode(
+              Aws::EventStream::Message.new(opts))
+            stream
+          end
+        end
+
+        def encode_error(opts, event_data)
+          opts[:headers][':error-message'] = Aws::EventStream::HeaderValue.new(
+            value: event_data[:error_message],
+            type: 'string'
+          )
+          opts[:headers][':error-code'] = Aws::EventStream::HeaderValue.new(
+            value: event_data[:error_code],
+            type: 'string'
+          )
+          opts[:headers][':message-type'] = Aws::EventStream::HeaderValue.new(
+            value: 'error',
+            type: 'string'
+          )
+          opts
+        end
+
+        def encode_event(opts, rules, event_data, builder)
+          event_ref = rules.shape.member(event_data.delete(:event_type))
+          event_data.each do |k, v|
+            member_ref = event_ref.shape.member(k)
+            if member_ref.eventheader
+              opts[:headers][member_ref.location_name] = Aws::EventStream::HeaderValue.new(
+                value: v,
+                type: member_ref.eventheader_type
+              )
+            elsif member_ref.eventpayload
+              case member_ref.eventpayload_type
+              when 'string'
+                opts[:payload] = StringIO.new(v)
+              when 'blob'
+                opts[:payload] = v
+              when 'structure'
+                opts[:payload] = StringIO.new(builder.new(member_ref).serialize(v))
+              end
+            end
+          end
+          opts[:headers][':event-type'] = Aws::EventStream::HeaderValue.new(
+            value: event_ref.location_name,
+            type: 'string'
+          )
+          opts[:headers][':message-type'] = Aws::EventStream::HeaderValue.new(
+            value: 'event',
+            type: 'string'
+          )
+          opts
+        end
+
       end
     end
   end

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

@@ -4,7 +4,11 @@ module Aws
       class RestJson < Rest
 
         def body_for(_, _, rules, data)
-          Aws::Json::Builder.new(rules).serialize(data)
+          if eventstream?(rules)
+            encode_eventstream_response(rules, data, Aws::Json::Builder)
+          else
+            Aws::Json::Builder.new(rules).serialize(data)
+          end
         end
 
         def stub_error(error_code)

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

@@ -6,11 +6,15 @@ module Aws
         include Seahorse::Model::Shapes
 
         def body_for(api, operation, rules, data)
-          xml = []
-          rules.location_name = operation.name + 'Result'
-          rules['xmlNamespace'] = { 'uri' => api.metadata['xmlNamespace'] }
-          Xml::Builder.new(rules, target:xml).to_xml(data)
-          xml.join
+          if eventstream?(rules)
+            encode_eventstream_response(rules, data, Xml::Builder)
+          else
+            xml = []
+            rules.location_name = operation.name + 'Result'
+            rules['xmlNamespace'] = { 'uri' => api.metadata['xmlNamespace'] }
+            Xml::Builder.new(rules, target:xml).to_xml(data)
+            xml.join
+          end
         end
 
         def stub_error(error_code)

data/lib/aws-sdk-sts.rb

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

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

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

data/lib/seahorse/client/http/response.rb

@@ -10,6 +10,7 @@ module Seahorse
           @status_code = options[:status_code] || 0
           @headers = options[:headers] || Headers.new
           @body = options[:body] || StringIO.new
+          @raw_stream = options[:raw_stream] || StringIO.new
           @listeners = Hash.new { |h,k| h[k] = [] }
           @complete = false
           @done = nil
@@ -26,6 +27,12 @@ module Seahorse
         # @return [StandardError, nil]
         attr_reader :error
 
+        # Raw binary stream data used for eventstream only
+        # body is concatenated parsed event structs in StringIO
+        #
+        # @return [IO]
+        attr_accessor :raw_stream
+
         # @return [IO]
         def body
           @body
@@ -59,6 +66,9 @@ module Seahorse
         # @param [string] chunk
         def signal_data(chunk)
           unless chunk == ''
+            # record raw binary stream for eventstream
+            # in case error happens, body is used for emit/track events
+            @raw_stream.write(chunk)
             @body.write(chunk)
             emit(:data, chunk)
           end

data/lib/seahorse/model/shapes.rb

@@ -10,6 +10,12 @@ module Seahorse
           @metadata = {}
           @required = false
           @deprecated = false
+          @event = false
+          @eventstream = false
+          @eventpayload = false
+          @eventpayload_type = ''
+          @eventheader = false
+          @eventheader_type = ''
           options.each do |key, value|
             if key == :metadata
               value.each do |k,v|
@@ -33,6 +39,24 @@ module Seahorse
         # @return [Boolean]
         attr_accessor :deprecated
 
+        # @return [Boolean]
+        attr_accessor :event
+
+        # @return [Boolean]
+        attr_accessor :eventstream
+
+        # @return [Boolean]
+        attr_accessor :eventpayload
+
+        # @return [Boolean]
+        attr_accessor :eventheader
+
+        # @return [String]
+        attr_accessor :eventpayload_type
+
+        # @return [Boolean]
+        attr_accessor :eventheader_type
+
         # @return [String, nil]
         def location
           @location || (shape && shape[:location])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws-sdk-core
 version: !ruby/object:Gem::Version
-  version: 3.20.2
+  version: 3.21.0
 platform: ruby
 authors:
 - Amazon Web Services
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-26 00:00:00.000000000 Z
+date: 2018-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jmespath
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: aws-eventstream
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: Provides API clients for AWS. This gem is part of the official AWS SDK
   for Ruby.
 email: 
@@ -63,6 +77,10 @@ files:
 - ca-bundle.crt
 - lib/aws-sdk-core.rb
 - lib/aws-sdk-core/assume_role_credentials.rb
+- lib/aws-sdk-core/binary.rb
+- lib/aws-sdk-core/binary/decode_handler.rb
+- lib/aws-sdk-core/binary/event_parser.rb
+- lib/aws-sdk-core/binary/event_stream_decoder.rb
 - lib/aws-sdk-core/client_stubs.rb
 - lib/aws-sdk-core/credential_provider.rb
 - lib/aws-sdk-core/credential_provider_chain.rb
@@ -71,6 +89,7 @@ files:
 - lib/aws-sdk-core/eager_loader.rb
 - lib/aws-sdk-core/ecs_credentials.rb
 - lib/aws-sdk-core/errors.rb
+- lib/aws-sdk-core/event_emitter.rb
 - lib/aws-sdk-core/ini_parser.rb
 - lib/aws-sdk-core/instance_profile_credentials.rb
 - lib/aws-sdk-core/json.rb
@@ -93,6 +112,7 @@ files:
 - lib/aws-sdk-core/plugins/apig_credentials_configuration.rb
 - lib/aws-sdk-core/plugins/apig_user_agent.rb
 - lib/aws-sdk-core/plugins/credentials_configuration.rb
+- lib/aws-sdk-core/plugins/event_stream_configuration.rb
 - lib/aws-sdk-core/plugins/global_configuration.rb
 - lib/aws-sdk-core/plugins/helpful_socket_errors.rb
 - lib/aws-sdk-core/plugins/idempotency_token.rb