aws-sdk-core 2.11.501 → 3.94.0

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

@@ -0,0 +1,62 @@
+module Aws
+  class EventEmitter
+
+    def initialize
+      @listeners = {}
+      @validate_event = true
+      @status = :sleep
+      @signal_queue = Queue.new
+    end
+
+    attr_accessor :stream
+
+    attr_accessor :encoder
+
+    attr_accessor :validate_event
+
+    attr_accessor :signal_queue
+
+    def on(type, callback)
+      (@listeners[type] ||= []) << callback
+    end
+
+    def signal(type, event)
+      return unless @listeners[type]
+      @listeners[type].each do |listener|
+        listener.call(event) if event.event_type == type
+      end
+    end
+
+    def emit(type, params)
+      unless @stream
+        raise Aws::Errors::SignalEventError.new(
+          "Singaling events before making async request"\
+          " is not allowed."
+        )
+      end
+      if @validate_event && type != :end_stream
+        Aws::ParamValidator.validate!(
+          @encoder.rules.shape.member(type), params)
+      end
+      _ready_for_events?
+      @stream.data(
+        @encoder.encode(type, params),
+        end_stream: type == :end_stream
+      )
+    end
+
+    private
+
+    def _ready_for_events?
+      return true if @status == :ready
+
+      # blocked until once initial 200 response is received
+      # signal will be available in @signal_queue
+      # and this check will no longer be blocked
+      @signal_queue.pop
+      @status = :ready
+      true
+    end
+
+  end
+end

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

@@ -1,4 +1,5 @@
 module Aws
+  # @api private
   class IniParser
     class << self
 

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

@@ -17,9 +17,6 @@ module Aws
     # @api private
     class TokenExpiredError < RuntimeError; end
 
-    # @api private
-    class TokenRetrivalUnavailableError < RuntimeError; end
-
     # These are the errors we trap when attempting to talk to the
     # instance metadata service.  Any of these imply the service
     # is not present, no responding or some other non-recoverable
@@ -32,24 +29,24 @@ module Aws
       Errno::ENETUNREACH,
       SocketError,
       Timeout::Error,
-      Non200Response,
-    ]
+      Non200Response
+    ].freeze
 
     # Path base for GET request for profile and credentials
     # @api private
-    METADATA_PATH_BASE = '/latest/meta-data/iam/security-credentials/'
+    METADATA_PATH_BASE = '/latest/meta-data/iam/security-credentials/'.freeze
 
     # Path for PUT request for token
     # @api private
-    METADATA_TOKEN_PATH = '/latest/api/token'
+    METADATA_TOKEN_PATH = '/latest/api/token'.freeze
 
     # @param [Hash] options
-    # @option options [Integer] :retries (5) Number of times to retry
+    # @option options [Integer] :retries (1) Number of times to retry
     #   when retrieving credentials.
     # @option options [String] :ip_address ('169.254.169.254')
     # @option options [Integer] :port (80)
-    # @option options [Float] :http_open_timeout (5)
-    # @option options [Float] :http_read_timeout (5)
+    # @option options [Float] :http_open_timeout (1)
+    # @option options [Float] :http_read_timeout (1)
     # @option options [Numeric, Proc] :delay By default, failures are retried
     #   with exponential back-off, i.e. `sleep(1.2 ** num_failures)`. You can
     #   pass a number of seconds to sleep between failed attempts, or
@@ -57,17 +54,19 @@ module Aws
     # @option options [IO] :http_debug_output (nil) HTTP wire
     #   traces are sent to this object.  You can specify something
     #   like $stdout.
-    # @option options [Integer] :token_ttl (21600) Time-to-Live in seconds for
-    #   EC2 Metadata Token used for fetching Metadata Profile Credentials.
-    def initialize options = {}
-      @retries = options[:retries] || 5
+    # @option options [Integer] :token_ttl Time-to-Live in seconds for EC2
+    #   Metadata Token used for fetching Metadata Profile Credentials, defaults
+    #   to 21600 seconds
+    def initialize(options = {})
+      @retries = options[:retries] || 1
       @ip_address = options[:ip_address] || '169.254.169.254'
       @port = options[:port] || 80
-      @http_open_timeout = options[:http_open_timeout] || 5
-      @http_read_timeout = options[:http_read_timeout] || 5
+      @http_open_timeout = options[:http_open_timeout] || 1
+      @http_read_timeout = options[:http_read_timeout] || 1
       @http_debug_output = options[:http_debug_output]
       @backoff = backoff(options[:backoff])
-      @token_ttl = options[:token_ttl] || 21600
+      @token_ttl = options[:token_ttl] || 21_600
+      @token = nil
       super
     end
 
@@ -81,8 +80,8 @@ module Aws
     def backoff(backoff)
       case backoff
       when Proc then backoff
