aws-sdk-core 3.39.0 → 3.54.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 170c5072c882998ecf8c01d181d0c4d987101463
-  data.tar.gz: 71a98bb06e800d2bc77866e322330944a5e7417b
+  metadata.gz: 957c22992e76e2f143a965bd0ec0b377f9ad95ac
+  data.tar.gz: a2aae223f15b9a3d0df478ce8eabd8b8a48136b8
 SHA512:
-  metadata.gz: 2dc2097e0b07c58e0ca5154970be40eb0d02e1b5bc413b92974aa58683dedecf8adea762c58f29be16b7bca31704c1973e30c3991f554e79bf209992c06a5f11
-  data.tar.gz: 86492dd225866778c8045ede1bd9a6a5b0bc6fe4b49be1016469583f2a0f738c3e37186ec02f4c5ba521072b755e54928b1a7ef375a6e165cf7a645383be57de
+  metadata.gz: e35f246d2a7ffa5789ec88035a55e4b6def9e99322f9560b53d70c21acfd34b11a6f0e248d8063af33e4d59a4c1a50f905d84434c35c99873b6093a4da9c64bb
+  data.tar.gz: 6e1ad990cd9343153d41a8f92f8f4801eb703504e4ec23da383496ebc2d994f448f85a30b11ad5726946bbbc7f2512897e569c3efc9383af672b998c2b925377

data/VERSION

@@ -1 +1 @@
-3.39.0
+3.54.2

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/decode_handler.rb

@@ -23,11 +23,19 @@ 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]
+            # #emit will be blocked until 200 success
+            # see Aws::EventEmitter#emit
+            input_emitter.signal_queue << "ready"
+          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.location_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

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/client_side_monitoring/request_metrics.rb

@@ -4,6 +4,19 @@ module Aws
     class RequestMetrics
       attr_reader :api_call, :api_call_attempts
 
+      FIELD_MAX_LENGTH = {
+        "ClientId" => 255,
+        "UserAgent" => 256,
+        "SdkException" => 128,
+        "SdkExceptionMessage" => 512,
+        "AwsException" => 128,
+        "AwsExceptionMessage" => 512,
+        "FinalAwsException" => 128,
+        "FinalAwsExceptionMessage" => 512,
+        "FinalSdkException" => 128,
+        "FinalSdkExceptionMessage" => 512,
+      }
+
       def initialize(opts = {})
         @service = opts[:service]
         @api = opts[:operation]
@@ -42,7 +55,10 @@ module Aws
 
       class ApiCall
         attr_reader :service, :api, :client_id, :timestamp, :version,
-          :attempt_count, :latency, :region, :max_retries_exceeded
+          :attempt_count, :latency, :region, :max_retries_exceeded,
+          :final_http_status_code, :user_agent, :final_aws_exception,
+          :final_aws_exception_message, :final_sdk_exception,
+          :final_sdk_exception_message
 
         def initialize(service, api, client_id, version, timestamp, region)
           @service = service
@@ -56,15 +72,22 @@ module Aws
         def complete(opts = {})
           @latency = opts[:latency]
           @attempt_count = opts[:attempt_count]
+          @user_agent = opts[:user_agent]
           if opts[:final_error_retryable]
             @max_retries_exceeded = 1
           else
             @max_retries_exceeded = 0
           end
+          @final_http_status_code = opts[:final_http_status_code]
+          @final_aws_exception = opts[:final_aws_exception]
+          @final_aws_exception_message = opts[:final_aws_exception_message]
+          @final_sdk_exception = opts[:final_sdk_exception]
+          @final_sdk_exception_message = opts[:final_sdk_exception_message]
+          @region = opts[:region] if opts[:region] # in case region changes
         end
 
         def to_json(*a)
-          {
+          document = {
             "Type" => "ApiCall",
             "Service" => @service,
             "Api" => @api,
@@ -74,17 +97,36 @@ module Aws
             "AttemptCount" => @attempt_count,
             "Latency" => @latency,
             "Region" => @region,
-            "MaxRetriesExceeded" => @max_retries_exceeded
-          }.to_json
+            "MaxRetriesExceeded" => @max_retries_exceeded,
+            "UserAgent" => @user_agent,
+            "FinalHttpStatusCode" => @final_http_status_code,
+          }
+          document["FinalSdkException"] = @final_sdk_exception if @final_sdk_exception
+          document["FinalSdkExceptionMessage"] = @final_sdk_exception_message if @final_sdk_exception_message
+          document["FinalAwsException"] = @final_aws_exception if @final_aws_exception
+          document["FinalAwsExceptionMessage"] = @final_aws_exception_message if @final_aws_exception_message
+          document = _truncate(document)
+          document.to_json
+        end
+
+        private
+        def _truncate(document)
+          document.each do |key, value|
+            limit = FIELD_MAX_LENGTH[key]
+            if limit && value.to_s.length > limit
+              document[key] = value.to_s.slice(0...limit)
+            end
+          end
+          document
         end
       end
 
       class ApiCallAttempt
-        attr_reader :service, :api, :client_id, :version, :timestamp, :fqdn,
-          :region, :user_agent, :access_key, :session_token
-        attr_accessor :request_latency, :http_status_code, :aws_exception_msg,
-          :x_amz_request_id, :x_amz_id_2, :x_amzn_request_id, :sdk_exception,
-          :aws_exception, :sdk_exception_msg
+        attr_reader :service, :api, :client_id, :version, :timestamp,
+          :user_agent, :access_key, :session_token
+        attr_accessor :region, :fqdn, :request_latency, :http_status_code,
+          :aws_exception_msg, :x_amz_request_id, :x_amz_id_2,
+          :x_amzn_request_id, :sdk_exception, :aws_exception, :sdk_exception_msg
 
         def initialize(
           service,
@@ -134,8 +176,20 @@ module Aws
           json["AttemptLatency"] = @request_latency if @request_latency
           json["SdkException"] = @sdk_exception if @sdk_exception
           json["SdkExceptionMessage"] = @sdk_exception_msg if @sdk_exception_msg
+          json = _truncate(json)
           json.to_json
         end
+
+        private
+        def _truncate(document)
+          document.each do |key, value|
+            limit = FIELD_MAX_LENGTH[key]
+            if limit && value.to_s.length > limit
+              document[key] = value.to_s.slice(0...limit)
+            end
+          end
+          document
+        end
       end
 
     end

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/ecs_credentials.rb

@@ -78,14 +78,18 @@ module Aws
       # Retry loading credentials up to 3 times is the instance metadata
       # service is responding but is returning invalid JSON documents
       # in response to the GET profile credentials call.
-      retry_errors([JSON::ParserError, StandardError], max_retries: 3) do
-        c = JSON.parse(get_credentials.to_s)
-        @credentials = Credentials.new(
-          c['AccessKeyId'],
-          c['SecretAccessKey'],
-          c['Token']
-        )
-        @expiration = c['Expiration'] ? Time.iso8601(c['Expiration']) : nil
+      begin
+        retry_errors([JSON::ParserError, StandardError], max_retries: 3) do
+          c = JSON.parse(get_credentials.to_s)
+          @credentials = Credentials.new(
+            c['AccessKeyId'],
+            c['SecretAccessKey'],
+            c['Token']
+          )
+          @expiration = c['Expiration'] ? Time.iso8601(c['Expiration']) : nil
+        end
+      rescue JSON::ParserError
+        raise Aws::Errors::MetadataParserError.new
       end
     end