aws-sdk-core 2.4.0 → 3.53.0

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,41 @@
+require 'thread'
+require 'socket'
+
+module Aws
+  module ClientSideMonitoring
+    # @api private
+    class Publisher
+      attr_reader :agent_port
+
+      def initialize(opts = {})
+        @agent_port = opts[:agent_port]
+        @mutex = Mutex.new
+      end
+
+      def agent_port=(value)
+        @mutex.synchronize do
+          @agent_port = 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("127.0.0.1", @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,19 @@ 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
+      @api_requests = []
+
+      requests = @api_requests
+      self.handle do |context|
+        requests << {
+          operation_name: context.operation_name,
+          params: context.params,
+          context: context
+        }
+        @handler.call(context)
       end
     end
 
@@ -50,8 +65,18 @@ module Aws
     #       buckets: [{ name: 'my-bucket' }]
     #     })
     #
-    #     client.list_buckets.buckets.map(&:name) #=> ['my-bucket']
-    #     #=> ['aws-sdk']
+    #     client.list_buckets.buckets.map(&:name)
+    #     #=> ['my-bucket']
+    #
+    # With a Resource class {#stub_responses} on the corresponding client:
+    #
+    #     s3 = Aws::S3::Resource.new(stub_responses: true)
+    #     s3.client.stub_responses(:list_buckets, {
+    #       buckets: [{ name: 'my-bucket' }]
+    #     })
+    #
+    #     s3.buckets.map(&:name)
+    #     #=> ['my-bucket']
     #
     # Lastly, default stubs can be configured via `Aws.config`:
     #
@@ -64,6 +89,22 @@ module Aws
     #     Aws::S3::Client.new.list_buckets.buckets.map(&:name)
     #     #=> ['my-bucket']
     #
+    #     Aws::S3::Resource.new.buckets.map(&:name)
+    #     #=> ['my-bucket']
+    #
+    # ## Dynamic Stubbing
+    #
+    # In addition to creating static stubs, it's also possible to generate
+    # stubs dynamically based on the parameters with which operations were
+    # called, by passing a `Proc` object:
+    #
+    #     s3 = Aws::S3::Resource.new(stub_responses: true)
+    #     s3.client.stub_responses(:put_object, -> (context) {
+    #       s3.client.stub_responses(:get_object, content_type: context.params[:content_type])
+    #     })
+    #
+    # The yielded object is an instance of {Seahorse::Client::RequestContext}.
+    #
     # ## Stubbing Errors
     #
     # When stubbing is enabled, the SDK will default to generate
@@ -141,6 +182,27 @@ module Aws
       end
     end
 
+    # Allows you to access all of the requests that the stubbed client has made
+    #
+    # @params [Boolean] exclude_presign Setting to true for filtering out not sent requests from
+    #                 generating presigned urls. Default to false.
+    # @return [Array] Returns an array of the api requests made, each request object contains the
+    #                 :operation_name, :params, and :context of the request. 
+    # @raise [NotImplementedError] Raises `NotImplementedError` when the client is not stubbed
+    def api_requests(options = {})
+      if config.stub_responses
+        if options[:exclude_presign]
+          @api_requests.reject {|req| req[:context][:presigned_url] }
+        else
+          @api_requests
+        end
+      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
+
     # Generates and returns stubbed response data from the named operation.
     #
     #     s3 = Aws::S3::Client.new
@@ -160,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
@@ -229,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

@@ -23,10 +23,11 @@ module Aws
         [:env_credentials, {}],
         [:assume_role_credentials, {}],
         [:shared_credentials, {}],
+        [:process_credentials, {}],
         [:instance_profile_credentials, {
-          retries: 0,
-          http_open_timeout: 1,
-          http_read_timeout: 1,
+          retries: @config ? @config.instance_profile_credentials_retries : 0,
+          http_open_timeout: @config ? @config.instance_profile_credentials_timeout : 1,
+          http_read_timeout: @config ? @config.instance_profile_credentials_timeout : 1,
         }],
       ]
     end
@@ -62,7 +63,22 @@ module Aws
       if options[:config]
         SharedCredentials.new(profile_name: options[:config].profile)
       else
-        SharedCredentials.new(profile_name: 'default')
+        SharedCredentials.new(
+          profile_name: ENV['AWS_PROFILE'].nil? ? 'default' : ENV['AWS_PROFILE'])
+      end
+    rescue Errors::NoSuchProfileError
+      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
@@ -93,7 +109,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