aws-sdk-core 2.11.363 → 3.64.0

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

@@ -0,0 +1,62 @@
+require 'aws-eventstream'
+
+module Aws
+  module Binary
+    # @api private
+    class EventStreamDecoder
+
+      # @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, output_ref, error_refs, io, event_stream_handler = nil)
+        @decoder = Aws::EventStream::Decoder.new
+        @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 = []
+      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
+        when '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/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/client_side_monitoring/publisher.rb

@@ -0,0 +1,49 @@
+require 'thread'
+require 'socket'
+
+module Aws
+  module ClientSideMonitoring
+    # @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
+
+      def agent_port=(value)
+        @mutex.synchronize do
+          @agent_port = value
+        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|
+          send_datagram(attempt.to_json)
+        end
+      end
+
+      def send_datagram(msg)
+        if @agent_port
+          socket = UDPSocket.new
+          begin
+            socket.connect(@agent_host, @agent_port)
+            socket.send(msg, 0)
+          rescue Errno::ECONNREFUSED
+            # Drop on the floor
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+module Aws
+  module ClientSideMonitoring
+    # @api private
+    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]
+        @client_id = opts[:client_id]
+        @timestamp = opts[:timestamp] # In epoch milliseconds
+        @region = opts[:region]
+        @version = 1
+        @api_call = ApiCall.new(@service, @api, @client_id, @version, @timestamp, @region)
+        @api_call_attempts = []
+      end
+
+      def build_call_attempt(opts = {})
+        timestamp = opts[:timestamp]
+        fqdn = opts[:fqdn]
+        region = opts[:region]
+        user_agent = opts[:user_agent]
+        access_key = opts[:access_key]
+        session_token = opts[:session_token]
+        ApiCallAttempt.new(
+          @service,
+          @api,
+          @client_id,
+          @version,
+          timestamp,
+          fqdn,
+          region,
+          user_agent,
+          access_key,
+          session_token
+        )
+      end
+
+      def add_call_attempt(attempt)
+        @api_call_attempts << attempt
+      end
+
+      class ApiCall
+        attr_reader :service, :api, :client_id, :timestamp, :version,
+          :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
+          @api = api
+          @client_id = client_id
+          @version = version
+          @timestamp = timestamp
+          @region = region
+        end
+
+        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,
+            "ClientId" => @client_id,
+            "Timestamp" => @timestamp,
+            "Version" => @version,
+            "AttemptCount" => @attempt_count,
+            "Latency" => @latency,
+            "Region" => @region,
+            "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,
+          :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,
+          api,
+          client_id,
+          version,
+          timestamp,
+          fqdn,
+          region,
+          user_agent,
+          access_key,
+          session_token
+        )
+          @service = service
+          @api = api
+          @client_id = client_id
+          @version = version
+          @timestamp = timestamp
+          @fqdn = fqdn
+          @region = region
+          @user_agent = user_agent
+          @access_key = access_key
+          @session_token = session_token
+        end
+
+        def to_json(*a)
+          json = {
+            "Type" => "ApiCallAttempt",
+            "Service" => @service,
+            "Api" => @api,
+            "ClientId" => @client_id,
+            "Timestamp" => @timestamp,
+            "Version" => @version,
+            "Fqdn" => @fqdn,
+            "Region" => @region,
+            "UserAgent" => @user_agent,
+            "AccessKey" => @access_key
+          }
+          # Optional Fields
+          json["SessionToken"] = @session_token if @session_token
+          json["HttpStatusCode"] = @http_status_code if @http_status_code
+          json["AwsException"] = @aws_exception if @aws_exception
+          json["AwsExceptionMessage"] = @aws_exception_msg if @aws_exception_msg
+          json["XAmznRequestId"] = @x_amzn_request_id if @x_amzn_request_id
+          json["XAmzRequestId"] = @x_amz_request_id if @x_amz_request_id
+          json["XAmzId2"] = @x_amz_id_2 if @x_amz_id_2
+          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
+  end
+end

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

@@ -6,6 +6,9 @@ module Aws
   # return when a client is using stubbed responses. Pass
   # `:stub_responses => true` to a client constructor to enable this
   # behavior.
