aws-sdk-core 3.190.2 → 3.240.0

data/lib/aws-sdk-core/cbor/encoder.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Aws
+  module Cbor
+    # Pure ruby implementation of CBOR encoder.
+    class Encoder
+      def initialize
+        @buffer = String.new
+      end
+
+      # @return the encoded bytes in CBOR format for all added data
+      def bytes
+        @buffer
+      end
+
+      # generic method for adding generic Ruby data based on its type
+      def add(value)
+        case value
+        when BigDecimal then add_big_decimal(value)
+        when Integer then add_auto_integer(value)
+        when Numeric then add_auto_float(value)
+        when Symbol then add_string(value.to_s)
+        when true, false then add_boolean(value)
+        when nil then add_nil
+        when Tagged
+          add_tag(value.tag)
+          add(value.value)
+        when String
+          if value.encoding == Encoding::BINARY
+            add_byte_string(value)
+          else
+            add_string(value)
+          end
+        when Array
+          start_array(value.size)
+          value.each { |di| add(di) }
+        when Hash
+          start_map(value.size)
+          value.each do |k, v|
+            add(k)
+            add(v)
+          end
+        when Time
+          add_time(value)
+        else
+          raise UnknownTypeError, value
+        end
+        self
+      end
+
+      private
+
+      MAJOR_TYPE_UNSIGNED_INT = 0x00 # 000_00000 - Major Type 0 - unsigned int
+      MAJOR_TYPE_NEGATIVE_INT = 0x20 # 001_00000 - Major Type 1 - negative int
+      MAJOR_TYPE_BYTE_STR = 0x40 # 010_00000 - Major Type 2 (Byte String)
+      MAJOR_TYPE_STR = 0x60 # 011_00000 - Major Type 3 (Text String)
+      MAJOR_TYPE_ARRAY = 0x80 # 100_00000 - Major Type 4 (Array)
+      MAJOR_TYPE_MAP = 0xa0 # 101_00000 - Major Type 5 (Map)
+      MAJOR_TYPE_TAG = 0xc0 # 110_00000 - Major type 6 (Tag)
+      MAJOR_TYPE_SIMPLE = 0xe0 # 111_00000 - Major type 7 (111) + 5 bit 0
+
+      FLOAT_BYTES = 0xfa # 111_11010 - Major type 7 (Float) + value: 26
+      DOUBLE_BYTES = 0xfb # 111_ 11011 - Major type 7 (Float) + value: 26
+
+      # https://www.rfc-editor.org/rfc/rfc8949.html#tags
+      TAG_TYPE_EPOCH = 1
+      TAG_BIGNUM_BASE = 2
+      TAG_TYPE_BIGDEC = 4
+
+      MAX_INTEGER = 18_446_744_073_709_551_616 # 2^64
+
+      def head(major_type, value)
+        @buffer <<
+          case value
+          when 0...24
+            [major_type + value].pack('C') # 8-bit unsigned
+          when 0...256
+            [major_type + 24, value].pack('CC')
+          when 0...65_536
+            [major_type + 25, value].pack('Cn')
+          when 0...4_294_967_296
+            [major_type + 26, value].pack('CN')
+          when 0...MAX_INTEGER
+            [major_type + 27, value].pack('CQ>')
+          else
+            raise Error, "Value is too large to encode: #{value}"
+          end
+      end
+
+      # streaming style, lower level interface
+      def add_integer(value)
+        major_type =
+          if value.negative?
+            value = -1 - value
+            MAJOR_TYPE_NEGATIVE_INT
+          else
+            MAJOR_TYPE_UNSIGNED_INT
+          end
+        head(major_type, value)
+      end
+
+      def add_bignum(value)
+        major_type =
+          if value.negative?
+            value = -1 - value
+            MAJOR_TYPE_NEGATIVE_INT
+          else
+            MAJOR_TYPE_UNSIGNED_INT
+          end
+        s = bignum_to_bytes(value)
+        head(MAJOR_TYPE_TAG, TAG_BIGNUM_BASE + (major_type >> 5))
+        head(MAJOR_TYPE_BYTE_STR, s.bytesize)
+        @buffer << s
+      end
+
+      # A decimal fraction or a bigfloat is represented as a tagged array
+      # that contains exactly two integer numbers:
+      # an exponent e and a mantissa m
+      # decimal fractions are always represented with a base of 10
+      # See: https://www.rfc-editor.org/rfc/rfc8949.html#name-decimal-fractions-and-bigfl
+      def add_big_decimal(value)
+        if value.infinite? == 1
+          return add_float(value.infinite? * Float::INFINITY)
+        elsif value.nan?
+          return add_float(Float::NAN)
+        end
+
+        head(MAJOR_TYPE_TAG, TAG_TYPE_BIGDEC)
+        sign, digits, base, exp = value.split
+        # Ruby BigDecimal digits of XXX are used as 0.XXX, convert
+        exp = exp - digits.size
+        digits = sign * digits.to_i
+        start_array(2)
+        add_auto_integer(exp)
+        add_auto_integer(digits)
+      end
+
+      def add_auto_integer(value)
+        major_type =
+          if value.negative?
+            value = -1 - value
+            MAJOR_TYPE_NEGATIVE_INT
+          else
+            MAJOR_TYPE_UNSIGNED_INT
+          end
+
+        if value >= MAX_INTEGER
+          s = bignum_to_bytes(value)
+          head(MAJOR_TYPE_TAG, TAG_BIGNUM_BASE + (major_type >> 5))
+          head(MAJOR_TYPE_BYTE_STR, s.bytesize)
+          @buffer << s
+        else
+          head(major_type, value)
+        end
+      end
+
+      def add_float(value)
+        @buffer << [FLOAT_BYTES, value].pack('Cg') # single-precision
+      end
+
+      def add_double(value)
+        @buffer << [DOUBLE_BYTES, value].pack('CG') # double-precision
+      end
+
+      def add_auto_float(value)
+        if value.nan?
+          @buffer << FLOAT_BYTES << [value].pack('g')
+        else
+          ss = [value].pack('g') # single-precision
+          if ss.unpack1('g') == value
+            @buffer << FLOAT_BYTES << ss
+          else
+            @buffer << [DOUBLE_BYTES, value].pack('CG') # double-precision
+          end
+        end
+      end
+
+      def add_nil
+        head(MAJOR_TYPE_SIMPLE, 22)
+      end
+
+      def add_boolean(value)
+        value ? head(MAJOR_TYPE_SIMPLE, 21) : head(MAJOR_TYPE_SIMPLE, 20)
+      end
+
+      # Encoding MUST already be Encoding::BINARY
+      def add_byte_string(value)
+        head(MAJOR_TYPE_BYTE_STR, value.bytesize)
+        @buffer << value
+      end
+
+      def add_string(value)
+        value = value.encode(Encoding::UTF_8).force_encoding(Encoding::BINARY)
+        head(MAJOR_TYPE_STR, value.bytesize)
+        @buffer << value
+      end
+
+      # caller is responsible for adding length values
+      def start_array(length)
+        head(MAJOR_TYPE_ARRAY, length)
+      end
+
+      def start_indefinite_array
+        head(MAJOR_TYPE_ARRAY + 31, 0)
+      end
+
+      # caller is responsible for adding length key/value pairs
+      def start_map(length)
+        head(MAJOR_TYPE_MAP, length)
+      end
+
+      def start_indefinite_map
+        head(MAJOR_TYPE_MAP + 31, 0)
+      end
+
+      def end_indefinite_collection
+        # write the stop sequence
+        head(MAJOR_TYPE_SIMPLE + 31, 0)
+      end
+
+      def add_tag(tag)
+        head(MAJOR_TYPE_TAG, tag)
+      end
+
+      def add_time(value)
+        head(MAJOR_TYPE_TAG, TAG_TYPE_EPOCH)
+        epoch = value.to_f
+        add_double(epoch)
+      end
+
+      def bignum_to_bytes(value)
+        s = String.new
+        while value != 0
+          s << (value & 0xFF)
+          value >>= 8
+        end
+        s.reverse!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'cbor/encoder'
+require_relative 'cbor/decoder'
+
+module Aws
+  # @api private
+  module Cbor
+
+    # CBOR Tagged data (Major type 6).
+    # A Tag consists of a tag number and a value.
+    # In the extended generic data model, a tag number's definition
+    # describes the additional semantics conveyed with the tag number.
+    # # @!method initialize(*args)
+    #   @option args [Integer] :tag The tag number.
+    #   @option args [Object] :value The tag's content.
+    # @!attribute tag
+    #   The tag number.
+    #   @return [Integer]
+    # @!attribute value
+    #   The tag's content.
+    #   @return [Object]
+    Tagged = Struct.new(:tag, :value)
+
+    class Error < StandardError; end
+
+    class OutOfBytesError < Error
+      def initialize(n, left)
+        super("Out of bytes. Trying to read #{n} bytes but buffer contains only #{left}")
+      end
+    end
+
+    class UnknownTypeError < Error
+      def initialize(type)
+        super("Unable to encode #{type}")
+      end
+    end
+
+    class ExtraBytesError < Error
+      def initialize(pos, size)
+        super("Extra bytes follow after decoding item. Read #{pos} / #{size} bytes")
+      end
+    end
+
+    class UnexpectedBreakCodeError < Error; end
+
+    class UnexpectedAdditionalInformationError < Error
+      def initialize(add_info)
+        super("Unexpected additional information: #{add_info}")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Aws
+  # setup autoloading for ClientSideMonitoring module
+  module ClientSideMonitoring
+    autoload :RequestMetrics, 'aws-sdk-core/client_side_monitoring/request_metrics'
+    autoload :Publisher, 'aws-sdk-core/client_side_monitoring/publisher'
+  end
+end

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