-      when Numeric then lambda { |_| sleep(backoff) }
-      else lambda { |num_failures| Kernel.sleep(1.2 ** num_failures) }
+      when Numeric then ->(_) { sleep(backoff) }
+      else ->(num_failures) { Kernel.sleep(1.2**num_failures) }
       end
     end
 
@@ -101,7 +100,7 @@ module Aws
           @expiration = c['Expiration'] ? Time.iso8601(c['Expiration']) : nil
         end
       rescue JSON::ParserError
-        raise Aws::Errors::MetadataParserError.new
+        raise Aws::Errors::MetadataParserError
       end
     end
 
@@ -114,11 +113,27 @@ module Aws
         begin
           retry_errors(NETWORK_ERRORS, max_retries: @retries) do
             open_connection do |conn|
-              _token_attempt(conn)
-              token_value = @token.value if token_set?
-              profile_name = http_get(conn, METADATA_PATH_BASE, token_value)
-                .lines.first.strip
-              http_get(conn, METADATA_PATH_BASE + profile_name, token_value)
+              # attempt to fetch token to start secure flow first
+              # and rescue to failover
+              begin
+                retry_errors(NETWORK_ERRORS, max_retries: @retries) do
+                  unless token_set?
+                    token_value, ttl = http_put(
+                      conn, METADATA_TOKEN_PATH, @token_ttl
+                    )
+                    @token = Token.new(token_value, ttl) if token_value && ttl
+                  end
+                end
+              rescue *NETWORK_ERRORS
+                # token attempt failed, reset token
+                # fallback to non-token mode
+                @token = nil
+              end
+
+              token = @token.value if token_set?
+              metadata = http_get(conn, METADATA_PATH_BASE, token)
+              profile_name = metadata.lines.first.strip
+              http_get(conn, METADATA_PATH_BASE + profile_name, token)
             end
           end
         rescue
@@ -131,27 +146,8 @@ module Aws
       @token && !@token.expired?
     end
 
-    # attempt to fetch token with retries baked in
-    # would be skipped if token already set
-    def _token_attempt(conn)
-      begin
-        retry_errors(NETWORK_ERRORS, max_retries: @retries) do
-          unless token_set?
-            token_value, ttl = http_put(conn, METADATA_TOKEN_PATH, @token_ttl)
-            @token = Token.new(token_value, ttl) if token_value && ttl
-          end
-        end
-      rescue *NETWORK_ERRORS, TokenRetrivalUnavailableError
-        # token attempt failed with allowable errors (those indicating
-        # token retrieval not available on the instance), reset token to
-        # allow safe failover to non-token mode
-        @token = nil
-      end
-    end
-
     def _metadata_disabled?
-      flag = ENV["AWS_EC2_METADATA_DISABLED"]
-      !flag.nil? && flag.downcase == "true"
+      ENV.fetch('AWS_EC2_METADATA_DISABLED', 'false').downcase == 'true'
     end
 
     def open_connection
@@ -164,64 +160,54 @@ module Aws
     end
 
     # GET request fetch profile and credentials
-    def http_get(connection, path, token=nil)
-      headers = {"User-Agent" => "aws-sdk-ruby2/#{VERSION}"}
-      headers["x-aws-ec2-metadata-token"] = token if token
+    def http_get(connection, path, token = nil)
+      headers = { 'User-Agent' => "aws-sdk-ruby3/#{CORE_GEM_VERSION}" }
+      headers['x-aws-ec2-metadata-token'] = token if token
       response = connection.request(Net::HTTP::Get.new(path, headers))
-      case response.code.to_i
-      when 200
-        response.body
-      when 401
-        raise TokenExpiredError
-      else
-        raise Non200Response
-      end
+      raise Non200Response unless response.code.to_i == 200
+
+      response.body
     end
 
     # PUT request fetch token with ttl
     def http_put(connection, path, ttl)
       headers = {
-        "User-Agent" => "aws-sdk-ruby2/#{VERSION}",
-        "x-aws-ec2-metadata-token-ttl-seconds" => ttl.to_s
+        'User-Agent' => "aws-sdk-ruby3/#{CORE_GEM_VERSION}",
+        'x-aws-ec2-metadata-token-ttl-seconds' => ttl.to_s
       }
       response = connection.request(Net::HTTP::Put.new(path, headers))
       case response.code.to_i
       when 200
         [
           response.body,
-          response.header["x-aws-ec2-metadata-token-ttl-seconds"].to_i
+          response.header['x-aws-ec2-metadata-token-ttl-seconds'].to_i
         ]
       when 400
         raise TokenRetrivalError
-      when 403
-      when 404
-      when 405
-        raise TokenRetrivalUnavailableError
+      when 401
+        raise TokenExpiredError
       else
         raise Non200Response
       end
     end
 
-    def retry_errors(error_classes, options = {}, &block)
+    def retry_errors(error_classes, options = {}, &_block)
       max_retries = options[:max_retries]
       retries = 0
       begin
         yield
       rescue *error_classes
