aws-sdk-core 3.46.2 → 3.126.2

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'securerandom'
+require 'base64'
+
+module Aws
+
+  # An auto-refreshing credential provider that works by assuming
+  # a role via {Aws::STS::Client#assume_role_with_web_identity}.
+  #
+  #     role_credentials = Aws::AssumeRoleWebIdentityCredentials.new(
+  #       client: Aws::STS::Client.new(...),
+  #       role_arn: "linked::account::arn",
+  #       web_identity_token_file: "/path/to/token/file",
+  #       role_session_name: "session-name"
+  #       ...
+  #     )
+  #     For full list of parameters accepted
+  #     @see Aws::STS::Client#assume_role_with_web_identity 
+  #
+  #
+  # If you omit `:client` option, a new {STS::Client} object will be
+  # constructed.
+  class AssumeRoleWebIdentityCredentials
+
+    include CredentialProvider
+    include RefreshingCredentials
+
+    # @param [Hash] options
+    # @option options [required, String] :role_arn the IAM role
+    #   to be assumed
+    #
+    # @option options [required, String] :web_identity_token_file
+    #   absolute path to the file on disk containing OIDC token
+    #
+    # @option options [String] :role_session_name the IAM session
+    #   name used to distinguish session, when not provided, base64
+    #   encoded UUID is generated as the session name
+    #
+    # @option options [STS::Client] :client
+    #
+    # @option options [Callable] before_refresh Proc called before
+    #   credentials are refreshed. `before_refresh` is called
+    #   with an instance of this object when
+    #   AWS credentials are required and need to be refreshed.
+    def initialize(options = {})
+      client_opts = {}
+      @assume_role_web_identity_params = {}
+      @token_file = options.delete(:web_identity_token_file)
+      options.each_pair do |key, value|
+        if self.class.assume_role_web_identity_options.include?(key)
+          @assume_role_web_identity_params[key] = value
+        else
+          client_opts[key] = value
+        end
+      end
+
+      unless @assume_role_web_identity_params[:role_session_name]
+        # not provided, generate encoded UUID as session name
+        @assume_role_web_identity_params[:role_session_name] = _session_name
+      end
+      @client = client_opts[:client] || STS::Client.new(client_opts.merge(credentials: false))
+      super
+    end
+
+    # @return [STS::Client]
+    attr_reader :client
+
+    private
+
+    def refresh
+      # read from token file everytime it refreshes
+      @assume_role_web_identity_params[:web_identity_token] = _token_from_file(@token_file)
+
+      c = @client.assume_role_with_web_identity(
+        @assume_role_web_identity_params).credentials
+      @credentials = Credentials.new(
+        c.access_key_id,
+        c.secret_access_key,
+        c.session_token
+      )
+      @expiration = c.expiration
+    end
+
+    def _token_from_file(path)
+      unless path && File.exist?(path)
+        raise Aws::Errors::MissingWebIdentityTokenFile.new
+      end
+      File.read(path)
+    end
+
+    def _session_name
+      Base64.strict_encode64(SecureRandom.uuid)
+    end
+
+    class << self
+
+      # @api private
+      def assume_role_web_identity_options
+        @arwio ||= begin
+          input = STS::Client.api.operation(:assume_role_with_web_identity).input
+          Set.new(input.shape.member_names)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+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 '\
+              '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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws
   module Binary
 
@@ -23,11 +25,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,34 @@
+# frozen_string_literal: true
+
+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,124 @@
+# frozen_string_literal: true
+
+module Aws
+  module Binary
+    # @api private
+    class EventBuilder
+
+      include Seahorse::Model::Shapes
+
+      # @param [Class] serializer_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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws
   module Binary
     # @api private
@@ -6,10 +8,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 +37,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 +48,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 +71,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 && ref.event
+          return Struct.new(:event_type, :raw_event_type, :raw_event)
+                       .new(:unknown_event, event_type, raw_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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'aws-eventstream'
 
 module Aws
@@ -7,11 +9,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 +46,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,55 @@
+# frozen_string_literal: true
+
+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,8 @@
+# frozen_string_literal: true
+
 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/publisher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'thread'
 require 'socket'
 
@@ -6,8 +8,10 @@ module Aws
     # @api private
     class Publisher
       attr_reader :agent_port
+      attr_reader :agent_host
 
       def initialize(opts = {})
+        @agent_host = opts[:agent_host] || "127.0.0.1"
         @agent_port = opts[:agent_port]
         @mutex = Mutex.new
       end
@@ -18,6 +22,12 @@ module Aws
         end
       end
 
+      def agent_host=(value)
+        @mutex.synchronize do
+          @agent_host = value
+        end
+      end
+
       def publish(request_metrics)
         send_datagram(request_metrics.api_call.to_json)
         request_metrics.api_call_attempts.each do |attempt|
@@ -29,7 +39,7 @@ module Aws
         if @agent_port
           socket = UDPSocket.new
           begin
-            socket.connect("127.0.0.1", @agent_port)
+            socket.connect(@agent_host, @agent_port)
             socket.send(msg, 0)
           rescue Errno::ECONNREFUSED
             # Drop on the floor

data/lib/aws-sdk-core/client_side_monitoring/request_metrics.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws
   module ClientSideMonitoring
     # @api private