aws-sdk-core 3.191.0 → 3.199.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc07663afa282f94e8d7f48f837cb98da7041095d4e317435c12e78ea150ad37
-  data.tar.gz: 3b7de307550bb34cf2751a48ffc58015c0cdd699706cdfed8c167f28b2ff483a
+  metadata.gz: d895f327aaebb1d2a4a50f3fd1c4e76e36104438bbf02f6d04399480561b4ef8
+  data.tar.gz: a060bd7053cb741fed767a7e71033dee9c8dd1dfd96fe31e4fa2d8525c0c61f9
 SHA512:
-  metadata.gz: 283d65ac79f93a3ab22b34bc488d0d1a3fb706184a6efae14246973cc44cd2a0256987d10b75da5358a1fc0ac6ca24cea223ddbb27846da47c3af7a535a5f374
-  data.tar.gz: 4951a75c31b534cc58a9e29a9f56e5228786f4e02f959fd74dba42079e7e86f51f9aa87947acd9d7fcb8f3efad6d8318f92f6e7eb271aa6b8c6e14af1e5a5920
+  metadata.gz: 4f91a98d16fc772e4ea6500b6ae6cbc1440666d7adee2bbbe2ed2f3fc5b9bae3ddfc31434c61ba01f109555a17730d0ff2429d5268e39c90eac91e9bb1cf40bc
+  data.tar.gz: c5f0a55469f8b2800ba5b380da353cee13e4e876174cb1e1c0959c192ae1281379074255fc095f64cfa3ef1fd2d7926a74b681523256e28e2b42c2019bffe498

data/CHANGELOG.md

@@ -1,6 +1,158 @@
 Unreleased Changes
 ------------------
 