-        if retries < max_retries
-          @backoff.call(retries)
-          retries += 1
-          retry
-        else
-          raise
-        end
+        raise unless retries < max_retries
+
+        @backoff.call(retries)
+        retries += 1
+        retry
       end
     end
 
     # @api private
     # Token used to fetch IMDS profile and credentials
     class Token
-
       def initialize(value, ttl)
         @ttl = ttl
         @value = value
@@ -234,8 +220,6 @@ module Aws
       def expired?
         Time.now - @created_time > @ttl
       end
-
     end
-
   end
 end

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

@@ -1,35 +1,30 @@
 require 'json'
+require_relative 'json/builder'
+require_relative 'json/error_handler'
+require_relative 'json/handler'
+require_relative 'json/parser'
 
 module Aws
   # @api private
   module Json
-
-    autoload :Builder, 'aws-sdk-core/json/builder'
-    autoload :ErrorHandler, 'aws-sdk-core/json/error_handler'
-    autoload :Handler, 'aws-sdk-core/json/handler'
-    autoload :Parser, 'aws-sdk-core/json/parser'
-
     class ParseError < StandardError
-
       def initialize(error)
         @error = error
         super(error.message)
       end
 
       attr_reader :error
-
     end
 
     class << self
-
       def load(json)
         ENGINE.load(json, *ENGINE_LOAD_OPTIONS)
-      rescue ENGINE_ERROR => e
-        raise ParseError.new(e)
+      rescue *ENGINE_ERRORS => e
+        raise ParseError, e
       end
 
       def load_file(path)
-        self.load(File.open(path, 'r', encoding: 'UTF-8') { |f| f.read })
+        load(File.open(path, 'r', encoding: 'UTF-8', &:read))
       end
 
       def dump(value)
@@ -40,28 +35,31 @@ module Aws
 
       def oj_engine
         require 'oj'
-        [Oj, [{mode: :compat, symbol_keys: false}], [{ mode: :compat }], oj_parse_error]
+        [
+          Oj,
+          [{ mode: :compat, symbol_keys: false }],
+          [{ mode: :compat }],
+          oj_parse_error
+        ]
       rescue LoadError
         false
       end
 
       def json_engine
-        [JSON, [], [], JSON::ParserError]
+        [JSON, [], [], [JSON::ParserError]]
       end
 
       def oj_parse_error
         if Oj.const_defined?('ParseError')
-          Oj::ParseError
+          [Oj::ParseError, EncodingError, JSON::ParserError]
         else
-          SyntaxError
+          [SyntaxError]
         end
       end
-
     end
 
     # @api private
-    ENGINE, ENGINE_LOAD_OPTIONS, ENGINE_DUMP_OPTIONS, ENGINE_ERROR =
+    ENGINE, ENGINE_LOAD_OPTIONS, ENGINE_DUMP_OPTIONS, ENGINE_ERRORS =
       oj_engine || json_engine
-
   end
 end

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

@@ -56,9 +56,11 @@ module Aws
       end
 
       def timestamp(ref, value)
-        if ref['timestampFormat'] == 'iso8601'
-          value.utc.iso8601
+        case ref['timestampFormat'] || ref.shape['timestampFormat']
+        when 'iso8601' then value.utc.iso8601
+        when 'rfc822' then value.utc.httpdate
         else
+          # rest-json and jsonrpc default to unixTimestamp
           value.to_i
         end
       end

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

@@ -17,9 +17,10 @@ module Aws
         json = Json.load(body)
         code = error_code(json, context)
         message = error_message(code, json)
-        [code, message]
+        data = parse_error_data(context, code)
+        [code, message, data]
       rescue Json::ParseError
-        [http_status_error_code(context), '']
+        [http_status_error_code(context), '', EmptyStructure.new]
       end
 
       def error_code(json, context)
@@ -41,6 +42,22 @@ module Aws
         end
       end
 
+      def parse_error_data(context, 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]/, '')
+            if match && rule.shape.members.any?
+              data = Parser.new(rule).parse(context.http_response.body_contents)
+            end
+          end
+        end
+        data
+      end
+
     end
   end
 end

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

@@ -38,10 +38,29 @@ module Aws
       def parse_body(context)
         if simple_json?(context)
           Json.load(context.http_response.body_contents)
-        else
-          rules = context.operation.output
+        elsif rules = context.operation.output
           json = context.http_response.body_contents
-          Parser.new(rules).parse(json == '' ? '{}' : json)
+          if json.is_a?(Array)
+            # an array of emitted events
+            if json[0].respond_to?(:response)
+              # initial response exists
+              # it must be the first event arrived
+              resp_struct = json.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}=", json.to_enum)
+              end
+            end
+            resp_struct
+          else
+            Parser.new(rules).parse(json == '' ? '{}' : json)
+          end
+        else
+          EmptyStructure.new
         end
       end