aws-sdk-core 2.3.23 → 3.89.1

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

@@ -0,0 +1,103 @@
+module Aws
+  module Rest
+    module Request
+      class QuerystringBuilder
+
+        include Seahorse::Model::Shapes
+
+        # Provide shape references and param values:
+        #
+        #     [
+        #       [shape_ref1, 123],
+        #       [shape_ref2, "text"]
+        #     ]
+        #
+        # Returns a querystring:
+        #
+        #   "Count=123&Words=text"
+        #
+        # @param [Array<Array<Seahorse::Model::ShapeRef, Object>>] params An array of
+        #   model shape references and request parameter value pairs.
+        #
+        # @return [String] Returns a built querystring
+        def build(params)
+          params.map do |(shape_ref, param_value)|
+            build_part(shape_ref, param_value)
+          end.join('&')
+        end
+
+        private
+
+        def build_part(shape_ref, param_value)
+          case shape_ref.shape
+          # supported scalar types
+          when StringShape, BooleanShape, FloatShape, IntegerShape, StringShape
+            param_name = shape_ref.location_name
+            "#{param_name}=#{escape(param_value.to_s)}"
+          when TimestampShape
+            param_name = shape_ref.location_name
+            "#{param_name}=#{escape(timestamp(shape_ref, param_value))}"
+          when MapShape
+            if StringShape === shape_ref.shape.value.shape
+              query_map_of_string(param_value)
+            elsif ListShape === shape_ref.shape.value.shape
+              query_map_of_string_list(param_value)
+            else
+              msg = "only map of string and string list supported"
+              raise NotImplementedError, msg
+            end
+          when ListShape
+            if StringShape === shape_ref.shape.member.shape
+              list_of_strings(shape_ref.location_name, param_value)
+            else
+              msg = "Only list of strings supported, got "
+              msg << shape_ref.shape.member.shape.class.name
+              raise NotImplementedError, msg
+            end
+          else
+            raise NotImplementedError
+          end
+        end
+
+        def timestamp(ref, value)
+          case ref['timestampFormat'] || ref.shape['timestampFormat']
+          when 'unixTimestamp' then value.to_i
+          when 'rfc822' then value.utc.httpdate
+          else
+            # querystring defaults to iso8601
+            value.utc.iso8601
+          end
+        end
+
+        def query_map_of_string(hash)
+          list = []
+          hash.each_pair do |key, value|
+            list << "#{escape(key)}=#{escape(value)}"
+          end
+          list
+        end
+
+        def query_map_of_string_list(hash)
+          list = []
+          hash.each_pair do |key, values|
+            values.each do |value|
+              list << "#{escape(key)}=#{escape(value)}"
+            end
+          end
+          list
+        end
+
+        def list_of_strings(name, values)
+          values.map do |value|
+            "#{name}=#{escape(value)}"
+          end
+        end
+
+        def escape(string)
+          Seahorse::Util.uri_escape(string)
+        end
+
+      end
+    end
+  end
+end

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

@@ -15,7 +15,9 @@ module Aws
         # @param [IO] body
         # @param [Hash, Struct] data
         def apply(body, data)
-          if streaming?
+          if event_stream?
+            data[@rules[:payload]] = parse_eventstream(body)
+          elsif streaming?
             data[@rules[:payload]] = body
           elsif @rules[:payload]
             data[@rules[:payload]] = parse(body.read, @rules[:payload_member])
@@ -26,6 +28,10 @@ module Aws
 
         private
 
