aws-sdk-core 2.11.366 → 3.64.0

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

@@ -0,0 +1,101 @@
+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
+
+    # @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
+    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,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

@@ -0,0 +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

@@ -0,0 +1,56 @@
+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']
+          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,
+            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
+          context.http_response.body = context.http_response.body.events
+        end
+
+        context.http_response.on_error do
+          # Potential enhancement to made
+          # since we don't want to track raw bytes in memory
+          context.http_response.body = StringIO.new
+        end
+
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,134 @@
+module Aws
+  module Binary
+    # @api private
+    class EventParser
+
+      include Seahorse::Model::Shapes
+
+      # @param [Class] parser_class
+      # @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
+      # 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'
+            parse_exception(raw_event)
+          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_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")
+        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
+
+        if event_type == 'initial-response'
+          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)
+        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.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
+          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
+
+      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