localstack-core 4.6.1.dev60__py3-none-any.whl → 4.10.1.dev12__py3-none-any.whl

localstack/aws/protocol/service_router.py

@@ -1,14 +1,16 @@
 import logging
-from typing import NamedTuple, Optional, Set
+from typing import NamedTuple
 
 from botocore.model import ServiceModel
 from werkzeug.exceptions import RequestEntityTooLarge
 from werkzeug.http import parse_dict_header
 
 from localstack.aws.spec import (
+    ProtocolName,
     ServiceCatalog,
     ServiceModelIdentifier,
     get_service_catalog,
+    is_protocol_in_service_model_identifier,
 )
 from localstack.http import Request
 from localstack.services.s3.utils import uses_host_addressing
@@ -17,6 +19,23 @@ from localstack.utils.strings import to_bytes
 
 LOG = logging.getLogger(__name__)
 
+_PROTOCOL_DETECTION_PRIORITY: list[ProtocolName] = [
+    "smithy-rpc-v2-cbor",
+    "json",
+    "query",
+    "ec2",
+    "rest-json",
+    "rest-xml",
+]
+
+
+class ProtocolError(Exception):
+    """
+    Error which is thrown if we cannot detect the protocol for the request.
+    """
+
+    pass
+
 
 class _ServiceIndicators(NamedTuple):
     """
@@ -28,21 +47,22 @@ class _ServiceIndicators(NamedTuple):
 
     # AWS service's "signing name" - Contained in the Authorization header
     # (https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-auth-using-authorization-header.html)
-    signing_name: Optional[str] = None
+    signing_name: str | None = None
     # Target prefix as defined in the service specs for non-rest protocols - Contained in the X-Amz-Target header
-    target_prefix: Optional[str] = None
+    target_prefix: str | None = None
     # Targeted operation as defined in the service specs for non-rest protocols - Contained in the X-Amz-Target header
-    operation: Optional[str] = None
+    operation: str | None = None
     # Host field of the HTTP request
-    host: Optional[str] = None
+    host: str | None = None
     # Path of the HTTP request
-    path: Optional[str] = None
+    path: str | None = None
 
 
 def _extract_service_indicators(request: Request) -> _ServiceIndicators:
     """Extracts all different fields that might indicate which service a request is targeting."""
     x_amz_target = request.headers.get("x-amz-target")
     authorization = request.headers.get("authorization")
+    is_rpc_v2 = "rpc-v2-cbor" in request.headers.get("Smithy-Protocol", "")
 
     signing_name = None
     if authorization:
@@ -55,7 +75,15 @@ def _extract_service_indicators(request: Request) -> _ServiceIndicators:
         except (ValueError, KeyError):
             LOG.debug("auth header could not be parsed for service routing: %s", authorization)
             pass
-    if x_amz_target:
+    if is_rpc_v2:
+        # https://smithy.io/2.0/additional-specs/protocols/smithy-rpc-v2.html#requests
+        rpc_v2_params = request.path.lstrip("/").split("/")
+        if len(rpc_v2_params) >= 4:
+            *_, service_shape_name, __, operation = rpc_v2_params
+            target_prefix = service_shape_name.split("#")[-1]
+        else:
+            target_prefix, operation = None, None
+    elif x_amz_target:
         if "." in x_amz_target:
             target_prefix, operation = x_amz_target.split(".", 1)
         else:
@@ -67,6 +95,48 @@ def _extract_service_indicators(request: Request) -> _ServiceIndicators:
     return _ServiceIndicators(signing_name, target_prefix, operation, request.host, request.path)
 
 
+def _matches_protocol(request: Request, protocol: ProtocolName) -> bool:
+    headers = request.headers
+    mimetype = request.mimetype.lower()
+    match protocol:
+        case "smithy-rpc-v2-cbor":
+            # Every request for the rpcv2Cbor protocol MUST contain a `Smithy-Protocol` header with the value
+            # of `rpc-v2-cbor`.
+            # https://smithy.io/2.0/additional-specs/protocols/smithy-rpc-v2.html
+            return headers.get("Smithy-Protocol", "") == "rpc-v2-cbor"
+        case "json":
+            return mimetype.startswith("application/x-amz-json")
+        case "query" | "ec2":
+            # https://smithy.io/2.0/aws/protocols/aws-query-protocol.html#request-serialization
+            return (
+                mimetype.startswith("application/x-www-form-urlencoded") or "Action" in request.args
+            )
+        case "rest-xml" | "rest-json":
+            # `rest-json` and `rest-xml` can accept any kind of Content-Type, and it can be configured on the operation
+            # level.
+            # https://smithy.io/2.0/aws/protocols/aws-restjson1-protocol.html
+            return True
+        case _:
+            return False
+
+
+def match_available_protocols(
+    request: Request, available_protocols: list[ProtocolName]
+) -> ProtocolName | None:
+    """
+    Tries to match the current request and determine the protocol used amongst the available protocols given.
+    We use a priority order to try to determine the protocol, as some protocols are more permissive that others.
+    :param request: the incoming request
+    :param available_protocols: the available protocols of the Service the request is directed to
+    :return: the protocol matched, if any
+    """
+    for protocol in _PROTOCOL_DETECTION_PRIORITY:
+        if protocol in available_protocols and _matches_protocol(request, protocol):
+            return protocol
+
+    return None
+
+
 signing_name_path_prefix_rules = {
     # custom rules based on URI path prefixes that are not easily generalizable
     "apigateway": {
@@ -111,7 +181,7 @@ signing_name_path_prefix_rules = {
 }
 
 
-def custom_signing_name_rules(signing_name: str, path: str) -> Optional[ServiceModelIdentifier]:
+def custom_signing_name_rules(signing_name: str, path: str) -> ServiceModelIdentifier | None:
     """
     Rules which are based on the signing name (in the auth header) and the request path.
     """
@@ -134,7 +204,7 @@ def custom_signing_name_rules(signing_name: str, path: str) -> Optional[ServiceM
     return rules.get("*", ServiceModelIdentifier(signing_name))
 
 
-def custom_host_addressing_rules(host: str) -> Optional[ServiceModelIdentifier]:
+def custom_host_addressing_rules(host: str) -> ServiceModelIdentifier | None:
     """
     Rules based on the host header of the request, which is typically the data plane of a service.
 
