aws-sdk-core 3.197.0 → 3.220.0

data/lib/aws-sdk-core/plugins/user_agent.rb

@@ -17,7 +17,24 @@ module Aws
           "S3_CRYPTO_V2": "I",
           "S3_EXPRESS_BUCKET": "J",
           "S3_ACCESS_GRANTS": "K",
-          "GZIP_REQUEST_COMPRESSION": "L"
+          "GZIP_REQUEST_COMPRESSION": "L",
+          "PROTOCOL_RPC_V2_CBOR": "M",
+          "ENDPOINT_OVERRIDE": "N",
+          "ACCOUNT_ID_ENDPOINT": "O",
+          "ACCOUNT_ID_MODE_PREFERRED": "P",
+          "ACCOUNT_ID_MODE_DISABLED": "Q",
+          "ACCOUNT_ID_MODE_REQUIRED": "R",
+          "SIGV4A_SIGNING": "S",
+          "RESOLVED_ACCOUNT_ID": "T",
+          "FLEXIBLE_CHECKSUMS_REQ_CRC32" : "U",
+          "FLEXIBLE_CHECKSUMS_REQ_CRC32C" : "V",
+          "FLEXIBLE_CHECKSUMS_REQ_CRC64" : "W",
+          "FLEXIBLE_CHECKSUMS_REQ_SHA1" : "X",
+          "FLEXIBLE_CHECKSUMS_REQ_SHA256" : "Y",
+          "FLEXIBLE_CHECKSUMS_REQ_WHEN_SUPPORTED" : "Z",
+          "FLEXIBLE_CHECKSUMS_REQ_WHEN_REQUIRED" : "a",
+          "FLEXIBLE_CHECKSUMS_RES_WHEN_SUPPORTED" : "b",
+          "FLEXIBLE_CHECKSUMS_RES_WHEN_REQUIRED" : "c"
         }
       METRICS
 
@@ -45,15 +62,13 @@ variable AWS_SDK_UA_APP_ID or the shared config profile attribute sdk_ua_app_id.
         block.call
       end
 
-      def self.metric(metric, &block)
+      def self.metric(*metrics, &block)
         Thread.current[:aws_sdk_core_user_agent_metric] ||= []
-        Thread.current[:aws_sdk_core_user_agent_metric] << METRICS[metric]
+        metrics = metrics.map { |metric| METRICS[metric] }.compact
+        Thread.current[:aws_sdk_core_user_agent_metric].concat(metrics)
         block.call
       ensure
-        Thread.current[:aws_sdk_core_user_agent_metric].pop
-        if Thread.current[:aws_sdk_core_user_agent_metric].empty?
-          Thread.current[:aws_sdk_core_user_agent_metric] = nil
-        end
+        Thread.current[:aws_sdk_core_user_agent_metric].pop(metrics.size)
       end
 
       # @api private
@@ -166,7 +181,10 @@ variable AWS_SDK_UA_APP_ID or the shared config profile attribute sdk_ua_app_id.
           end
 
           def metric_metadata