+3.199.0 (2024-06-25)
+------------------
+
+* Feature - Support RpcV2 protocol.
+
+* Feature - Add CBOR encoder and decoder.
+
+* Issue - Enhance, refactor, and rebase protocols to be consistent. Ensure protocol tests are run for each engine.
+
+3.198.0 (2024-06-24)
+------------------
+
+* Feature - Updated Aws::STS::Client with the latest API changes.
+
+* Feature - Updated Aws::SSOOIDC::Client with the latest API changes.
+
+* Feature - Updated Aws::SSO::Client with the latest API changes.
+
+* Feature - Support `:plugins` option on all Clients or using `Aws.config[:plugins]`.
+
+3.197.2 (2024-06-20)
+------------------
+
+* Issue - fix issue in Endpoint `attr` matcher when path is only an array index.
+
+* Issue - Fix trailing slash in endpoint URLs for rest-json and rest-xml services.
+
+3.197.1 (2024-06-19)
+------------------
+
+* Issue - Support an array of string arguments for `Aws::ProcessCredentials` to be executed by `system`.
+
+3.197.0 (2024-06-05)
+------------------
+
+* Issue - Ensure no UTC offset when deserializing `iso8601` timestamp format values.
+
+* Feature - Bump User Agent to version 2.1 to track business metrics. This changes the User Agent plugin order to be just before sending.
+
+3.196.1 (2024-05-14)
+------------------
+
+* Issue - Fix `ConnectionPool` for `.empty!` and `.clear!` since it prevented adding a new key from being added to the pool (#3020).
+
+3.196.0 (2024-05-13)
+------------------
+
+* Feature - Updated Aws::STS::Client with the latest API changes.
+
+* Feature - Updated Aws::SSOOIDC::Client with the latest API changes.
+
+* Feature - Updated Aws::SSO::Client with the latest API changes.
+
+3.195.0 (2024-05-10)
+------------------
+
+* Feature - Updated Aws::SSOOIDC::Client with the latest API changes.
+
+* Feature - Updated request parameters for PKCE support.
+
+3.194.2 (2024-05-07)
+------------------
+
+* Issue - Fix issue where `ConnectionPool` size iteration would prevent a new key from being added to the pool.
+
+3.194.1 (2024-05-03)
+------------------
+
+* Issue - Update EC2 protocol to not serialize empty lists.
+
+3.194.0 (2024-04-30)
+------------------
+
+* Feature - Add an API private cache for S3 Express and Access Grants.
+
+3.193.0 (2024-04-25)
+------------------
+
+* Feature - Updated Aws::STS::Client with the latest API changes.
+
+* Feature - Updated Aws::SSOOIDC::Client with the latest API changes.
+
+* Feature - Updated Aws::SSO::Client with the latest API changes.
+
+* Issue - Update event stream documentation.
+* Issue - Move `InvocationId` plugin to all clients.
+* Issue - Handle event streaming content-sha256 header in the signer plugin.
+* Issue - Add the event stream content type to initial requests.
+* Issue - Fix `standard` and `adaptive` retry mode for event streams.
+* Issue - Add `authority` to http2 headers.
+* Issue - Do not treat single members in event stream structures as implicit payloads.
+* Issue - Do not wait for initial response headers to start sending input events.
+
+3.192.1 (2024-04-18)
+------------------
+
+* Issue - Drop key/value pair if value is `nil` when deserializing json maps.
+
+3.192.0 (2024-04-16)
+------------------
+
+* Feature - Updated Aws::STS::Client with the latest API changes.
+
+* Feature - Update serializing/deserializing for all protocols to align with Smithy protocol-tests.
+* Issue - Allow `nil` values in lists and maps.
+* Issue - Populate headers for XML and JSON error responses.
+* Issue - Support fractional seconds when parsing `DateTime` timestamps.
+* Issue - Correctly serialize flattened lists for Query protocol.
+* Issue - Correctly serialize payload name in Rest-XML requests.
+* Issue - Fix an issue where Rest-XML requests do not have a default `Content-Type` header applied.
+* Issue - Apply appropriate `Content-Type` header for payloads in Rest services.
+* Issue - Correctly serialize URI label bindings in Rest requests.
+* Issue - Correctly serialize and parse header bindings in Rest services.
+* Issue - Ensure that null and empty headers are not sent in Rest requests.
+* Issue - Ensure keys in query maps do not override modeled keys in Rest requests.
+* Issue - Ensure empty blob payloads are omitted in Rest requests.
+* Issue - Support parsing of `NaN`, `Infinity` and `-Infinity` float values.
+* Issue - Apply appropriate `xmlName` for flattened lists and maps in Rest-XML services.
+* Issue - Handle serializing of different formats of `xmlNamespace` on shapes.
+* Issue - Fix deserializing of an empty blob to produce an empty string.
+* Issue - Fix deserializing an empty self-closed blob to produce an empty string.
+* Issue - Support parsing of different formats of error data in Rest-XML services.
+
+3.191.6 (2024-04-02)
+------------------
+* Issue - Performance optimization: ensure presence and order of instance variables in `PluginOptions` (#3002).
+
+3.191.5 (2024-03-26)
+------------------
+
+* Issue - Fix `EC2Metadata` and `InstanceProfileCredentials` to respect the port from a configured endpoint from code, ENV, or shared config.
+
+3.191.4 (2024-03-15)
+------------------
+
+* Issue - Ensure output unions work correctly with stub_responses.
+
+3.191.3 (2024-02-20)
+------------------
+
+* Issue - Remove base64 as dependency.
+
+3.191.2 (2024-02-14)
+------------------
+
+* Issue - Add base64 as dependency to prepare for Ruby 3.4 release (#2984).
+
+3.191.1 (2024-02-07)
+------------------
+
+* Issue - Warn on previously silent credential failures (#2981).
+
 3.191.0 (2024-01-26)
 ------------------
 
@@ -10,7 +162,7 @@ Unreleased Changes
 
 * Feature - Updated Aws::SSO::Client with the latest API changes.
 
-* Feature - Add RBS signature files to support static type checking.
+* Feature - Add RBS signature files to support static type checking
 
 3.190.3 (2024-01-16)
 ------------------

data/VERSION

@@ -1 +1 @@
-3.191.0
+3.199.0

data/lib/aws-sdk-core/binary/decode_handler.rb

@@ -22,22 +22,16 @@ module Aws
       end
 
       def attach_eventstream_listeners(context, rules)
-
         context.http_response.on_headers(200) do
-          protocol = context.config.api.metadata['protocol']
-          output_handler = context[:output_event_stream_handler] || context[:event_stream_handler]
+          output_handler = context[:output_event_stream_handler] ||
+                           context[:event_stream_handler]
           context.http_response.body = EventStreamDecoder.new(
-            protocol,
+            context.config.protocol,
             rules,
             context.operation.output,
             context.operation.errors,
             context.http_response.body,
             output_handler)
-          if input_emitter = context[:input_event_emitter]
-            # #emit will be blocked until 200 success
-            # see Aws::EventEmitter#emit
-            input_emitter.signal_queue << "ready"
-          end
         end
 
         context.http_response.on_success(200) do

data/lib/aws-sdk-core/binary/encode_handler.rb

@@ -10,7 +10,7 @@ module Aws
         if eventstream_member = eventstream_input?(context)
           input_es_handler = context[:input_event_stream_handler]
           input_es_handler.event_emitter.encoder = EventStreamEncoder.new(
-            context.config.api.metadata['protocol'],
+            context.config.protocol,
             eventstream_member,
             context.operation.input,
             signer_for(context)

data/lib/aws-sdk-core/binary/event_builder.rb

@@ -42,41 +42,39 @@ module Aws
           end
         end
 
-        # implict payload
-        if !explicit_payload && !implicit_payload_members.empty?
-          if implicit_payload_members.size > 1
-            payload_shape = Shapes::StructureShape.new
-            implicit_payload_members.each do |m_name, m_ref|
-              payload_shape.add_member(m_name, m_ref)
-            end
-            payload_ref = Shapes::ShapeRef.new(shape: payload_shape)
-
-            payload = build_payload_members(payload_ref, params)
-          else
-            m_name, m_ref = implicit_payload_members.first
-            streaming, content_type = _content_type(m_ref.shape)
-
-            es_headers[":content-type"] = Aws::EventStream::HeaderValue.new(
-              type: "string", value: content_type)
-            payload = _build_payload(streaming, m_ref, params[m_name])
-          end
-        end
-
-
+        # handle header members for all cases
         event_ref.shape.members.each do |member_name, member_ref|
           if member_ref.eventheader && params[member_name]
             header_value = params[member_name]
             es_headers[member_ref.shape.name] = Aws::EventStream::HeaderValue.new(
-              type: _header_value_type(member_ref.shape, header_value),
+              type: header_value_type(member_ref.shape, header_value),
               value: header_value
             )
-          elsif member_ref.eventpayload && params[member_name]
-            # explicit payload
-            streaming, content_type = _content_type(member_ref.shape)
+          end
+        end
+
+        # implict payload
+        if !explicit_payload && !implicit_payload_members.empty?
+          payload_shape = StructureShape.new
+          implicit_payload_members.each do |m_name, m_ref|
+            payload_shape.add_member(m_name, m_ref)
+          end
+          payload_ref = ShapeRef.new(shape: payload_shape)
 
-            es_headers[":content-type"] = Aws::EventStream::HeaderValue.new(
-              type: "string", value: content_type)
-            payload = _build_payload(streaming, member_ref, params[member_name])
+          payload = build_payload_members(payload_ref, params)
+                      .force_encoding(Encoding::BINARY)
+
+
+          es_headers[":content-type"] = Aws::EventStream::HeaderValue.new(
+            type: "string", value: content_type(payload_ref.shape))
+        else
+          # explicit payload, serialize just the payload member
+          event_ref.shape.members.each do |member_name, member_ref|
+            if member_ref.eventpayload && params[member_name]
+              es_headers[":content-type"] = Aws::EventStream::HeaderValue.new(
+                type: "string", value: content_type(member_ref.shape))
+              payload = params[member_name]
+            end
           end
         end
 
@@ -86,15 +84,15 @@ module Aws
         )
       end
 
-      def _content_type(shape)
+      def content_type(shape)
         case shape
-        when BlobShape then [true, "application/octet-stream"]
-        when StringShape then [true, "text/plain"]
+        when BlobShape then "application/octet-stream"
+        when StringShape then "text/plain"
         when StructureShape then
           if @serializer_class.name.include?('Xml')
-            [false, "text/xml"]
+            "text/xml"
           elsif @serializer_class.name.include?('Json')
-            [false, "application/json"]
+            "application/json"
           end
         else
           raise Aws::Errors::EventStreamBuilderError.new(
@@ -102,7 +100,7 @@ module Aws
         end
       end
 
-      def _header_value_type(shape, value)
+      def header_value_type(shape, value)
         case shape
         when StringShape then "string"
         when IntegerShape then "integer"
@@ -115,10 +113,9 @@ module Aws
         end
       end
 
-      def _build_payload(streaming, ref, value)
-        streaming ? value : @serializer_class.new(ref).serialize(value)
+      def build_payload_members(payload_ref, params)
+        @serializer_class.new(payload_ref).serialize(params)
       end
-
     end
   end
 end

data/lib/aws-sdk-core/binary/event_stream_decoder.rb

@@ -47,6 +47,7 @@ module Aws
         when 'rest-xml' then Aws::Xml::Parser
         when 'rest-json' then Aws::Json::Parser
         when 'json' then Aws::Json::Parser
+        when 'smithy-rpc-v2-cbor' then Aws::RpcV2::Parser
         else raise "unsupported protocol #{protocol} for event stream"
         end
       end

data/lib/aws-sdk-core/binary/event_stream_encoder.rb

@@ -43,9 +43,10 @@ module Aws
 
       def serializer_class(protocol)
         case protocol
-        when 'rest-xml' then Xml::Builder
-        when 'rest-json' then Json::Builder
-        when 'json' then Json::Builder
+        when 'rest-xml' then Aws::Xml::Builder
+        when 'rest-json' then Aws::Json::Builder
+        when 'json' then Aws::Json::Builder
+        when 'smithy-rpc-v2-cbor' then Aws::RpcV2::Builder
         else raise "unsupported protocol #{protocol} for event stream"
         end
       end

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

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

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

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+module Aws
+  module Cbor
+    # Pure Ruby implementation of CBOR Decoder
+    class Decoder
+      def initialize(bytes)
+        @buffer = bytes
+        @pos = 0
+      end
+
+      def decode
+        return nil if @buffer.nil? || @buffer.empty?
+
+        val = decode_item
+        return val unless @pos != @buffer.size
+
+        raise ExtraBytesError.new(@pos, @buffer.size)
+      end
+
+      private
+
+      FIVE_BIT_MASK = 0x1F
+      TAG_TYPE_EPOCH = 1
+      TAG_TYPE_BIGNUM = 2
+      TAG_TYPE_NEG_BIGNUM = 3
+      TAG_TYPE_BIGDEC = 4
+
+      # high level, generic decode. Based on the next type. Consumes and returns
+      # the next item as a ruby object.
+      def decode_item
+        case (next_type = peek_type)
+        when :array
+          read_array.times.map { decode_item }
+        when :map
+          read_map.times.map { [read_string, decode_item] }.to_h
+        when :indefinite_array
+          read_start_indefinite_array
+          value = []
+          value << decode_item until peek_type == :break_stop_code
+          read_end_indefinite_collection
+          value
+        when :indefinite_map
+          read_start_indefinite_map
+          value = {}
+          value[read_string] = decode_item until peek_type == :break_stop_code
+          read_end_indefinite_collection
+          value
+        when :indefinite_binary_string
+          read_info
+          value = String.new
+          value << read_binary_string until peek_type == :break_stop_code
+          read_end_indefinite_collection
+          value
+        when :indefinite_string
+          read_info
+          value = String.new
+          value << read_string until peek_type == :break_stop_code
+          read_end_indefinite_collection
+          value.force_encoding(Encoding::UTF_8)
+        when :tag
+          case (tag = read_tag)
+          when TAG_TYPE_EPOCH
+            type = peek_type
+            item = decode_item
+            item /= 1000.0 if type == :integer
+            Time.at(item)
+          when TAG_TYPE_BIGNUM, TAG_TYPE_NEG_BIGNUM
+            read_bignum(tag)
+          when TAG_TYPE_BIGDEC
+            read_big_decimal
+          else
+            Tagged.new(tag, decode_item)
+          end
+        when :break_stop_code
+          raise UnexpectedBreakCodeError
+        else
+          send("read_#{next_type}")
+        end
+      end
+
+      # low level streaming interface
+      def peek_type
+        ib = peek(1).ord
+        add_info = ib & FIVE_BIT_MASK
+        major_type = ib >> 5
+        case major_type
+        when 0, 1 then :integer
+        when 2
+          add_info == 31 ? :indefinite_binary_string : :binary_string
+        when 3
+          add_info == 31 ? :indefinite_string : :string
+        when 4
+          add_info == 31 ? :indefinite_array : :array
+        when 5
+          add_info == 31 ? :indefinite_map : :map
+        when 6 then :tag
+        when 7 # simple or float
+          case add_info
+          when 20, 21 then :boolean
+          when 22 then :nil
+          when 23 then :undefined # for smithy, this should be parsed as nil
+          when 25 then :half
+          when 26 then :float
+          when 27 then :double
+          when 31 then :break_stop_code
+          else
+            :reserved_undefined
+          end
+        end
+      end
+
+      def read_break_stop_code
+        read_info
+        :break_stop_code
+      end
+
+      def read_integer
+        major_type, add_info = read_info
+
+        val = read_count(add_info)
+        case major_type
+        when 0 then val
+        when 1 then -1 - val
+        else
+          raise Error,
+                "Expected Integer (0,1) got major type: #{major_type}"
+        end
+      end
+
+      def read_binary_string
+        _major_type, add_info = read_info
+        take(read_count(add_info)).force_encoding(Encoding::BINARY)
+      end
+
+      def read_string
+        _major_type, add_info = read_info
+        take(read_count(add_info)).force_encoding(Encoding::UTF_8)
+      end
+
+      # returns only the length of the array, caller must read the correct number of values after this
+      def read_array
+        _major_type, add_info = read_info
+        read_count(add_info)
+      end
+
+      # returns nothing but consumes and checks the type/info.
+      # Caller must keep reading until encountering the stop sequence
+      def read_start_indefinite_array
+        read_info
+      end
+
+      # returns nothing but consumes and checks the type/info.
+      # Caller must keep reading until encountering the stop sequence
+      def read_start_indefinite_map
+        read_info
+      end
+
+      # returns nothing but consumes and checks the type/info.
+      def read_end_indefinite_collection
+        read_info
+      end
+
+      # returns only the length of the array, caller must read the correct number of key value pairs after this
+      def read_map
+        _major_type, add_info = read_info
+        read_count(add_info)
+      end
+
+      # returns only the tag, caller must interpret the tag and read another value as appropriate
+      def read_tag
+        _major_type, add_info = read_info
+        read_count(add_info)
+      end
+
+      def read_reserved_undefined
+        _major_type, add_info = read_info
+        raise Error,
+          "Undefined reserved additional information: #{add_info}"
+      end
+
+      def read_boolean
+        _major_type, add_info = read_info
+        case add_info
+        when 20 then false
+        when 21 then true
+        else
+          raise Error,
+                'Invalid Boolean simple type, expected add_info of 20 or 21, ' \
+                 "got: #{add_info}"
+        end
+      end
+
+      def read_nil
+        read_info
+        nil
+      end
+
+      def read_undefined
+        read_info
+        :undefined
+      end
+
+      # 16 bit IEEE 754 half-precision floats
+      # Support decoding only
+      # format:
+      # sign - 1 bit
+      # exponent - 5 bits
+      # precision - 10 bits
+      def read_half
+        read_info
+        b16 = take(2).unpack1('n')
+        exp = (b16 >> 10) & 0x1f
+        mant = b16 & 0x3ff
+        val =
+          case exp
+          when 0
+            Math.ldexp(mant, -24)
+          when 31
+            mant.zero? ? Float::INFINITY : Float::NAN
+          else
+            # exp bias is 15, but to use ldexp we divide by 1024 (2^10) to get
+            # exp-15-10
+            Math.ldexp(1024 + mant, exp - 25)
+          end
+        if (b16[15]).zero?
+          val
+        else
+          -val
+        end
+      end
+
+      def read_float
+        read_info
+        take(4).unpack1('g')
+      end
+
+      def read_double
+        read_info
+        take(8).unpack1('G')
+      end
+
+      # tag type 2 or 3
+      def read_bignum(tag_value)
+        _major_type, add_info = read_info
+        bstr = take(read_count(add_info))
+        v = bstr.bytes.inject(0) do |sum, b|
+          sum <<= 8
+          sum + b
+        end
+        case tag_value
+        when 2 then v
+        when 3 then -1 - v
+        else
+          raise Error,
+                'Invalid Tag value for BigNum, ' \
+                "expected 2 or 3, got: #{tag_value}"
+        end
+      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
+      # See: https://www.rfc-editor.org/rfc/rfc8949.html#name-decimal-fractions-and-bigfl
+      def read_big_decimal
+        unless (s = read_array) == 2
+          raise Error, "Expected array of length 2 but length is: #{s}"
+        end
+
+        e = read_integer
+        m = read_integer
+        BigDecimal(m) * (BigDecimal(10)**BigDecimal(e))
+      end
+
+      # return a tuple of major_type, add_info
+      def read_info
+        ib = take(1).ord
+        [ib >> 5, ib & FIVE_BIT_MASK]
+      end
+
+      def read_count(add_info)
+        case add_info
+        when 0..23 then add_info
+        when 24 then take(1).ord
+        when 25 then take(2).unpack1('n')
+        when 26 then take(4).unpack1('N')
+        when 27 then take(8).unpack1('Q>')
+        when 28 then take(16).unpack1('Q>')
+        when 29 then take(32).unpack1('Q>')
+        else raise UnexpectedAdditionalInformationError, add_info
+        end
+      end
+
+      def take(n_bytes)
+        opos = @pos
+        @pos += n_bytes
+
+        return @buffer[opos, n_bytes] if @pos <= @buffer.bytesize
+
+        raise OutOfBytesError.new(n_bytes, @buffer.bytesize - @pos)
+      end
+
+      def peek(n_bytes)
+        return @buffer[@pos, n_bytes] if (@pos + n_bytes) <= @buffer.bytesize
+
+        raise OutOfBytesError.new(n_bytes, @buffer.bytesize - @pos)
+      end
+    end
+  end
+end