@@ -15,29 +15,11 @@ module Aws
 
     # @api private
     def setup_stubbing
-      @stubs = {}
-      @stub_mutex = Mutex.new
       if Hash === @config.stub_responses
         @config.stub_responses.each do |operation_name, stubs|
           apply_stubs(operation_name, Array === stubs ? stubs : [stubs])
         end
       end
-
-      # When a client is stubbed allow the user to access the requests made
-      @api_requests = []
-
-      requests = @api_requests
-      requests_mutex = Mutex.new
-      self.handle do |context|
-        requests_mutex.synchronize do
-          requests << {
-            operation_name: context.operation_name,
-            params: context.params,
-            context: context
-          }
-        end
-        @handler.call(context)
-      end
     end
 
     # Configures what data / errors should be returned from the named operation
@@ -177,7 +159,7 @@ module Aws
     #   on a client that has not enabled response stubbing via
     #   `:stub_responses => true`.
     def stub_responses(operation_name, *stubs)
-      if config.stub_responses
+      if @config.stub_responses
         apply_stubs(operation_name, stubs.flatten)
       else
         msg = 'stubbing is not enabled; enable stubbing in the constructor '\
@@ -196,11 +178,13 @@ module Aws
     # @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
+      if @config.stub_responses
+        @config.api_requests_mutex.synchronize do
+          if options[:exclude_presign]
+            @config.api_requests.reject {|req| req[:context][:presigned_url] }
+          else
+            @config.api_requests
+          end
         end
       else
         msg = 'This method is only implemented for stubbed clients, and is '\