-            return unless Thread.current[:aws_sdk_core_user_agent_metric]
+            if Thread.current[:aws_sdk_core_user_agent_metric].nil? ||
+               Thread.current[:aws_sdk_core_user_agent_metric].empty?
+              return
+            end
 
             metrics = Thread.current[:aws_sdk_core_user_agent_metric].join(',')
             # Metric metadata is limited to 1024 bytes

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Aws
+  # setup autoloading for Plugins
+  # Most plugins are required explicitly from service clients
+  # but users may reference them outside of client usage.
+  module Plugins
+    autoload :ApiKey, 'aws-sdk-core/plugins/api_key'
+    autoload :BearerAuthorization, 'aws-sdk-core/plugins/bearer_authorization'
+    autoload :ChecksumAlgorithm, 'aws-sdk-core/plugins/checksum_algorithm'
+    autoload :ClientMetricsPlugin, 'aws-sdk-core/plugins/client_metrics_plugin'
+    autoload :ClientMetricsSendPlugin, 'aws-sdk-core/plugins/client_metrics_send_plugin'
+    autoload :CredentialsConfiguration, 'aws-sdk-core/plugins/credentials_configuration'
+    autoload :DefaultsMode, 'aws-sdk-core/plugins/defaults_mode'
+    autoload :EndpointDiscovery, 'aws-sdk-core/plugins/endpoint_discovery'
+    autoload :EndpointPattern, 'aws-sdk-core/plugins/endpoint_pattern'
+    autoload :EventStreamConfiguration, 'aws-sdk-core/plugins/event_stream_configuration'
+    autoload :GlobalConfiguration, 'aws-sdk-core/plugins/global_configuration'
+    autoload :HelpfulSocketErrors, 'aws-sdk-core/plugins/helpful_socket_errors'
+    autoload :HttpChecksum, 'aws-sdk-core/plugins/http_checksum'
+    autoload :IdempotencyToken, 'aws-sdk-core/plugins/idempotency_token'
+    autoload :InvocationId, 'aws-sdk-core/plugins/invocation_id'
+    autoload :JsonvalueConverter, 'aws-sdk-core/plugins/jsonvalue_converter'
+    autoload :Logging, 'aws-sdk-core/plugins/logging'
+    autoload :ParamConverter, 'aws-sdk-core/plugins/param_converter'
+    autoload :ParamValidator, 'aws-sdk-core/plugins/param_validator'
+    autoload :RecursionDetection, 'aws-sdk-core/plugins/recursion_detection'
+    autoload :RegionalEndpoint, 'aws-sdk-core/plugins/regional_endpoint'
+    autoload :RequestCompression, 'aws-sdk-core/plugins/request_compression'
+    autoload :ResponsePaging, 'aws-sdk-core/plugins/response_paging'
+    autoload :RetryErrors, 'aws-sdk-core/plugins/retry_errors'
+    autoload :Sign, 'aws-sdk-core/plugins/sign'
+    autoload :SignatureV4, 'aws-sdk-core/plugins/signature_v4'
+    autoload :StubResponses, 'aws-sdk-core/plugins/stub_responses'
+    autoload :Telemetry, 'aws-sdk-core/plugins/telemetry'
+    autoload :TransferEncoding, 'aws-sdk-core/plugins/transfer_encoding'
+    autoload :UserAgent, 'aws-sdk-core/plugins/user_agent'
+  end
+end

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

@@ -2,9 +2,15 @@
 
 module Aws
   # A credential provider that executes a given process and attempts
-  # to read its stdout to recieve a JSON payload containing the credentials.
+  # to read its stdout to receive a JSON payload containing the credentials.
   #
-  #     credentials = Aws::ProcessCredentials.new('/usr/bin/credential_proc')
+  #     credentials = Aws::ProcessCredentials.new(['/usr/bin/credential_proc'])
+  #     ec2 = Aws::EC2::Client.new(credentials: credentials)
+  #
+  # Arguments should be provided as strings in the array, for example:
+  #
+  #     process = ['/usr/bin/credential_proc', 'arg1', 'arg2']
+  #     credentials = Aws::ProcessCredentials.new(process)
   #     ec2 = Aws::EC2::Client.new(credentials: credentials)
   #
   # Automatically handles refreshing credentials if an Expiration time is
@@ -19,56 +25,69 @@ module Aws
     # Creates a new ProcessCredentials object, which allows an
     # external process to be used as a credential provider.
     #
-    # @param [String] process Invocation string for process
-    # credentials provider.
+    # @param [Array<String>, String] process An array of strings including
+    #  the process name and its arguments to execute, or a single string to be
+    #  executed by the shell (deprecated and insecure).
     def initialize(process)
+      if process.is_a?(String)
+        warn('Passing a single string to Aws::ProcessCredentials.new '\
+             'is insecure, please use use an array of system arguments instead')
+      end
       @process = process
-      @credentials = credentials_from_process(@process)
+      @credentials = credentials_from_process
       @async_refresh = false
 
       super
     end
 
     private
-    def credentials_from_process(proc_invocation)
-      begin
-        raw_out = `#{proc_invocation}`
-        process_status = $?
-      rescue Errno::ENOENT
-        raise Errors::InvalidProcessCredentialsPayload.new("Could not find process #{proc_invocation}")
+
+    def credentials_from_process
+      r, w = IO.pipe
+      success = system(*@process, out: w)
+      w.close
+      raw_out = r.read
+      r.close
+
+      unless success
+        raise Errors::InvalidProcessCredentialsPayload.new(
+          'credential_process provider failure, the credential process had '\
+          'non zero exit status and failed to provide credentials'
+        )
       end
 
