localstack-core 4.8.2.dev2__py3-none-any.whl → 4.8.2.dev4__py3-none-any.whl

localstack/aws/protocol/serializer.py

@@ -14,27 +14,34 @@ The different protocols have many similarities. The class hierarchy is
 designed such that the serializers share as much logic as possible.
 The class hierarchy looks as follows:
 ::
-                                      ┌───────────────────┐
-                                      │ResponseSerializer │
-                                      └───────────────────┘
-                                          ▲    ▲      ▲
-                   ┌──────────────────────┘    │      └──────────────────┐
-      ┌────────────┴────────────┐ ┌────────────┴─────────────┐ ┌─────────┴────────────┐
-      │BaseXMLResponseSerializer│ │BaseRestResponseSerializer│ │JSONResponseSerializer│
-      └─────────────────────────┘ └──────────────────────────┘ └──────────────────────┘
-                         ▲    ▲             ▲             ▲              ▲
-  ┌──────────────────────┴─┐ ┌┴─────────────┴──────────┐ ┌┴──────────────┴──────────┐
-  │QueryResponseSerializer │ │RestXMLResponseSerializer│ │RestJSONResponseSerializer│
-  └────────────────────────┘ └─────────────────────────┘ └──────────────────────────┘
-              ▲
-   ┌──────────┴──────────┐
+                                     ┌────────────────────┐
+                                     │ ResponseSerializer │
+                                     └────────────────────┘
+                                           ▲    ▲    ▲
+                 ┌─────────────────┬───────┘    │    └──────────────┬──────────────────────┐
+    ┌────────────┴────────────┐    │    ┌───────┴──────────────┐    │         ┌────────────┴─────────────┐
+    │BaseXMLResponseSerializer│    │    │JSONResponseSerializer│    │         │BaseCBORResponseSerializer│
+    └─────────────────────────┘    │    └──────────────────────┘    │         └──────────────────────────┘
+       ▲    ▲        ┌─────────────┴────────────┐     ▲       ┌─────┴─────────────────────┐  ▲         ▲
+       │    │        │BaseRestResponseSerializer│     │       │BaseRpcV2ResponseSerializer│  │         │
+       │    │        └──────────────────────────┘     │       └───────────────────────────┘  │         │
+       │    │              ▲              ▲           │                          ▲           │         │
+       │    │              │              │           │                          │           │         │
+       │  ┌─┴──────────────┴────────┐  ┌──┴───────────┴───────────┐   ┌──────────┴───────────┴────┐    │
+       │  │RestXMLResponseSerializer│  │RestJSONResponseSerializer│   │RpcV2CBORResponseSerializer│    │
+       │  └─────────────────────────┘  └──────────────────────────┘   └───────────────────────────┘    │
+ ┌─────┴──────────────────┐                                                                 ┌──────────┴─────────────┐
+ │QueryResponseSerializer │                                                                 │ CBORResponseSerializer │
+ └────────────────────────┘                                                                 └────────────────────────┘
+             ▲
+   ┌─────────┴───────────┐
    │EC2ResponseSerializer│
    └─────────────────────┘
 ::
 
 The ``ResponseSerializer`` contains the logic that is used among all the
-different protocols (``query``, ``json``, ``rest-json``, ``rest-xml``, and
-``ec2``).
+different protocols (``query``, ``json``, ``rest-json``, ``rest-xml``, ``cbor``
+and ``ec2``).
 The protocols relate to each other in the following ways:
 
 * The ``query`` and the ``rest-xml`` protocols both have XML bodies in their
@@ -42,10 +49,14 @@ The protocols relate to each other in the following ways:
   type).
 * The ``json`` and the ``rest-json`` protocols both have JSON bodies in their
   responses which are serialized the same way.
+* The ``cbor`` protocol is not properly defined in the spec, but mirrors the
+  ``json`` protocol.
 * The ``rest-json`` and ``rest-xml`` protocols serialize some metadata in
-  the HTTP response's header fields
+  the HTTP response's header fields.
 * The ``ec2`` protocol is basically similar to the ``query`` protocol with a
   specific error response formatting.
+* The ``smithy-rpc-v2-cbor`` protocol defines a specific way to route request
+  to services via the RPC v2 trait, and encodes its body with the CBOR format.
 
 The serializer classes in this module correspond directly to the different
 protocols. ``#create_serializer`` shows the explicit mapping between the