+  #
+  # Also allows you to see the requests made by the client by reading the
+  # api_requests instance variable
   module ClientStubs
 
     # @api private
@@ -16,7 +19,6 @@ module Aws
         @config.stub_responses.each do |operation_name, stubs|
           apply_stubs(operation_name, Array === stubs ? stubs : [stubs])
         end
-        @config.stub_responses = true
       end
 
       # When a client is stubbed allow the user to access the requests made
@@ -220,7 +222,7 @@ module Aws
     # @return [Structure] Returns a stubbed response data structure. The
     #   actual class returned will depend on the given `operation_name`.
     def stub_data(operation_name, data = {})
-      Stubbing::StubData.new(operation(operation_name)).stub(data)
+      Stubbing::StubData.new(config.api.operation(operation_name)).stub(data)
     end
 
     # @api private
@@ -289,17 +291,18 @@ 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
 
     def protocol_helper
       case config.api.metadata['protocol']
-      when 'json'      then Stubbing::Protocols::Json
-      when 'query'     then Stubbing::Protocols::Query
-      when 'ec2'       then Stubbing::Protocols::EC2
-      when 'rest-json' then Stubbing::Protocols::RestJson
-      when 'rest-xml'  then Stubbing::Protocols::RestXml
+      when 'json'        then Stubbing::Protocols::Json
+      when 'query'       then Stubbing::Protocols::Query
+      when 'ec2'         then Stubbing::Protocols::EC2
+      when 'rest-json'   then Stubbing::Protocols::RestJson
+      when 'rest-xml'    then Stubbing::Protocols::RestXml
+      when 'api-gateway' then Stubbing::Protocols::ApiGateway
       else raise "unsupported protocol"
       end.new
     end

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

@@ -1,3 +1,5 @@
+require_relative 'deprecations'
+
 module Aws
   module CredentialProvider
 

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

@@ -21,8 +21,10 @@ module Aws
       [
         [:static_credentials, {}],
         [:env_credentials, {}],
+        [:assume_role_web_identity_credentials, {}],
         [:assume_role_credentials, {}],
         [:shared_credentials, {}],
+        [:process_credentials, {}],
         [:instance_profile_credentials, {
           retries: @config ? @config.instance_profile_credentials_retries : 0,
           http_open_timeout: @config ? @config.instance_profile_credentials_timeout : 1,
@@ -69,6 +71,20 @@ module Aws
       nil
     end
 
+    def process_credentials(options)
+      profile_name = options[:config].profile if options[:config]
+      profile_name ||= ENV['AWS_PROFILE'].nil? ? 'default' : ENV['AWS_PROFILE']
+      
+      config = Aws.shared_config
+      if config.config_enabled? && process_provider = config.credentials_process(profile_name)
+        ProcessCredentials.new(process_provider)
+      else
+        nil
+      end
+    rescue Errors::NoSuchProfileError
+      nil
+    end
+
     def assume_role_credentials(options)
       if Aws.shared_config.config_enabled?
         profile, region = nil, nil
@@ -83,6 +99,22 @@ module Aws
       end
     end
 
+    def assume_role_web_identity_credentials(options)
+      if (role_arn = ENV['AWS_ROLE_ARN']) &&
+        (token_file = ENV['AWS_WEB_IDENTITY_TOKEN_FILE'])
+        AssumeRoleWebIdentityCredentials.new(
+          role_arn: role_arn,
+          web_identity_token_file: token_file,
+          role_session_name: ENV['AWS_ROLE_SESSION_NAME']
+        )
+      elsif Aws.shared_config.config_enabled?
+        profile = options[:config].profile if options[:config]
+        Aws.shared_config.assume_role_web_identity_credentials_from_config(profile)
+      else
+        nil
+      end
+    end
+
     def instance_profile_credentials(options)
       if ENV["AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"]
         ECSCredentials.new(options)
@@ -94,7 +126,8 @@ module Aws
     def assume_role_with_profile(prof, region)
       Aws.shared_config.assume_role_credentials_from_config(
         profile: prof,
-        region: region
+        region: region,
+        chain_config: @config
       )
     end