-      if process_status.success?
-        begin
-          creds_json = Aws::Json.load(raw_out)
-        rescue Aws::Json::ParseError
-          raise Errors::InvalidProcessCredentialsPayload.new("Invalid JSON response")
-        end
-        payload_version = creds_json['Version']
-        if payload_version == 1
-          _parse_payload_format_v1(creds_json)
-        else
-          raise Errors::InvalidProcessCredentialsPayload.new("Invalid version #{payload_version} for credentials payload")
-        end
-      else
-        raise Errors::InvalidProcessCredentialsPayload.new('credential_process provider failure, the credential process had non zero exit status and failed to provide credentials')
+      begin
+        creds_json = Aws::Json.load(raw_out)
+      rescue Aws::Json::ParseError
+        raise Errors::InvalidProcessCredentialsPayload.new('Invalid JSON response')
       end
+
+      payload_version = creds_json['Version']
+      return _parse_payload_format_v1(creds_json) if payload_version == 1
+
+      raise Errors::InvalidProcessCredentialsPayload.new(
+        "Invalid version #{payload_version} for credentials payload"
+      )
     end
 
     def _parse_payload_format_v1(creds_json)
       creds = Credentials.new(
         creds_json['AccessKeyId'],
         creds_json['SecretAccessKey'],
-        creds_json['SessionToken']
+        creds_json['SessionToken'],
+        account_id: creds_json['AccountId']
       )
 
       @expiration = creds_json['Expiration'] ? Time.iso8601(creds_json['Expiration']) : nil
       return creds if creds.set?
-      raise Errors::InvalidProcessCredentialsPayload.new("Invalid payload for JSON credentials version 1")
+
+      raise Errors::InvalidProcessCredentialsPayload.new(
+        'Invalid payload for JSON credentials version 1'
+      )
     end
 
     def refresh
-      @credentials = credentials_from_process(@process)
+      @credentials = credentials_from_process
     end
 
     def near_expiration?(expiration_length)

data/lib/aws-sdk-core/query/ec2_handler.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Aws
+  # @api private
+  module Query
+    class EC2Handler < Aws::Query::Handler
+
+      def apply_params(param_list, params, rules)
+        Aws::Query::EC2ParamBuilder.new(param_list).apply(rules, params)
+      end
+
+      def parse_xml(context)
+        if (rules = context.operation.output)
+          parser = Xml::Parser.new(rules)
+          parser.parse(xml(context)) do |path, value|
+            if path.size == 2 && path.last == 'requestId'
+              context.metadata[:request_id] = value
+            end
+          end
+        else
+          EmptyStructure.new
+        end
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-core/query/handler.rb

@@ -27,13 +27,13 @@ module Aws
       # @return [Seahorse::Client::Response]
       def call(context)
         build_request(context)
-        @handler.call(context).on_success do |response|
-          response.error = nil
+        @handler.call(context).on_success do |resp|
+          resp.error = nil
           parsed = parse_xml(context)
           if parsed.nil? || parsed == EmptyStructure
-            response.data = EmptyStructure.new
+            resp.data = EmptyStructure.new
           else
-            response.data = parsed
+            resp.data = parsed
           end
         end
       end

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

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'query/ec2_param_builder'
 require_relative 'query/handler'
+require_relative 'query/ec2_handler'
 require_relative 'query/param'
 require_relative 'query/param_builder'
+require_relative 'query/ec2_param_builder'
 require_relative 'query/param_list'

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Aws
+  # setup autoloading for Resources module
+  module Resources
+    autoload :Collection, 'aws-sdk-core/resources/collection'
+  end
+end

data/lib/aws-sdk-core/rest/{request/content_type.rb → content_type_handler.rb}

@@ -35,7 +35,7 @@ module Aws
 
       def eventstream?(context)
         context.operation.input.shape.members.each do |_, ref|
-          return ref if ref.eventstream
+          return true if ref.eventstream
         end
         false
       end

data/lib/aws-sdk-core/rest/handler.rb

@@ -7,10 +7,9 @@ module Aws
 
       def call(context)
         Rest::Request::Builder.new.apply(context)
-        resp = @handler.call(context)
-        resp.on(200..299) { |response| Response::Parser.new.apply(response) }
-        resp.on(200..599) { |response| apply_request_id(context) }
-        resp
+        response = @handler.call(context)
+        response.on(200..299) { |resp| Response::Parser.new.apply(resp) }
+        response.on(200..599) { |_resp| apply_request_id(context) }
       end
 
       private

data/lib/aws-sdk-core/rest/request/endpoint.rb

@@ -30,7 +30,9 @@ module Aws
         private
 
         def apply_path_params(uri, params)
-          path = uri.path.sub(%r{/$}, '') + @path_pattern.split('?')[0]
+          path = uri.path.sub(%r{/$}, '')
+          # handle trailing slash
+          path += @path_pattern.split('?')[0] if path.empty? || @path_pattern != '/'
           uri.path = path.gsub(/{.+?}/) do |placeholder|
             param_value_for_placeholder(placeholder, params)
           end