@@ -147,7 +217,7 @@ def custom_host_addressing_rules(host: str) -> Optional[ServiceModelIdentifier]:
         return ServiceModelIdentifier("s3")
 
 
-def custom_path_addressing_rules(path: str) -> Optional[ServiceModelIdentifier]:
+def custom_path_addressing_rules(path: str) -> ServiceModelIdentifier | None:
     """
     Rules which are only based on the request path.
     """
@@ -159,7 +229,7 @@ def custom_path_addressing_rules(path: str) -> Optional[ServiceModelIdentifier]:
         return ServiceModelIdentifier("lambda")
 
 
-def legacy_s3_rules(request: Request) -> Optional[ServiceModelIdentifier]:
+def legacy_s3_rules(request: Request) -> ServiceModelIdentifier | None:
     """
     *Legacy* rules which allow us to fallback to S3 if no other service was matched.
     All rules which are implemented here should be removed once we make sure it would not break any use-cases.
@@ -228,7 +298,7 @@ def legacy_s3_rules(request: Request) -> Optional[ServiceModelIdentifier]:
 
 
 def resolve_conflicts(
-    candidates: Set[ServiceModelIdentifier], request: Request
+    candidates: set[ServiceModelIdentifier], request: Request
 ) -> ServiceModelIdentifier:
     """
     Some service definitions are overlapping to a point where they are _not_ distinguishable at all
@@ -248,17 +318,17 @@ def resolve_conflicts(
         # The `application/x-amz-json-1.0` header is mandatory for requests targeting SQS with the `json` protocol. We
         # can safely route them to the `sqs` JSON parser/serializer. If not present, route the request to the
         # sqs-query protocol.
-        content_type = request.headers.get("Content-Type")
+        protocol = match_available_protocols(request, available_protocols=["json", "query"])
         return (
             ServiceModelIdentifier("sqs")
-            if content_type == "application/x-amz-json-1.0"
+            if protocol == "json"
             else ServiceModelIdentifier("sqs", "query")
         )
 
 
 def determine_aws_service_model_for_data_plane(
     request: Request, services: ServiceCatalog = None
-) -> Optional[ServiceModel]:
+) -> ServiceModel | None:
     """
     A stripped down version of ``determine_aws_service_model`` which only checks hostname indicators for
     the AWS data plane, such as s3 websites, lambda function URLs, or API gateway routes.
@@ -266,12 +336,30 @@ def determine_aws_service_model_for_data_plane(
     custom_host_match = custom_host_addressing_rules(request.host)
     if custom_host_match:
         services = services or get_service_catalog()
-        return services.get(*custom_host_match)
+        return services.get(custom_host_match.name, custom_host_match.protocol)
+
+
+def determine_aws_protocol(request: Request, service_model: ServiceModel) -> ProtocolName:
+    if not (protocols := service_model.metadata.get("protocols")):
+        # if the service does not define multiple protocols, return the `protocol` defined for the service
+        return service_model.protocol
+
+    if len(protocols) == 1:
+        return protocols[0]
+
+    if protocol := match_available_protocols(request, available_protocols=protocols):
+        return protocol
+
+    raise ProtocolError(
+        f"Could not determine the protocol for the request: "
+        f"{request.method} {request.path} for the service '{service_model.service_name}' "
+        f"(available protocols: {protocols})"
+    )
 
 
 def determine_aws_service_model(
     request: Request, services: ServiceCatalog = None
-) -> Optional[ServiceModel]:
+) -> ServiceModel | None:
     """
     Tries to determine the name of the AWS service an incoming request is targeting.
     :param request: to determine the target service name of