+        def event_stream?
+          @rules[:payload] && @rules[:payload_member].eventstream
+        end
+
         def streaming?
           @rules[:payload] && (
             BlobShape === @rules[:payload_member].shape ||
@@ -37,6 +43,13 @@ module Aws
           @parser_class.new(rules).parse(body, target) if body.size > 0
         end
 
+        def parse_eventstream(body)
+          # body contains an array of parsed event when they arrive
+          @rules[:payload_member].shape.struct_class.new do |payload|
+            body.each { |event| payload << event }
+          end
+        end
+
       end
     end
   end

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

@@ -1,4 +1,6 @@
 require 'time'
+require 'base64'
+require 'json'
 
 module Aws
   module Rest
@@ -31,6 +33,7 @@ module Aws
         end
 
         def cast_value(ref, value)
+          value = extract_json_trait(value) if ref['jsonvalue']
           case ref.shape
           when StringShape then value
           when IntegerShape then value.to_i
@@ -39,6 +42,8 @@ module Aws
           when TimestampShape
             if value =~ /\d+(\.\d*)/
               Time.at(value.to_f)
+            elsif value =~ /^\d+$/
+              Time.at(value.to_i)
             else
               begin
                 Time.parse(value)
@@ -60,6 +65,10 @@ module Aws
           end
         end
 
+        def extract_json_trait(value)
+          JSON.parse(Base64.decode64(value))
+        end
+
       end
     end
   end

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

@@ -5,31 +5,34 @@ module Aws
 
         def apply(response)
           # TODO : remove this unless check once response stubbing is fixed
-          unless response.data
-            response.data = response.context.operation.output[:struct_class].new
+          if rules = response.context.operation.output
+            response.data = rules.shape.struct_class.new
+            extract_status_code(rules, response)
+            extract_headers(rules, response)
+            extract_body(rules, response)
+          else
+            response.data = EmptyStructure.new
           end
-          extract_status_code(response)
-          extract_headers(response)
-          extract_body(response)
         end
 
         private
 
-        def extract_status_code(response)
-          status_code = StatusCode.new(response.context.operation.output)
+        def extract_status_code(rules, response)
+          status_code = StatusCode.new(rules)
           status_code.apply(response.context.http_response, response.data)
         end
 
-        def extract_headers(response)
-          headers = Headers.new(response.context.operation.output)
+        def extract_headers(rules, response)
+          headers = Headers.new(rules)
           headers.apply(response.context.http_response, response.data)
         end
 
-        def extract_body(response)
-          Body.new(
-            parser_class(response),
-            response.context.operation.output,
-          ).apply(response.context.http_response.body, response.data)
+        def extract_body(rules, response)
+          Body.new(parser_class(response), rules).
+            apply(
+              response.context.http_response.body,
+              response.data
+            )
         end
 
         def parser_class(response)
@@ -37,6 +40,7 @@ module Aws
           case protocol
           when 'rest-xml' then Xml::Parser
           when 'rest-json' then Json::Parser
+          when 'api-gateway' then Json::Parser
           else raise "unsupported protocol #{protocol}"
           end
         end

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

@@ -0,0 +1,451 @@
+module Aws
+
+  # @api private
+  class SharedConfig
+
+    # @return [String]
+    attr_reader :credentials_path
+
+    # @return [String]
+    attr_reader :config_path
+
+    # @return [String]
+    attr_reader :profile_name
+
+    # Constructs a new SharedConfig provider object. This will load the shared
+    # credentials file, and optionally the shared configuration file, as ini
+    # files which support profiles.
+    #
+    # By default, the shared credential file (the default path for which is
+    # `~/.aws/credentials`) and the shared config file (the default path for
+    # which is `~/.aws/config`) are loaded. However, if you set the
+    # `ENV['AWS_SDK_CONFIG_OPT_OUT']` environment variable, only the shared
+    # credential file will be loaded. You can specify the shared credential
+    # file path with the `ENV['AWS_SHARED_CREDENTIALS_FILE']` environment
+    # variable or with the `:credentials_path` option. Similarly, you can
+    # specify the shared config file path with the `ENV['AWS_CONFIG_FILE']`
+    # environment variable or with the `:config_path` option.
+    #
+    # The default profile name is 'default'. You can specify the profile name
+    # with the `ENV['AWS_PROFILE']` environment variable or with the
+    # `:profile_name` option.
+    #
+    # @param [Hash] options
+    # @option options [String] :credentials_path Path to the shared credentials
+    #   file. If not specified, will check `ENV['AWS_SHARED_CREDENTIALS_FILE']`
+    #   before using the default value of "#{Dir.home}/.aws/credentials".
+    # @option options [String] :config_path Path to the shared config file.
+    #   If not specified, will check `ENV['AWS_CONFIG_FILE']` before using the
+    #   default value of "#{Dir.home}/.aws/config".
+    # @option options [String] :profile_name The credential/config profile name
+    #   to use. If not specified, will check `ENV['AWS_PROFILE']` before using
+    #   the fixed default value of 'default'.
+    # @option options [Boolean] :config_enabled If true, loads the shared config
+    #   file and enables new config values outside of the old shared credential
+    #   spec.
+    def initialize(options = {})
+      @parsed_config = nil
+      @profile_name = determine_profile(options)
+      @config_enabled = options[:config_enabled]
+      @credentials_path = options[:credentials_path] ||
+        determine_credentials_path
+      @parsed_credentials = {}
+      load_credentials_file if loadable?(@credentials_path)
+      if @config_enabled
+        @config_path = options[:config_path] || determine_config_path
+        load_config_file if loadable?(@config_path)
+      end
+    end
+
+    # @api private
+    def fresh(options = {})
+      @profile_name = nil
+      @credentials_path = nil
+      @config_path = nil
+      @parsed_credentials = {}
+      @parsed_config = nil
+      @config_enabled = options[:config_enabled] ? true : false
+      @profile_name = determine_profile(options)
+      @credentials_path = options[:credentials_path] ||
+        determine_credentials_path
+      load_credentials_file if loadable?(@credentials_path)
+      if @config_enabled
+        @config_path = options[:config_path] || determine_config_path
+        load_config_file if loadable?(@config_path)
+      end
+    end
+
+    # @return [Boolean] Returns `true` if a credential file
+    #   exists and has appropriate read permissions at {#path}.
+    # @note This method does not indicate if the file found at {#path}
+    #   will be parsable, only if it can be read.
+    def loadable?(path)
+      !path.nil? && File.exist?(path) && File.readable?(path)
+    end
+
+    # @return [Boolean] returns `true` if use of the shared config file is
+    #   enabled.
+    def config_enabled?
+      @config_enabled ? true : false
+    end
+
+    # Sources static credentials from shared credential/config files.
+    #
+    # @param [Hash] opts
+    # @option options [String] :profile the name of the configuration file from
+    #   which credentials are being sourced.
+    # @return [Aws::Credentials] credentials sourced from configuration values,
+    #   or `nil` if no valid credentials were found.
+    def credentials(opts = {})
+      p = opts[:profile] || @profile_name
+      validate_profile_exists(p) if credentials_present?
+      if (credentials = credentials_from_shared(p, opts))
+        credentials
+      elsif (credentials = credentials_from_config(p, opts))
+        credentials
+      end
+    end
+
+    # Attempts to assume a role from shared config or shared credentials file.
+    # Will always attempt first to assume a role from the shared credentials
+    # file, if present.
+    def assume_role_credentials_from_config(opts = {})
+      p = opts.delete(:profile) || @profile_name
+      chain_config = opts.delete(:chain_config)
+      credentials = assume_role_from_profile(@parsed_credentials, p, opts, chain_config)
+      if @parsed_config
+        credentials ||= assume_role_from_profile(@parsed_config, p, opts, chain_config)
+      end
+      credentials
+    end
+
+    def assume_role_web_identity_credentials_from_config(profile)
+      p = profile || @profile_name
+      if @config_enabled && @parsed_config
+        entry = @parsed_config.fetch(p, {})
+        if entry['web_identity_token_file'] &&
+          entry['role_arn']
+          AssumeRoleWebIdentityCredentials.new(
+            role_arn: entry['role_arn'],
+            web_identity_token_file: entry['web_identity_token_file'],
+            role_session_name: entry['role_session_name']
+          )
+        else
+          nil
+        end
+      else
+        nil
+      end
+    end
+
+    def region(opts = {})
+      p = opts[:profile] || @profile_name
+      if @config_enabled
+        if @parsed_credentials
+          region = @parsed_credentials.fetch(p, {})["region"]
+        end
+        if @parsed_config
+          region ||= @parsed_config.fetch(p, {})["region"]
+        end
+        region
+      else
+        nil
+      end
+    end
+
+    def sts_regional_endpoints(opts = {})
+      p = opts[:profile] || @profile_name
+      if @config_enabled
+        if @parsed_credentials
+          mode = @parsed_credentials.fetch(p, {})["sts_regional_endpoints"]
+        end
+        if @parsed_config
+          mode ||= @parsed_config.fetch(p, {})["sts_regional_endpoints"]
+        end
+        mode
+      else
+        nil
+      end
+    end
+
+    def s3_us_east_1_regional_endpoint(opts = {})
+      p = opts[:profile] || @profile_name
+      if @config_enabled
+        if @parsed_credentials
+          mode = @parsed_credentials.fetch(p, {})["s3_us_east_1_regional_endpoint"]
+        end
+        if @parsed_config
+          mode ||= @parsed_config.fetch(p, {})["s3_us_east_1_regional_endpoint"]
+        end
+        mode
+      else
+        nil
+      end
+    end
+
+    def s3_use_arn_region(opts = {})
+      p = opts[:profile] || @profile_name
+      if @config_enabled
+        if @parsed_credentials
+          value = @parsed_credentials.fetch(p, {})["s3_use_arn_region"]
+        end
+        if @parsed_config
+          value ||= @parsed_config.fetch(p, {})["s3_use_arn_region"]
+        end
+        value
+      else
+        nil
+      end
+    end
+
+    def endpoint_discovery(opts = {})
+      p = opts[:profile] || @profile_name
+      if @config_enabled && @parsed_config
+        @parsed_config.fetch(p, {})["endpoint_discovery_enabled"]
+      end
+    end
+
+    def credentials_process(profile)
+      validate_profile_exists(profile)
+      @parsed_config[profile]['credential_process']
+    end
+
+    def csm_enabled(opts = {})
+      p = opts[:profile] || @profile_name
+      if @config_enabled
+        if @parsed_credentials
+          value = @parsed_credentials.fetch(p, {})["csm_enabled"]
+        end
+        if @parsed_config
+          value ||= @parsed_config.fetch(p, {})["csm_enabled"]
+        end
+        value
+      else
+        nil
+      end
+    end
+
+    def csm_client_id(opts = {})
+      p = opts[:profile] || @profile_name
+      if @config_enabled
+        if @parsed_credentials
+          value = @parsed_credentials.fetch(p, {})["csm_client_id"]
+        end
+        if @parsed_config
+          value ||= @parsed_config.fetch(p, {})["csm_client_id"]
+        end
+        value
+      else
+        nil
+      end
+    end
+
+    def csm_port(opts = {})
+      p = opts[:profile] || @profile_name
+      if @config_enabled
+        if @parsed_credentials
+          value = @parsed_credentials.fetch(p, {})["csm_port"]
+        end
+        if @parsed_config
+          value ||= @parsed_config.fetch(p, {})["csm_port"]
+        end
+        value
+      else
+        nil
+      end
+    end
+
+    def csm_host(opts = {})
+      p = opts[:profile] || @profile_name
+      if @config_enabled
+        if @parsed_credentials
+          value = @parsed_credentials.fetch(p, {})["csm_host"]
+        end
+        if @parsed_config
+          value ||= @parsed_config.fetch(p, {})["csm_host"]
+        end
+        value
+      else
+        nil
+      end
+    end
+
+    private
+
+    def credentials_present?
+      (@parsed_credentials && !@parsed_credentials.empty?) ||
+        (@parsed_config && !@parsed_config.empty?)
+    end
+
+    def assume_role_from_profile(cfg, profile, opts, chain_config)
+      if cfg && prof_cfg = cfg[profile]
+        opts[:source_profile] ||= prof_cfg["source_profile"]
+        credential_source = opts.delete(:credential_source)
+        credential_source ||= prof_cfg["credential_source"]
+        if opts[:source_profile] && credential_source
+          raise Errors::CredentialSourceConflictError.new(
+            "Profile #{profile} has a source_profile, and "\
+              "a credential_source. For assume role credentials, must "\
+              "provide only source_profile or credential_source, not both."
+          )
+        elsif opts[:source_profile]
+          opts[:credentials] = resolve_source_profile(opts[:source_profile])
+          if opts[:credentials]
+            opts[:role_session_name] ||= prof_cfg["role_session_name"]
+            opts[:role_session_name] ||= "default_session"
+            opts[:role_arn] ||= prof_cfg["role_arn"]
+            opts[:duration_seconds] ||= prof_cfg["duration_seconds"]
+            opts[:external_id] ||= prof_cfg["external_id"]
+            opts[:serial_number] ||= prof_cfg["mfa_serial"]
+            opts[:profile] = opts.delete(:source_profile)
+            AssumeRoleCredentials.new(opts)
+          else
+            raise Errors::NoSourceProfileError.new(
+              "Profile #{profile} has a role_arn, and source_profile, but the"\
+                " source_profile does not have credentials."
+            )
+          end
+        elsif credential_source
+          opts[:credentials] = credentials_from_source(
+            credential_source,
+            chain_config
+          )
+          if opts[:credentials]
+            opts[:role_session_name] ||= prof_cfg["role_session_name"]
+            opts[:role_session_name] ||= "default_session"
+            opts[:role_arn] ||= prof_cfg["role_arn"]
+            opts[:duration_seconds] ||= prof_cfg["duration_seconds"]
+            opts[:external_id] ||= prof_cfg["external_id"]
+            opts[:serial_number] ||= prof_cfg["mfa_serial"]
+            opts.delete(:source_profile) # Cleanup
+            AssumeRoleCredentials.new(opts)
+          else
+            raise Errors::NoSourceCredentials.new(
+              "Profile #{profile} could not get source credentials from"\
+                " provider #{credential_source}"
+            )
+          end
+        elsif prof_cfg["role_arn"]
+          raise Errors::NoSourceProfileError.new(
+            "Profile #{profile} has a role_arn, but no source_profile."
+          )
+        else
+          nil
+        end
+      else
+        nil
+      end
+    end
+
+    def resolve_source_profile(profile)
+      if (creds = credentials(profile: profile))
+        creds # static credentials
+      elsif (provider = assume_role_web_identity_credentials_from_config(profile))
+        if provider.credentials.set?
+          provider.credentials
+        end
+      elsif (provider = assume_role_process_credentials_from_config(profile))
+        if provider.credentials.set?
+          provider.credentials
+        end
+      end
+    end
+
+    def credentials_from_source(credential_source, config)
+      case credential_source
+      when "Ec2InstanceMetadata"
+        InstanceProfileCredentials.new(
+          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
+        )
+      when "EcsContainer"
+        ECSCredentials.new
+      else
+        raise Errors::InvalidCredentialSourceError.new(
+          "Unsupported credential_source: #{credential_source}"
+        )
+      end
+    end
+
+    def assume_role_process_credentials_from_config(profile)
+      credential_process = credentials_process(profile)
+      ProcessCredentials.new(credential_process) if credential_process
+    end
+
+    def credentials_from_shared(profile, opts)
+      if @parsed_credentials && prof_config = @parsed_credentials[profile]
+        credentials_from_profile(prof_config)
+      else
+        nil
+      end
+    end
+
+    def credentials_from_config(profile, opts)
+      if @parsed_config && prof_config = @parsed_config[profile]
+        credentials_from_profile(prof_config)
+      else
+        nil
+      end
+    end
+
+    def credentials_from_profile(prof_config)
+      creds = Credentials.new(
+        prof_config['aws_access_key_id'],
+        prof_config['aws_secret_access_key'],
+        prof_config['aws_session_token']
+      )
+      if credentials_complete(creds)
+        creds
+      else
+        nil
+      end
+    end
+
+    def credentials_complete(creds)
+      creds.set?
+    end
+
+    def load_credentials_file
+      @parsed_credentials = IniParser.ini_parse(
+        File.read(@credentials_path)
+      )
+    end
+
+    def load_config_file
+      @parsed_config = IniParser.ini_parse(File.read(@config_path))
+    end
+
+    def determine_credentials_path
+      ENV['AWS_SHARED_CREDENTIALS_FILE'] || default_shared_config_path('credentials')
+    end
+
+    def determine_config_path
+      ENV['AWS_CONFIG_FILE'] || default_shared_config_path('config')
+    end
+
+    def default_shared_config_path(file)
+      File.join(Dir.home, '.aws', file)
+    rescue ArgumentError
+      # Dir.home raises ArgumentError when ENV['home'] is not set
+      nil
+    end
+
+    def validate_profile_exists(profile)
+      unless (@parsed_credentials && @parsed_credentials[profile]) ||
+          (@parsed_config && @parsed_config[profile])
+        msg = "Profile `#{profile}' not found in #{@credentials_path}"
+        msg << " or #{@config_path}" if @config_path
+        raise Errors::NoSuchProfileError.new(msg)
+      end
+    end
+
+    def determine_profile(options)
+      ret = options[:profile_name]
+      ret ||= ENV["AWS_PROFILE"]
+      ret ||= "default"
+      ret
+    end
+
+  end
+end