@@ -228,54 +212,44 @@ 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(config.api.operation(operation_name)).stub(data)
+      Stubbing::StubData.new(@config.api.operation(operation_name)).stub(data)
     end
 
     # @api private
     def next_stub(context)
       operation_name = context.operation_name.to_sym
-      stub = @stub_mutex.synchronize do
-        stubs = @stubs[operation_name] || []
+      stub = @config.stubs_mutex.synchronize do
+        stubs = @config.stubs[operation_name] || []
         case stubs.length
-        when 0 then default_stub(operation_name)
+        when 0 then stub_data(operation_name)
         when 1 then stubs.first
         else stubs.shift
         end
       end
-      Proc === stub ? convert_stub(operation_name, stub.call(context)) : stub
+      stub = convert_stub(operation_name, stub, context)
+      stub[:mutex] = Mutex.new
+      stub
     end
 
     private
 
-    def default_stub(operation_name)
-      stub = stub_data(operation_name)
-      http_response_stub(operation_name, stub)
+    def apply_stubs(operation_name, stubs)
+      @config.stubs_mutex.synchronize do
+        @config.stubs[operation_name.to_sym] = stubs
+      end
     end
 
     # This method converts the given stub data and converts it to a
     # HTTP response (when possible). This enables the response stubbing
     # plugin to provide a HTTP response that triggers all normal events
     # during response handling.
-    def apply_stubs(operation_name, stubs)
-      @stub_mutex.synchronize do
-        @stubs[operation_name.to_sym] = stubs.map do |stub|
-          convert_stub(operation_name, stub)
-        end
-      end
-    end
-
-    def convert_stub(operation_name, stub)
-      stub = case stub
-      when Proc then stub
+    def convert_stub(operation_name, stub, context)
+      case stub
+      when Proc then convert_stub(operation_name, stub.call(context), context)
       when Exception, Class then { error: stub }
       when String then service_error_stub(stub)
-      when Hash then http_response_stub(operation_name, stub)
-      else { data: stub }
+      else http_response_stub(operation_name, stub)
       end
-      if Hash === stub
-        stub[:mutex] = Mutex.new
-      end
-      stub
     end
 
     def service_error_stub(error_code)
@@ -299,21 +273,28 @@ module Aws
     end
 
     def data_to_http_resp(operation_name, data)
-      api = config.api
+      api = @config.api
       operation = api.operation(operation_name)
       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 'api-gateway' then Stubbing::Protocols::ApiGateway
-      else raise "unsupported protocol"
+      # Prioritize JSON over CBOR when CBOR is the configured protocol but both are supported. This is to match similar
+      # prioritization in service.rb code generation.
+      if @config.api.metadata['protocol'] == 'smithy-rpc-v2-cbor' && @config.api.metadata['protocols']&.include?('json')
+        return Stubbing::Protocols::Json.new
+      end
+
+      case @config.api.metadata['protocol']
+      when 'json'               then Stubbing::Protocols::Json
+      when 'rest-json'          then Stubbing::Protocols::RestJson
+      when 'rest-xml'           then Stubbing::Protocols::RestXml
+      when 'query'              then Stubbing::Protocols::Query
+      when 'ec2'                then Stubbing::Protocols::EC2
+      when 'smithy-rpc-v2-cbor' then Stubbing::Protocols::RpcV2
+      when 'api-gateway'        then Stubbing::Protocols::ApiGateway
+      else raise 'unsupported protocol'
       end.new
     end
   end

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

@@ -9,9 +9,13 @@ module Aws
     # @return [Time]
     attr_reader :expiration
 
+    # @api private
+    # Returns UserAgent metrics for credentials.
+    attr_accessor :metrics
+
     # @return [Boolean]
     def set?
-      !!credentials && credentials.set?
+      !!@credentials && @credentials.set?
     end
 
   end