@@ -54,13 +65,23 @@ The classes are structured as follows:
 
 * The ``ResponseSerializer`` contains all the basic logic for the
   serialization which is shared among all different protocols.
-* The ``BaseXMLResponseSerializer`` and the ``JSONResponseSerializer``
-  contain the logic for the XML and the JSON serialization respectively.
+* The ``BaseXMLResponseSerializer``, ``JSONResponseSerializer`` and
+  ``BaseCBORResponseSerializer`` contain the logic for the XML, JSON
+  and the CBOR serialization respectively.
 * The ``BaseRestResponseSerializer`` contains the logic for the REST
   protocol specifics (i.e. specific HTTP header serializations).
+* The ``BaseRpcV2ResponseSerializer`` contains the logic for the RPC v2
+  protocol specifics (i.e. pretty bare, does not has any specific
+  about body serialization).
 * The ``RestXMLResponseSerializer`` and the ``RestJSONResponseSerializer``
   inherit the ReST specific logic from the ``BaseRestResponseSerializer``
   and the XML / JSON body serialization from their second super class.
+* The ``RpcV2CBORResponseSerializer`` inherits the RPC v2 specific logic
+  from the ``BaseRpcV2ResponseSerializer`` and the CBOR body serialization
+  from its second super class.
+* The ``CBORResponseSerializer`` contains the logic specific to the
+  non-official ``cbor`` protocol, mirroring the ``json`` protocol but
+  with CBOR encoded body
 
 The services and their protocols are defined by using AWS's Smithy
 (a language to define services in a - somewhat - protocol-agnostic
@@ -73,21 +94,32 @@ be sent back to the calling client.
 
 import abc
 import base64
+import copy
+import datetime
 import functools
 import json
 import logging
+import math
 import string
+import struct
 from abc import ABC
 from binascii import crc32
 from collections.abc import Iterable, Iterator
-from datetime import datetime
 from email.utils import formatdate
 from struct import pack
-from typing import Any
+from typing import IO, Any
 from xml.etree import ElementTree as ETree
 
 import xmltodict
-from botocore.model import ListShape, MapShape, OperationModel, ServiceModel, Shape, StructureShape
+from botocore.model import (
+    ListShape,
+    MapShape,
+    OperationModel,
+    ServiceModel,
+    Shape,
+    StringShape,
+    StructureShape,
+)
 from botocore.serialize import ISO8601, ISO8601_MICRO
 from botocore.utils import calculate_md5, is_json_value_header, parse_to_aware_datetime
 
@@ -506,7 +538,7 @@ class ResponseSerializer(abc.ABC):
     # Some extra utility methods subclasses can use.
 
     @staticmethod
-    def _timestamp_iso8601(value: datetime) -> str:
+    def _timestamp_iso8601(value: datetime.datetime) -> str:
         if value.microsecond > 0:
             timestamp_format = ISO8601_MICRO
         else:
@@ -514,15 +546,17 @@ class ResponseSerializer(abc.ABC):
         return value.strftime(timestamp_format)
 
     @staticmethod
-    def _timestamp_unixtimestamp(value: datetime) -> float:
+    def _timestamp_unixtimestamp(value: datetime.datetime) -> float:
         return value.timestamp()
 
-    def _timestamp_rfc822(self, value: datetime) -> str:
-        if isinstance(value, datetime):
+    def _timestamp_rfc822(self, value: datetime.datetime) -> str:
+        if isinstance(value, datetime.datetime):
             value = self._timestamp_unixtimestamp(value)
         return formatdate(value, usegmt=True)
 
-    def _convert_timestamp_to_str(self, value: int | str | datetime, timestamp_format=None) -> str:
+    def _convert_timestamp_to_str(
+        self, value: int | str | datetime.datetime, timestamp_format=None
+    ) -> str:
         if timestamp_format is None:
             timestamp_format = self.TIMESTAMP_FORMAT
         timestamp_format = timestamp_format.lower()
@@ -1407,6 +1441,459 @@ class RestJSONResponseSerializer(BaseRestResponseSerializer, JSONResponseSeriali
             serialized.headers["Content-Type"] = mime_type
 
 
+class BaseCBORResponseSerializer(ResponseSerializer):
+    """
+    The ``BaseCBORResponseSerializer`` performs the basic logic for the CBOR response serialization.
+
+    There are two types of map/list in CBOR, indefinite length types and "defined" ones:
+    You can use the `\xbf` byte marker to indicate a map with indefinite length, then `\xff` to indicate the end
+     of the map.
+    You can also use, for example, `\xa4` to indicate a map with exactly 4 things in it, so `\xff` is not
+    required at the end.
+    AWS, for both Kinesis and `smithy-rpc-v2-cbor` services, is using indefinite data structures when returning
+    responses.
+    """
+
+    SUPPORTED_MIME_TYPES = [APPLICATION_CBOR, APPLICATION_AMZ_CBOR_1_1]
+
+    UNSIGNED_INT_MAJOR_TYPE = 0
+    NEGATIVE_INT_MAJOR_TYPE = 1
+    BLOB_MAJOR_TYPE = 2
+    STRING_MAJOR_TYPE = 3
+    LIST_MAJOR_TYPE = 4
+    MAP_MAJOR_TYPE = 5
+    TAG_MAJOR_TYPE = 6
+    FLOAT_AND_SIMPLE_MAJOR_TYPE = 7
+
+    INDEFINITE_ITEM_ADDITIONAL_INFO = 31
+    BREAK_CODE = b"\xff"
+    USE_INDEFINITE_DATA_STRUCTURE = True
+
+    def _serialize_data_item(
+        self, serialized: bytearray, value: Any, shape: Shape | None, name: str | None = None
+    ) -> None:
+        method = getattr(self, f"_serialize_type_{shape.type_name}")
+        if method is None:
+            raise ValueError(
+                f"Unrecognized C2J type: {shape.type_name}, unable to serialize request"
+            )
+        method(serialized, value, shape, name)
+
+    def _serialize_type_integer(
+        self, serialized: bytearray, value: int, shape: Shape | None, name: str | None = None
+    ) -> None:
+        if value >= 0:
+            major_type = self.UNSIGNED_INT_MAJOR_TYPE
+        else:
+            major_type = self.NEGATIVE_INT_MAJOR_TYPE
+            # The only differences in serializing negative and positive integers is
+            # that for negative, we set the major type to 1 and set the value to -1
+            # minus the value
+            value = -1 - value
+        additional_info, num_bytes = self._get_additional_info_and_num_bytes(value)
+        initial_byte = self._get_initial_byte(major_type, additional_info)
+        if num_bytes == 0:
+            serialized.extend(initial_byte)
+        else:
+            serialized.extend(initial_byte + value.to_bytes(num_bytes, "big"))
+
+    def _serialize_type_long(
+        self, serialized: bytearray, value: int, shape: Shape, name: str | None = None
+    ) -> None:
+        self._serialize_type_integer(serialized, value, shape, name)
+
+    def _serialize_type_blob(
+        self,
+        serialized: bytearray,
+        value: str | bytes | IO[bytes],
+        shape: Shape | None,
+        name: str | None = None,
+    ) -> None:
+        if isinstance(value, str):
+            value = value.encode("utf-8")
+        elif not isinstance(value, (bytes, bytearray)):
+            # We support file-like objects for blobs; these already have been
+            # validated to ensure they have a read method
+            value = value.read()
+        length = len(value)
+        additional_info, num_bytes = self._get_additional_info_and_num_bytes(length)
+        initial_byte = self._get_initial_byte(self.BLOB_MAJOR_TYPE, additional_info)
+        if num_bytes == 0:
+            serialized.extend(initial_byte)
+        else:
+            serialized.extend(initial_byte + length.to_bytes(num_bytes, "big"))
+        serialized.extend(value)
+
+    def _serialize_type_string(
+        self, serialized: bytearray, value: str, shape: Shape | None, name: str | None = None
+    ) -> None:
+        encoded = value.encode("utf-8")
+        length = len(encoded)
+        additional_info, num_bytes = self._get_additional_info_and_num_bytes(length)
+        initial_byte = self._get_initial_byte(self.STRING_MAJOR_TYPE, additional_info)
+        if num_bytes == 0:
+            serialized.extend(initial_byte + encoded)
+        else:
+            serialized.extend(initial_byte + length.to_bytes(num_bytes, "big") + encoded)
+
+    def _serialize_type_list(
+        self, serialized: bytearray, value: list, shape: Shape | None, name: str | None = None
+    ) -> None:
+        initial_bytes, closing_bytes = self._get_bytes_for_data_structure(
+            value, self.LIST_MAJOR_TYPE
+        )
+        serialized.extend(initial_bytes)
+
+        for item in value:
+            self._serialize_data_item(serialized, item, shape.member)
+
+        if closing_bytes is not None:
+            serialized.extend(closing_bytes)
+
+    def _serialize_type_map(
+        self, serialized: bytearray, value: dict, shape: Shape | None, name: str | None = None
+    ) -> None:
+        initial_bytes, closing_bytes = self._get_bytes_for_data_structure(
+            value, self.MAP_MAJOR_TYPE
+        )
+        serialized.extend(initial_bytes)
+
+        for key_item, item in value.items():
+            self._serialize_data_item(serialized, key_item, shape.key)
+            self._serialize_data_item(serialized, item, shape.value)
+
+        if closing_bytes is not None:
+            serialized.extend(closing_bytes)
+
+    def _serialize_type_structure(
+        self, serialized: bytearray, value: dict, shape: Shape | None, name: str | None = None
+    ) -> None:
+        if name is not None:
+            # For nested structures, we need to serialize the key first
+            self._serialize_data_item(serialized, name, shape.key_shape)
+
+        # Remove `None` values from the dictionary
+        value = {k: v for k, v in value.items() if v is not None}
+
+        initial_bytes, closing_bytes = self._get_bytes_for_data_structure(
+            value, self.MAP_MAJOR_TYPE
+        )
+        serialized.extend(initial_bytes)
+
+        members = shape.members
+        for member_key, member_value in value.items():
+            member_shape = members[member_key]
+            if "name" in member_shape.serialization:
+                member_key = member_shape.serialization["name"]
+            if member_value is not None:
+                self._serialize_type_string(serialized, member_key, None, None)
+                self._serialize_data_item(serialized, member_value, member_shape)
+
+        if closing_bytes is not None:
+            serialized.extend(closing_bytes)
+
+    def _serialize_type_timestamp(
+        self,
+        serialized: bytearray,
+        value: int | str | datetime.datetime,
+        shape: Shape | None,
+        name: str | None = None,
+    ) -> None:
+        # https://smithy.io/2.0/additional-specs/protocols/smithy-rpc-v2.html#timestamp-type-serialization
+        tag = 1  # Use tag 1 for unix timestamp
+        initial_byte = self._get_initial_byte(self.TAG_MAJOR_TYPE, tag)
+        serialized.extend(initial_byte)  # Tagging the timestamp
+
+        # we encode the timestamp as a double, like the Go SDK
+        # https://github.com/aws/aws-sdk-go-v2/blob/5d7c17325a2581afae4455c150549174ebfd9428/internal/protocoltest/smithyrpcv2cbor/serializers.go#L664-L669
+        # Currently, the Botocore serializer using unsigned integers, but it does not conform to the Smithy specs:
+        # > This protocol uses epoch-seconds, also known as Unix timestamps, with millisecond
+        # > (1/1000th of a second) resolution.
+        timestamp = float(self._convert_timestamp_to_str(value))
+        initial_byte = self._get_initial_byte(self.FLOAT_AND_SIMPLE_MAJOR_TYPE, 27)
+        serialized.extend(initial_byte + struct.pack(">d", timestamp))
+
+    def _serialize_type_float(
+        self, serialized: bytearray, value: float, shape: Shape | None, name: str | None = None
+    ) -> None:
+        if self._is_special_number(value):
+            serialized.extend(
+                self._get_bytes_for_special_numbers(value)
+            )  # Handle special values like NaN or Infinity
+        else:
+            initial_byte = self._get_initial_byte(self.FLOAT_AND_SIMPLE_MAJOR_TYPE, 26)
+            serialized.extend(initial_byte + struct.pack(">f", value))
+
+    def _serialize_type_double(
+        self, serialized: bytearray, value: float, shape: Shape | None, name: str | None = None
+    ) -> None:
+        if self._is_special_number(value):
+            serialized.extend(
+                self._get_bytes_for_special_numbers(value)
+            )  # Handle special values like NaN or Infinity
+        else:
+            initial_byte = self._get_initial_byte(self.FLOAT_AND_SIMPLE_MAJOR_TYPE, 27)
+            serialized.extend(initial_byte + struct.pack(">d", value))
+
+    def _serialize_type_boolean(
+        self, serialized: bytearray, value: bool, shape: Shape | None, name: str | None = None
+    ) -> None:
+        additional_info = 21 if value else 20
+        serialized.extend(self._get_initial_byte(self.FLOAT_AND_SIMPLE_MAJOR_TYPE, additional_info))
+
+    @staticmethod
+    def _get_additional_info_and_num_bytes(value: int) -> tuple[int, int]:
+        # Values under 24 can be stored in the initial byte and don't need further
+        # encoding
+        if value < 24:
+            return value, 0
+        # Values between 24 and 255 (inclusive) can be stored in 1 byte and
+        # correspond to additional info 24
+        elif value < 256:
+            return 24, 1
+        # Values up to 65535 can be stored in two bytes and correspond to additional
+        # info 25
+        elif value < 65536:
+            return 25, 2
+        # Values up to 4294967296 can be stored in four bytes and correspond to
+        # additional info 26
+        elif value < 4294967296:
+            return 26, 4
+        # The maximum number of bytes in a definite length data items is 8 which
+        # to additional info 27
+        else:
+            return 27, 8
+
+    def _get_initial_byte(self, major_type: int, additional_info: int) -> bytes:
+        # The highest order three bits are the major type, so we need to bitshift the
+        # major type by 5
+        major_type_bytes = major_type << 5
+        return (major_type_bytes | additional_info).to_bytes(1, "big")
+
+    @staticmethod
+    def _is_special_number(value: int | float) -> bool:
+        return any(
+            [
+                value == float("inf"),
+                value == float("-inf"),
+                math.isnan(value),
+            ]
+        )
+
+    def _get_bytes_for_special_numbers(self, value: int | float) -> bytes:
+        additional_info = 25
+        initial_byte = self._get_initial_byte(self.FLOAT_AND_SIMPLE_MAJOR_TYPE, additional_info)
+        if value == float("inf"):
+            return initial_byte + struct.pack(">H", 0x7C00)
+        elif value == float("-inf"):
+            return initial_byte + struct.pack(">H", 0xFC00)
+        elif math.isnan(value):
+            return initial_byte + struct.pack(">H", 0x7E00)
+
+    def _get_bytes_for_data_structure(
+        self, value: list | dict, major_type: int
+    ) -> tuple[bytes, bytes | None]:
+        if self.USE_INDEFINITE_DATA_STRUCTURE:
+            additional_info = self.INDEFINITE_ITEM_ADDITIONAL_INFO
+            return self._get_initial_byte(major_type, additional_info), self.BREAK_CODE
+        else:
+            length = len(value)
+            additional_info, num_bytes = self._get_additional_info_and_num_bytes(length)
+            initial_byte = self._get_initial_byte(major_type, additional_info)
+            if num_bytes != 0:
+                initial_byte = initial_byte + length.to_bytes(num_bytes, "big")
+
+            return initial_byte, None
+
+
+class CBORResponseSerializer(BaseCBORResponseSerializer):
+    """
+    The ``CBORResponseSerializer`` is responsible for the serialization of responses from services with the ``cbor``
+    protocol. It implements the CBOR response body serialization, which is only currently used by Kinesis and is derived
+    conceptually from the ``JSONResponseSerializer``
+    """
+
+    TIMESTAMP_FORMAT = "unixtimestamp"
+
+    def _serialize_error(
+        self,
+        error: ServiceException,
+        response: Response,
+        shape: StructureShape,
+        operation_model: OperationModel,
+        mime_type: str,
+        request_id: str,
+    ) -> None:
+        body = bytearray()
+        response.content_type = mime_type
+        response.headers["X-Amzn-Errortype"] = error.code
+
+        if shape:
+            # FIXME: we need to manually add the `__type` field to the shape as it is not part of the specs
+            #  think about a better way, this is very hacky
+            shape_copy = copy.deepcopy(shape)
+            shape_copy.members["__type"] = StringShape(
+                shape_name="__type", shape_model={"type": "string"}
+            )
+            remaining_params = {"__type": error.code}
+
+            for member_name in shape_copy.members:
+                if hasattr(error, member_name):
+                    remaining_params[member_name] = getattr(error, member_name)
+                # Default error message fields can sometimes have different casing in the specs
+                elif member_name.lower() in ["code", "message"] and hasattr(
+                    error, member_name.lower()
+                ):
+                    remaining_params[member_name] = getattr(error, member_name.lower())
+
+            self._serialize_data_item(body, remaining_params, shape_copy, None)
+
+        response.set_response(bytes(body))
+
+    def _serialize_response(
+        self,
+        parameters: dict,
+        response: Response,
+        shape: Shape | None,
+        shape_members: dict,
+        operation_model: OperationModel,
+        mime_type: str,
+        request_id: str,
+    ) -> None:
+        response.content_type = mime_type
+        response.set_response(
+            self._serialize_body_params(parameters, shape, operation_model, mime_type, request_id)
+        )
+
+    def _serialize_body_params(
+        self,
+        params: dict,
+        shape: Shape,
+        operation_model: OperationModel,
+        mime_type: str,
+        request_id: str,
+    ) -> bytes | None:
+        body = bytearray()
+        self._serialize_data_item(body, params, shape)
+        return bytes(body)
+
+    def _prepare_additional_traits_in_response(
+        self, response: Response, operation_model: OperationModel, request_id: str
+    ) -> Response:
+        response.headers["x-amzn-requestid"] = request_id
+        response = super()._prepare_additional_traits_in_response(
+            response, operation_model, request_id
+        )
+        return response
+
+
+class BaseRpcV2ResponseSerializer(ResponseSerializer):
+    """
+    The BaseRpcV2ResponseSerializer performs the basic logic for the RPC V2 response serialization.
+    The only variance between the various RPCv2 protocols is the way the body is serialized for regular responses,
+    and the way they will encode exceptions.
+    """
+
+    def _serialize_response(
+        self,
+        parameters: dict,
+        response: Response,
+        shape: Shape | None,
+        shape_members: dict,
+        operation_model: OperationModel,
+        mime_type: str,
+        request_id: str,
+    ) -> None:
+        response.content_type = mime_type
+        response.set_response(
+            self._serialize_body_params(parameters, shape, operation_model, mime_type, request_id)
+        )
+
+    def _serialize_body_params(
+        self,
+        params: dict,
+        shape: Shape,
+        operation_model: OperationModel,
+        mime_type: str,
+        request_id: str,
+    ) -> bytes | None:
+        raise NotImplementedError
+
+
+class RpcV2CBORResponseSerializer(BaseRpcV2ResponseSerializer, BaseCBORResponseSerializer):
+    """
+    The RpcV2CBORResponseSerializer implements the CBOR body serialization part for the RPC v2 protocol, and implements the
+    specific exception serialization.
+    https://smithy.io/2.0/additional-specs/protocols/smithy-rpc-v2.html
+    """
+
+    # the Smithy spec defines that only `application/cbor` is supported for RPC v2 CBOR
+    SUPPORTED_MIME_TYPES = [APPLICATION_CBOR]
+    TIMESTAMP_FORMAT = "unixtimestamp"
+
+    def _serialize_body_params(
+        self,
+        params: dict,
+        shape: Shape,
+        operation_model: OperationModel,
+        mime_type: str,
+        request_id: str,
+    ) -> bytes | None:
+        body = bytearray()
+        self._serialize_data_item(body, params, shape)
+        return bytes(body)
+
+    def _serialize_error(
+        self,
+        error: ServiceException,
+        response: Response,
+        shape: StructureShape,
+        operation_model: OperationModel,
+        mime_type: str,
+        request_id: str,
+    ) -> None:
+        body = bytearray()
+        response.content_type = mime_type  # can only be 'application/cbor'
+        # TODO: the Botocore parser is able to look at the `x-amzn-query-error` header for the RpcV2 CBOR protocol
+        #  we'll need to investigate which services need it
+        # Responses for the rpcv2Cbor protocol SHOULD NOT contain the X-Amzn-ErrorType header.
+        # Type information is always serialized in the payload. This is different than `json` protocol
+
+        if shape:
+            # FIXME: we need to manually add the `__type` field to the shape as it is not part of the specs
+            #  think about a better way, this is very hacky
+            # Error responses in the rpcv2Cbor protocol MUST be serialized identically to standard responses with one
+            # additional component to distinguish which error is contained: a body field named __type.
+            shape_copy = copy.deepcopy(shape)
+            shape_copy.members["__type"] = StringShape(
+                shape_name="__type", shape_model={"type": "string"}
+            )
+            remaining_params = {"__type": error.code}
+
+            for member_name in shape_copy.members:
+                if hasattr(error, member_name):
+                    remaining_params[member_name] = getattr(error, member_name)
+                # Default error message fields can sometimes have different casing in the specs
+                elif member_name.lower() in ["code", "message"] and hasattr(
+                    error, member_name.lower()
+                ):
+                    remaining_params[member_name] = getattr(error, member_name.lower())
+
+            self._serialize_data_item(body, remaining_params, shape_copy, None)
+
+        response.set_response(bytes(body))
+
+    def _prepare_additional_traits_in_response(
+        self, response: Response, operation_model: OperationModel, request_id: str
+    ):
+        response.headers["x-amzn-requestid"] = request_id
+        response.headers["Smithy-Protocol"] = "rpc-v2-cbor"
+        response = super()._prepare_additional_traits_in_response(
+            response, operation_model, request_id
+        )
+        return response
+
+
 class S3ResponseSerializer(RestXMLResponseSerializer):
     """
     The ``S3ResponseSerializer`` adds some minor logic to handle S3 specific peculiarities with the error response
@@ -1573,7 +2060,7 @@ class S3ResponseSerializer(RestXMLResponseSerializer):
         root.attrib["xmlns"] = self.XML_NAMESPACE
 
     @staticmethod
-    def _timestamp_iso8601(value: datetime) -> str:
+    def _timestamp_iso8601(value: datetime.datetime) -> str:
         """
         This is very specific to S3, S3 returns an ISO8601 timestamp but with milliseconds always set to 000
         Some SDKs are very picky about the length
@@ -1744,11 +2231,14 @@ def gen_amzn_requestid():
 
 
 @functools.cache
-def create_serializer(service: ServiceModel) -> ResponseSerializer:
+def create_serializer(
+    service: ServiceModel, protocol: ProtocolName | None = None
+) -> ResponseSerializer:
     """
     Creates the right serializer for the given service model.
 
     :param service: to create the serializer for
+    :param protocol: the protocol for the serializer. If not provided, fallback to the service's default protocol
     :return: ResponseSerializer which can handle the protocol of the service
     """
 
@@ -1768,17 +2258,25 @@ def create_serializer(service: ServiceModel) -> ResponseSerializer:
         "rest-json": RestJSONResponseSerializer,
         "rest-xml": RestXMLResponseSerializer,
         "ec2": EC2ResponseSerializer,
+        "smithy-rpc-v2-cbor": RpcV2CBORResponseSerializer,
+        # TODO: implement multi-protocol support for Kinesis, so that it can uses the `cbor` protocol and remove
+        #  CBOR handling from JSONResponseParser
+        # this is not an "official" protocol defined from the spec, but is derived from ``json``
     }
+    # TODO: even though our Service Name Parser will only use a protocol that is available for the service, we might
+    #  want to verify if the given protocol here is available for that service, in case we are manually calling
+    #  this factory. Revisit once we implement multi-protocol support
+    service_protocol = protocol or service.protocol
 
     # Try to select a service- and protocol-specific serializer implementation
     if (
         service.service_name in service_specific_serializers
-        and service.protocol in service_specific_serializers[service.service_name]
+        and service_protocol in service_specific_serializers[service.service_name]
     ):
-        return service_specific_serializers[service.service_name][service.protocol]()
+        return service_specific_serializers[service.service_name][service_protocol]()
     else:
         # Otherwise, pick the protocol-specific serializer for the protocol of the service
-        return protocol_specific_serializers[service.protocol]()
+        return protocol_specific_serializers[service_protocol]()
 
 
 def aws_response_serializer(

localstack/aws/spec.py

@@ -21,7 +21,7 @@ from localstack.utils.objects import singleton_factory
 LOG = logging.getLogger(__name__)
 
 ServiceName = str
-ProtocolName = Literal["query", "json", "rest-json", "rest-xml", "ec2"]
+ProtocolName = Literal["query", "json", "rest-json", "rest-xml", "ec2", "smithy-rpc-v2-cbor"]
 
 
 class ServiceModelIdentifier(NamedTuple):