data/lib/aws-sdk-core/rest/request/headers.rb

@@ -20,7 +20,7 @@ module Aws
         def apply(http_req, params)
           @rules.shape.members.each do |name, ref|
             value = params[name]
-            next if value.nil? || ((ref.shape).is_a?(StringShape) && value.empty?)
+            next if value.nil?
 
             case ref.location
             when 'header' then apply_header_value(http_req.headers, ref, value)
@@ -51,7 +51,7 @@ module Aws
         end
 
         def list(headers, ref, values)
-          return if !values || values.empty?
+          return if values.nil?
 
           member_ref = ref.shape.member
           values = values.collect do |value|

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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 require_relative 'rest/handler'
+require_relative 'rest/content_type_handler'
 require_relative 'rest/request/body'
 require_relative 'rest/request/builder'
 require_relative 'rest/request/endpoint'
 require_relative 'rest/request/headers'
 require_relative 'rest/request/querystring_builder'
-require_relative 'rest/request/content_type'
 require_relative 'rest/response/body'
 require_relative 'rest/response/headers'
 require_relative 'rest/response/parser'

data/lib/aws-sdk-core/rpc_v2/builder.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Aws
+  module RpcV2
+    class Builder
+      include Seahorse::Model::Shapes
+
+      def initialize(rules, _options = {})
+        @rules = rules
+      end
+
+      def serialize(params)
+        # If the input shape is empty, do not set a body. This is
+        # different than if the input shape is a structure with no members.
+        return nil if @rules.shape.struct_class == EmptyStructure
+
+        RpcV2.encode(format(@rules, params))
+      end
+
+      private
+
+      def structure(ref, values)
+        shape = ref.shape
+        values.each_pair.with_object({}) do |(key, value), data|
+          if shape.member?(key) && !value.nil?
+            member_ref = shape.member(key)
+            member_name = member_ref.location_name || key
+            data[member_name] = format(member_ref, value)
+          end
+        end
+      end
+
+      def list(ref, values)
+        member_ref = ref.shape.member
+        values.collect { |value| format(member_ref, value) }
+      end
+
+      def map(ref, values)
+        value_ref = ref.shape.value
+        values.each.with_object({}) do |(key, value), data|
+          data[key] = format(value_ref, value)
+        end
+      end
+
+      def blob(value)
+        (String === value ? value : value.read).force_encoding(Encoding::BINARY)
+      end
+
+      def format(ref, value)
+        case ref.shape
+        when StructureShape then structure(ref, value)
+        when ListShape      then list(ref, value)
+        when MapShape       then map(ref, value)
+        when BlobShape      then blob(value)
+        else value
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/rpc_v2/cbor_engine.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative '../cbor'
+
+module Aws
+  module RpcV2
+    # Pure Ruby implementation of CBOR encode and decode
+    module CborEngine
+      def self.encode(data)
+        Cbor::Encoder.new.add(data).bytes
+      end
+
+      def self.decode(bytes)
+        Cbor::Decoder.new(bytes.force_encoding(Encoding::BINARY)).decode
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/rpc_v2/content_type_handler.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Aws
+  module RpcV2
+    class ContentTypeHandler < Seahorse::Client::Handler
+      def call(context)
+        content_type =
+          if eventstream_input?(context)
+            'application/vnd.amazon.eventstream'
+          elsif !empty_input_structure?(context)
+            'application/cbor'
+          end
+        accept =
+          if eventstream_output?(context)
+            'application/vnd.amazon.eventstream'
+          else
+            'application/cbor'
+          end
+
+        headers = context.http_request.headers
+        headers['Content-Type'] ||= content_type if content_type
+        headers['Accept'] ||= accept
+        @handler.call(context)
+      end
+
+      private
+
+      def eventstream_input?(context)
+        context.operation.input.shape.members.each do |_, ref|
+          return true if ref.eventstream
+        end
+        false
+      end
+
+      def eventstream_output?(context)
+        context.operation.output.shape.members.each do |_, ref|
+          return true if ref.eventstream
+        end
+        false
+      end
+
+      def empty_input_structure?(context)
+        context.operation.input.shape.struct_class == EmptyStructure
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/rpc_v2/error_handler.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Aws
+  module RpcV2
+    class ErrorHandler < Aws::ErrorHandler
+
+      def call(context)
+        # Malformed responses should throw an http based error, so we check
+        # 200 range for error handling only for this case.
+        @handler.call(context).on(200..599) do |response|
+          if !valid_response?(context)
+            code, message, data = http_status_error(context)
+            response.error = build_error(context, code, message, data)
+          elsif (300..599).cover?(context.http_response.status_code)
+            response.error = error(context)
+          end
+          response.data = nil
+        end
+      end
+
+      private
+
+      def valid_response?(context)
+        req_header = context.http_request.headers['smithy-protocol']
+        resp_header = context.http_response.headers['smithy-protocol']
+        req_header == resp_header
+      end
+
+      def extract_error(body, context)
+        data = RpcV2.decode(body)
+        code = error_code(data, context)
+        message = data['message']
+        data = parse_error_data(context, body, code)
+        [code, message, data]
+      rescue Cbor::Error
+        [http_status_error_code(context), '', EmptyStructure.new]
+      end
+
+      def error_code(data, context)
+        code =
+          if aws_query_error?(context)
+            query_header = context.http_response.headers['x-amzn-query-error']
+            error, _type = query_header.split(';') # type not supported
+            remove_prefix(error, context)
+          else
+            data['__type']
+          end
+        if code
+          code.split('#').last
+        else
+          http_status_error_code(context)
+        end
+      end
+
+      def parse_error_data(context, body, code)
+        data = EmptyStructure.new
+        if (error_rules = context.operation.errors)
+          error_rules.each do |rule|
+            # match modeled shape name with the type(code) only
+            # some type(code) might contains invalid characters
+            # such as ':' (efs) etc
+            match = rule.shape.name == code.gsub(/[^^a-zA-Z0-9]/, '')
+            next unless match && rule.shape.members.any?
+
+            data = Parser.new(rule).parse(body)
+          end
+        end
+        data
+      end
+
+      def aws_query_error?(context)
+        context.config.api.metadata['awsQueryCompatible'] &&
+          context.http_response.headers['x-amzn-query-error']
+      end
+
+      def remove_prefix(error_code, context)
+        if (prefix = context.config.api.metadata['errorPrefix'])
+          error_code.sub(/^#{prefix}/, '')
+        else
+          error_code
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/rpc_v2/handler.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Aws
+  module RpcV2
+    class Handler < Seahorse::Client::Handler
+      # @param [Seahorse::Client::RequestContext] context
+      # @return [Seahorse::Client::Response]
+      def call(context)
+        build_request(context)
+        response = with_metric { @handler.call(context) }
+        response.on(200..299) { |resp| resp.data = parse_body(context) }
+        response.on(200..599) { |_resp| apply_request_id(context) }
+        response
+      end
+
+      private
+
+      def with_metric(&block)
+        Aws::Plugins::UserAgent.metric('PROTOCOL_RPC_V2_CBOR', &block)
+      end
+
+      def build_request(context)
+        context.http_request.headers['Smithy-Protocol'] = 'rpc-v2-cbor'
+        context.http_request.headers['X-Amzn-Query-Mode'] = 'true' if query_compatible?(context)
+        context.http_request.http_method = 'POST'
+        context.http_request.body = build_body(context)
+        build_url(context)
+      end
+
+      def build_url(context)
+        base = context.http_request.endpoint
+        service_name = context.config.api.metadata['targetPrefix']
+        base.path += "/service/#{service_name}/operation/#{context.operation.name}"
+      end
+
+      def build_body(context)
+        Builder.new(context.operation.input).serialize(context.params)
+      end
+
+      def parse_body(context)
+        cbor = context.http_response.body_contents
+        if (rules = context.operation.output)
+          if cbor.is_a?(Array)
+            # an array of emitted events
+            if cbor[0].respond_to?(:response)
+              # initial response exists
+              # it must be the first event arrived
+              resp_struct = cbor.shift.response
+            else
+              resp_struct = context.operation.output.shape.struct_class.new
+            end
+
+            rules.shape.members.each do |name, ref|
+              if ref.eventstream
+                resp_struct.send("#{name}=", cbor.to_enum)
+              end
+            end
+            resp_struct
+          else
+            Parser.new(
+              rules,
+              query_compatible: query_compatible?(context)
+            ).parse(cbor)
+          end
+        else
+          EmptyStructure.new
+        end
+      end
+
+      def apply_request_id(context)
+        context[:request_id] = context.http_response.headers['x-amzn-requestid']
+      end
+
+      def query_compatible?(context)
+        context.config.api.metadata.key?('awsQueryCompatible')
+      end
+    end
+  end
+end