@@ -287,12 +375,13 @@ def determine_aws_service_model(
         signing_name_candidates = services.by_signing_name(signing_name)
         if len(signing_name_candidates) == 1:
             # a unique signing-name -> service name mapping is the case for ~75% of service operations
-            return services.get(*signing_name_candidates[0])
+            candidate = signing_name_candidates[0]
+            return services.get(candidate.name, candidate.protocol)
 
         # try to find a match with the custom signing name rules
         custom_match = custom_signing_name_rules(signing_name, path)
         if custom_match:
-            return services.get(*custom_match)
+            return services.get(custom_match.name, custom_match.protocol)
 
         # still ambiguous - add the services to the list of candidates
         candidates.update(signing_name_candidates)
@@ -302,33 +391,34 @@ def determine_aws_service_model(
         target_candidates = services.by_target_prefix(target_prefix)
         if len(target_candidates) == 1:
             # a unique target prefix
-            return services.get(*target_candidates[0])
+            candidate = target_candidates[0]
+            return services.get(candidate.name, candidate.protocol)
 
         # still ambiguous - add the services to the list of candidates
         candidates.update(target_candidates)
 
         # exclude services where the operation is not contained in the service spec
         for service_identifier in list(candidates):
-            service = services.get(*service_identifier)
+            service = services.get(service_identifier.name, service_identifier.protocol)
             if operation not in service.operation_names:
                 candidates.remove(service_identifier)
     else:
         # exclude services which have a target prefix (the current request does not have one)
         for service_identifier in list(candidates):
-            service = services.get(*service_identifier)
+            service = services.get(service_identifier.name, service_identifier.protocol)
             if service.metadata.get("targetPrefix") is not None:
                 candidates.remove(service_identifier)
 
     if len(candidates) == 1:
         service_identifier = candidates.pop()
-        return services.get(*service_identifier)
+        return services.get(service_identifier.name, service_identifier.protocol)
 
     # 3. check the path if it is set and not a trivial root path
     if path and path != "/":
         # try to find a match with the custom path rules
         custom_path_match = custom_path_addressing_rules(path)
         if custom_path_match:
-            return services.get(*custom_path_match)
+            return services.get(custom_path_match.name, custom_path_match.protocol)
 
     # 4. check the host (custom host addressing rules)
     if host:
@@ -337,12 +427,14 @@ def determine_aws_service_model(
             # this prevents a virtual host addressed bucket to be wrongly recognized
             if host.startswith(f"{prefix}.") and ".s3." not in host:
                 if len(services_per_prefix) == 1:
-                    return services.get(*services_per_prefix[0])
+                    candidate = services_per_prefix[0]
+                    return services.get(candidate.name, candidate.protocol)
                 candidates.update(services_per_prefix)
 
         custom_host_match = custom_host_addressing_rules(host)
         if custom_host_match:
-            return services.get(*custom_host_match)
+            candidate = custom_host_match[0]
+            return services.get(candidate.name, candidate.protocol)
 
     if request.shallow:
         # from here on we would need access to the request body, which doesn't exist for shallow requests like
@@ -357,21 +449,28 @@ def determine_aws_service_model(
             query_candidates = [
                 service
                 for service in services.by_operation(values["Action"])
-                if service.protocol in ("ec2", "query")
+                if any(
+                    is_protocol_in_service_model_identifier(protocol, service)
+                    for protocol in ("ec2", "query")
+                )
             ]
 
             if len(query_candidates) == 1:
-                return services.get(*query_candidates[0])
+                candidate = query_candidates[0]
+                return services.get(candidate.name, candidate.protocol)
 
             if "Version" in values:
                 for service_identifier in list(query_candidates):
-                    service_model = services.get(*service_identifier)
+                    service_model = services.get(
+                        service_identifier.name, service_identifier.protocol
+                    )
                     if values["Version"] != service_model.api_version:
                         # the combination of Version and Action is not unique, add matches to the candidates
                         query_candidates.remove(service_identifier)
 
             if len(query_candidates) == 1:
-                return services.get(*query_candidates[0])
+                candidate = query_candidates[0]
+                return services.get(candidate.name, candidate.protocol)
 
             candidates.update(query_candidates)
 
@@ -387,15 +486,16 @@ def determine_aws_service_model(
     # 6. resolve service spec conflicts
     resolved_conflict = resolve_conflicts(candidates, request)
     if resolved_conflict:
-        return services.get(*resolved_conflict)
+        return services.get(resolved_conflict.name, resolved_conflict.protocol)
 
     # 7. check the legacy S3 rules in the end
     legacy_match = legacy_s3_rules(request)
     if legacy_match:
-        return services.get(*legacy_match)
+        return services.get(legacy_match.name, legacy_match.protocol)
 
     if signing_name:
         return services.get(name=signing_name)
     if candidates:
-        return services.get(*candidates.pop())
+        candidate = candidates.pop()
+        return services.get(candidate.name, candidate.protocol)
     return None

localstack/aws/protocol/validate.py

@@ -1,6 +1,6 @@
 """Slightly extends the ``botocore.validate`` package to provide better integration with our parser/serializer."""
 
-from typing import Any, Dict, List, NamedTuple
+from typing import Any, NamedTuple
 
 from botocore.model import OperationModel, Shape
 from botocore.validate import ParamValidator as BotocoreParamValidator
@@ -22,7 +22,7 @@ class Error(NamedTuple):
 
     reason: str
     name: str
-    attributes: Dict[str, Any]
+    attributes: dict[str, Any]
 
 
 class ParameterValidationError(Exception):
@@ -88,11 +88,11 @@ class EmptyInput(ParameterValidationError):
 
 
 class ValidationErrors(BotocoreValidationErrors):
-    def __init__(self, shape: Shape, params: Dict[str, Any]):
+    def __init__(self, shape: Shape, params: dict[str, Any]):
         super().__init__()
         self.shape = shape
         self.params = params
-        self._exceptions: List[ParameterValidationError] = []
+        self._exceptions: list[ParameterValidationError] = []
 
     @property
     def exceptions(self):
@@ -133,7 +133,7 @@ class ValidationErrors(BotocoreValidationErrors):
 
 
 class ParamValidator(BotocoreParamValidator):
-    def validate(self, params: Dict[str, Any], shape: Shape):
+    def validate(self, params: dict[str, Any], shape: Shape):
         """Validate parameters against a shape model.
 
         This method will validate the parameters against a provided shape model.
@@ -159,7 +159,7 @@ class ParamValidator(BotocoreParamValidator):
             if required_member in params and params[required_member] is None:
                 params.pop(required_member)
 
-        super(ParamValidator, self)._validate_structure(params, shape, errors, name)
+        super()._validate_structure(params, shape, errors, name)
 
 
 def validate_request(operation: OperationModel, request: ServiceRequest) -> ValidationErrors:

localstack/aws/scaffold.py

@@ -1,10 +1,10 @@
 import io
 import keyword
 import re
+from collections import OrderedDict
 from functools import cached_property
 from multiprocessing import Pool
 from pathlib import Path
-from typing import Dict, List, Optional, Set
 
 import click
 from botocore import xform_name
@@ -18,7 +18,6 @@ from botocore.model import (
     StringShape,
     StructureShape,
 )
-from typing_extensions import OrderedDict
 
 from localstack.aws.spec import load_service
 from localstack.utils.common import camel_to_snake_case, snake_to_camel_case
@@ -75,7 +74,7 @@ class ShapeNode:
         self.shape = shape
 
     @cached_property
-    def request_operation(self) -> Optional[OperationModel]:
+    def request_operation(self) -> OperationModel | None:
         for operation_name in self.service.operation_names:
             operation = self.service.operation_model(operation_name)
             if operation.input_shape is None:
@@ -89,7 +88,7 @@ class ShapeNode:
         return None
 
     @cached_property
-    def response_operation(self) -> Optional[OperationModel]:
+    def response_operation(self) -> OperationModel | None:
         for operation_name in self.service.operation_names:
             operation = self.service.operation_model(operation_name)
             if operation.output_shape is None:
@@ -128,7 +127,7 @@ class ShapeNode:
         return isinstance(self.shape, StringShape) and self.shape.enum
 
     @property
-    def dependencies(self) -> List[str]:
+    def dependencies(self) -> list[str]:
         shape = self.shape
 
         if isinstance(shape, StructureShape):
@@ -222,7 +221,7 @@ class ShapeNode:
 
     def _print_as_typed_dict(self, output, doc=True, quote_types=False):
         name = to_valid_python_name(self.shape.name)
-        output.write('%s = TypedDict("%s", {\n' % (name, name))
+        output.write(f'{name} = TypedDict("{name}", {{\n')
         for k, v in self.shape.members.items():
             member_name = to_valid_python_name(v.name)
             # check if the member name is the same as the type name (recursive types need to use forward references)
@@ -327,7 +326,7 @@ def generate_service_types(output, service: ServiceModel, doc=True):
     output.write("\n")
 
     # ==================================== print type declarations
-    nodes: Dict[str, ShapeNode] = {}
+    nodes: dict[str, ShapeNode] = {}
 
     for shape_name in service.shape_names:
         shape = service.shape_for(shape_name)
@@ -338,9 +337,9 @@ def generate_service_types(output, service: ServiceModel, doc=True):
     #     output.write(f'    "{name}",\n')
     # output.write("]\n")
 
-    printed: Set[str] = set()
-    visited: Set[str] = set()
-    stack: List[str] = list(nodes.keys())
+    printed: set[str] = set()
+    visited: set[str] = set()
+    stack: list[str] = list(nodes.keys())
 
     stack = sorted(stack, key=lambda name: nodes[name].get_order())
     stack.reverse()

localstack/aws/serving/edge.py

@@ -1,6 +1,5 @@
 import logging
 import threading
-from typing import List
 
 from rolo.gateway.wsgi import WsgiGateway
 
@@ -15,7 +14,7 @@ LOG = logging.getLogger(__name__)
 
 
 def serve_gateway(
-    listen: HostAndPort | List[HostAndPort], use_ssl: bool, asynchronous: bool = False
+    listen: HostAndPort | list[HostAndPort], use_ssl: bool, asynchronous: bool = False
 ):
     """
     Implementation of the edge.do_start_edge_proxy interface to start a Hypercorn server instance serving the
@@ -37,7 +36,7 @@ def serve_gateway(
 
 
 def _serve_werkzeug(
-    gateway: LocalstackAwsGateway, listen: List[HostAndPort], use_ssl: bool, asynchronous: bool
+    gateway: LocalstackAwsGateway, listen: list[HostAndPort], use_ssl: bool, asynchronous: bool
 ):
     from werkzeug.serving import ThreadedWSGIServer
 
@@ -57,7 +56,7 @@ def _serve_werkzeug(
         params["ssl_context"] = (cert_file_name, key_file_name)
 
     threads = []
-    servers: List[ThreadedWSGIServer] = []
+    servers: list[ThreadedWSGIServer] = []
 
     for host_port in listen:
         kwargs = dict(params)
@@ -90,7 +89,7 @@ def _serve_werkzeug(
 
 
 def _serve_hypercorn(
-    gateway: LocalstackAwsGateway, listen: List[HostAndPort], use_ssl: bool, asynchronous: bool
+    gateway: LocalstackAwsGateway, listen: list[HostAndPort], use_ssl: bool, asynchronous: bool
 ):
     from localstack.http.hypercorn import GatewayServer
 
@@ -112,7 +111,7 @@ def _serve_hypercorn(
 
 
 def _serve_twisted(
-    gateway: LocalstackAwsGateway, listen: List[HostAndPort], use_ssl: bool, asynchronous: bool
+    gateway: LocalstackAwsGateway, listen: list[HostAndPort], use_ssl: bool, asynchronous: bool
 ):
     from .twisted import serve_gateway
 

localstack/aws/serving/hypercorn.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Any, Optional, Tuple
+from typing import Any
 
 from hypercorn import Config
 from hypercorn.asyncio import serve as serve_hypercorn
@@ -15,7 +15,7 @@ def serve(
     host: str = "localhost",
     port: int = constants.DEFAULT_PORT_EDGE,
     use_reloader: bool = True,
-    ssl_creds: Optional[Tuple[Any, Any]] = None,
+    ssl_creds: tuple[Any, Any] | None = None,
     **kwargs,
 ) -> None:
     """

localstack/aws/serving/twisted.py

@@ -4,7 +4,6 @@ Bindings to serve LocalStack using twisted.
 
 import logging
 import time
-from typing import List
 
 from rolo.gateway import Gateway
 from rolo.serving.twisted import TwistedGateway
@@ -130,7 +129,7 @@ def stop_thread_pool(self: ThreadPool, stop, timeout: float = None):
 
 
 def serve_gateway(
-    gateway: Gateway, listen: List[HostAndPort], use_ssl: bool, asynchronous: bool = False
+    gateway: Gateway, listen: list[HostAndPort], use_ssl: bool, asynchronous: bool = False
 ):
     """
     Serve a Gateway instance using twisted.

localstack/aws/serving/werkzeug.py

@@ -1,5 +1,5 @@
 import ssl
-from typing import TYPE_CHECKING, Any, Optional, Tuple
+from typing import TYPE_CHECKING, Any
 
 from rolo.gateway import Gateway
 from rolo.gateway.wsgi import WsgiGateway
@@ -17,7 +17,7 @@ def serve(
     host: str = "localhost",
     port: int = constants.DEFAULT_PORT_EDGE,
     use_reloader: bool = True,
-    ssl_creds: Optional[Tuple[Any, Any]] = None,
+    ssl_creds: tuple[Any, Any] | None = None,
     **kwargs,
 ) -> None:
     """

localstack/aws/skeleton.py

@@ -1,6 +1,7 @@
 import inspect
 import logging
-from typing import Any, Callable, Dict, NamedTuple, Optional, Union
+from collections.abc import Callable
+from typing import Any, NamedTuple
 
 from botocore import xform_name
 from botocore.model import ServiceModel
@@ -20,10 +21,10 @@ from localstack.utils.coverage_docs import get_coverage_link_for_service
 
 LOG = logging.getLogger(__name__)
 
-DispatchTable = Dict[str, ServiceRequestHandler]
+DispatchTable = dict[str, ServiceRequestHandler]
 
 
-def create_skeleton(service: Union[str, ServiceModel], delegate: Any):
+def create_skeleton(service: str | ServiceModel, delegate: Any):
     if isinstance(service, str):
         service = load_service(service)
 
@@ -49,10 +50,10 @@ def create_dispatch_table(delegate: object) -> DispatchTable:
     # scan class tree for @handler wrapped functions (reverse class tree so that inherited functions overwrite parent
     # functions)
     cls_tree = inspect.getmro(delegate.__class__)
-    handlers: Dict[str, HandlerAttributes] = {}
+    handlers: dict[str, HandlerAttributes] = {}
     cls_tree = reversed(list(cls_tree))
     for cls in cls_tree:
-        if cls == object:
+        if cls is object:
             continue
 
         for name, fn in inspect.getmembers(cls, inspect.isfunction):
@@ -98,9 +99,7 @@ class ServiceRequestDispatcher:
         self.pass_context = pass_context
         self.expand_parameters = expand_parameters
 
-    def __call__(
-        self, context: RequestContext, request: ServiceRequest
-    ) -> Optional[ServiceResponse]:
+    def __call__(self, context: RequestContext, request: ServiceRequest) -> ServiceResponse | None:
         args = []
         kwargs = {}
 
@@ -122,7 +121,7 @@ class Skeleton:
     service: ServiceModel
     dispatch_table: DispatchTable
 
-    def __init__(self, service: ServiceModel, implementation: Union[Any, DispatchTable]):
+    def __init__(self, service: ServiceModel, implementation: Any | DispatchTable):
         self.service = service
 
         if isinstance(implementation, dict):
@@ -131,14 +130,16 @@ class Skeleton:
             self.dispatch_table = create_dispatch_table(implementation)
 
     def invoke(self, context: RequestContext) -> Response:
-        serializer = create_serializer(context.service)
+        serializer = create_serializer(context.service, context.protocol)
 
         if context.operation and context.service_request:
             # if the parsed request is already set in the context, re-use them
             operation, instance = context.operation, context.service_request
         else:
             # otherwise, parse the incoming HTTPRequest
-            operation, instance = create_parser(context.service).parse(context.request)
+            operation, instance = create_parser(context.service, context.protocol).parse(
+                context.request
+            )
             context.operation = operation
 
         try: