aws-sdk-core 2.11.502 → 3.94.0

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

@@ -0,0 +1,77 @@
+module Aws
+  # Create and provide access to components of Amazon Resource Names (ARN).
+  #
+  # You can create an ARN and access it's components like the following:
+  #
+  #   arn = Aws::ARN.new(
+  #     partition: 'aws',
+  #     service: 's3',
+  #     region: 'us-west-2',
+  #     account_id: '12345678910',
+  #     resource: 'foo/bar'
+  #   )
+  #   # => #<Aws::ARN ...>
+  #
+  #   arn.to_s
+  #   # => "arn:aws:s3:us-west-2:12345678910:foo/bar"
+  #
+  #   arn.partition
+  #   # => 'aws'
+  #   arn.service
+  #   # => 's3'
+  #   arn.resource
+  #   # => foo/bar
+  #
+  #   # Note: parser available for parsing resource details
+  #   @see Aws::ARNParser#parse_resource
+  #
+  # @see https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#genref-arns
+  class ARN
+
+    # @param [Hash] options
+    # @option options [String] :partition
+    # @option options [String] :service
+    # @option options [String] :region
+    # @option options [String] :account_id
+    # @option options [String] :resource
+    def initialize(options = {})
+      @partition = options[:partition]
+      @service = options[:service]
+      @region = options[:region]
+      @account_id = options[:account_id]
+      @resource = options[:resource]
+    end
+
+    # @return [String]
+    attr_reader :partition
+
+    # @return [String]
+    attr_reader :service
+
+    # @return [String]
+    attr_reader :region
+
+    # @return [String]
+    attr_reader :account_id
+
+    # @return [String]
+    attr_reader :resource
+
+    # Validates ARN contains non-empty required components.
+    # Region and account_id can be optional.
+    #
+    # @return [Boolean]
+    def valid?
+      !partition.nil? && !partition.empty? &&
+        !service.nil? && !service.empty? &&
+        !resource.nil? && !resource.empty?
+    end
+
+    # Return the ARN format in string
+    #
+    # @return [String]
+    def to_s
+      "arn:#{partition}:#{service}:#{region}:#{account_id}:#{resource}"
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Aws
+  module ARNParser
+    # Parse a string with an ARN format into an {Aws::ARN} object.
+    # `InvalidARNError` would be raised when encountering a parsing error or the
+    # ARN object contains invalid components (nil/empty).
+    #
+    # @param [String] arn_str
+    #
+    # @return [Aws::ARN]
+    # @see https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#genref-arns
+    def self.parse(arn_str)
+      parts = arn_str.nil? ? [] : arn_str.split(':', 6)
+      raise Aws::Errors::InvalidARNError if parts.size < 6
+
+      # part[0] is "arn"
+      arn = ARN.new(
+        partition: parts[1],
+        service: parts[2],
+        region: parts[3],
+        account_id: parts[4],
+        resource: parts[5]
+      )
+      raise Aws::Errors::InvalidARNError unless arn.valid?
+
+      arn
+    end
+
+    # Checks whether a String could be a ARN or not. An ARN starts with 'arn:'
+    # and has at least 6 segments separated by a colon (:).
+    #
+    # @param [String] str
+    #
+    # @return [Boolean]
+    def self.arn?(str)
+      !str.nil? && str.start_with?('arn:') && str.scan(/:/).length >= 5
+    end
+  end
+end

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

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