localstack-core 4.8.2.dev11__tar.gz → 4.8.2.dev13__tar.gz

{localstack_core-4.8.2.dev11 → localstack_core-4.8.2.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localstack-core
-Version: 4.8.2.dev11
+Version: 4.8.2.dev13
 Summary: The core library and runtime of LocalStack
 Author-email: LocalStack Contributors <info@localstack.cloud>
 License-Expression: Apache-2.0

{localstack_core-4.8.2.dev11 → localstack_core-4.8.2.dev13}/localstack-core/localstack/aws/api/cloudwatch/__init__.py

@@ -218,7 +218,7 @@ class ConcurrentModificationException(ServiceException):
 class ConflictException(ServiceException):
     code: str = "ConflictException"
     sender_fault: bool = False
-    status_code: int = 400
+    status_code: int = 409
 
 
 class DashboardValidationMessage(TypedDict, total=False):

{localstack_core-4.8.2.dev11 → localstack_core-4.8.2.dev13}/localstack-core/localstack/aws/api/core.py

@@ -13,6 +13,7 @@ from botocore.model import OperationModel, ServiceModel
 from rolo.gateway import RequestContext as RoloRequestContext
 
 from localstack.aws.connect import InternalRequestParameters
+from localstack.aws.spec import ProtocolName
 from localstack.http import Request, Response
 from localstack.utils.strings import long_uid
 
@@ -88,6 +89,8 @@ class RequestContext(RoloRequestContext):
     """The underlying incoming HTTP request."""
     service: ServiceModel | None
     """The botocore ServiceModel of the service the request is made to."""
+    protocol: ProtocolName | None
+    """The botocore Protocol for the service the request is made to."""
     operation: OperationModel | None
     """The botocore OperationModel of the AWS operation being invoked."""
     region: str
@@ -112,6 +115,7 @@ class RequestContext(RoloRequestContext):
     def __init__(self, request: Request):
         super().__init__(request)
         self.service = None
+        self.protocol = None
         self.operation = None
         self.region = None  # type: ignore[assignment]  # type=str, because we know it will always be set downstream
         self.partition = "aws"  # Sensible default - will be overwritten by region-handler

{localstack_core-4.8.2.dev11 → localstack_core-4.8.2.dev13}/localstack-core/localstack/aws/client.py

@@ -21,6 +21,7 @@ from localstack.utils.strings import to_str
 from .api import CommonServiceException, RequestContext, ServiceException, ServiceResponse
 from .connect import get_service_endpoint
 from .gateway import Gateway
+from .spec import ProtocolName
 
 LOG = logging.getLogger(__name__)
 
@@ -284,13 +285,17 @@ def _patch_botocore_endpoint_in_memory():
 
 
 def parse_response(
-    operation: OperationModel, response: Response, include_response_metadata: bool = True
+    operation: OperationModel,
+    protocol: ProtocolName,
+    response: Response,
+    include_response_metadata: bool = True,
 ) -> ServiceResponse:
     """
     Parses an HTTP Response object into an AWS response object using botocore. It does this by adapting the
     procedure of ``botocore.endpoint.convert_to_response_dict`` to work with Werkzeug's server-side response object.
 
     :param operation: the operation of the original request
+    :param protocol: the protocol of the original request
     :param response: the HTTP response object containing the response of the operation
     :param include_response_metadata: True if the ResponseMetadata (typical for boto response dicts) should be included
     :return: a parsed dictionary as it is returned by botocore
@@ -322,7 +327,7 @@ def parse_response(
             timestamp_parser=_cbor_timestamp_parser, blob_parser=_cbor_blob_parser
         )
 
-    parser = factory.create_parser(operation.service_model.protocol)
+    parser = factory.create_parser(protocol)
     parsed_response = parser.parse(response_dict, operation.output_shape)
 
     if response.status_code >= 301:

{localstack_core-4.8.2.dev11 → localstack_core-4.8.2.dev13}/localstack-core/localstack/aws/forwarder.py

@@ -8,6 +8,8 @@ from typing import Any
 
 from botocore.awsrequest import AWSPreparedRequest, prepare_request_dict
 from botocore.config import Config as BotoConfig
+from botocore.model import OperationModel
+from botocore.serialize import create_serializer
 from werkzeug.datastructures import Headers
 
 from localstack.aws.api.core import (
@@ -19,7 +21,7 @@ from localstack.aws.api.core import (
 from localstack.aws.client import create_http_request, parse_response, raise_service_exception
 from localstack.aws.connect import connect_to
 from localstack.aws.skeleton import DispatchTable, create_dispatch_table
-from localstack.aws.spec import load_service
+from localstack.aws.spec import ProtocolName, load_service
 from localstack.constants import AWS_REGION_US_EAST_1
 from localstack.http import Response
 from localstack.http.proxy import Proxy
@@ -79,7 +81,7 @@ class AwsRequestProxy:
         if not self.parse_response:
             return http_response
         parsed_response = parse_response(
-            context.operation, http_response, self.include_response_metadata
+            context.operation, context.protocol, http_response, self.include_response_metadata
         )
         raise_service_exception(http_response, parsed_response)
         return parsed_response
@@ -90,6 +92,7 @@ class AwsRequestProxy:
             action=original.operation.name,
             parameters=service_request,
             region=original.region,
+            protocol=original.protocol,
         )
         # update the newly created context with non-payload specific request headers (the payload can differ from
         # the original request, f.e. it could be JSON encoded now while the initial request was CBOR encoded)
@@ -184,7 +187,9 @@ def dispatch_to_backend(
     :raises ServiceException: if the dispatcher returned an error response
     """
     http_response = http_request_dispatcher(context)
-    parsed_response = parse_response(context.operation, http_response, include_response_metadata)
+    parsed_response = parse_response(
+        context.operation, context.protocol, http_response, include_response_metadata
+    )
     raise_service_exception(http_response, parsed_response)
     return parsed_response
 
@@ -196,6 +201,7 @@ _non_validating_boto_config = BotoConfig(parameter_validation=False)
 def create_aws_request_context(
     service_name: str,
     action: str,
+    protocol: ProtocolName = None,
     parameters: Mapping[str, Any] = None,
     region: str = None,
     endpoint_url: str | None = None,
@@ -210,6 +216,7 @@ def create_aws_request_context(
 
     :param service_name: the AWS service
     :param action: the action to invoke
+    :param protocol: the protocol to use
     :param parameters: the invocation parameters
     :param region: the region name (default is us-east-1)
     :param endpoint_url: the endpoint to call (defaults to localstack)
@@ -222,6 +229,8 @@ def create_aws_request_context(
 
     service = load_service(service_name)
     operation = service.operation_model(action)
+    # TODO: remove this once every usage upstream has been removed
+    protocol = protocol or service.resolved_protocol
 
     # we re-use botocore internals here to serialize the HTTP request,
     # but deactivate validation (validation errors should be handled by the backend)
@@ -243,8 +252,14 @@ def create_aws_request_context(
         endpoint_url = "http://localhost.localstack.cloud"
     # pre-process the request args (some params are modified using botocore event handlers)
     parameters = client._emit_api_params(parameters, operation, request_context)
-    request_dict = client._convert_to_request_dict(
-        parameters, operation, endpoint_url, context=request_context
+
+    request_dict = _convert_to_request_dict_with_protocol(
+        client=client,
+        protocol=protocol,
+        api_params=parameters,
+        operation_model=operation,
+        endpoint_url=endpoint_url,
+        context=request_context,
     )
 
     if auth_path := request_dict.get("auth_path"):
@@ -266,7 +281,39 @@ def create_aws_request_context(
     context = RequestContext(request=create_http_request(aws_request))
     context.service = service
     context.operation = operation
+    context.protocol = protocol
     context.region = region
     context.service_request = parameters
 
     return context
+
+
+def _convert_to_request_dict_with_protocol(
+    client,
+    protocol: ProtocolName,
+    api_params: dict,
+    operation_model: OperationModel,
+    endpoint_url: str,
+    context: dict,
+    set_user_agent_header: bool = True,
+) -> dict:
+    """
+    This function is taken from botocore Client._convert_to_request_dict, but we are overriding the serializer
+    Botocore does not expose a way to create a client with a specific protocol, but we need this functionality
+    to support multi-protocols.
+    """
+    serializer = create_serializer(protocol, include_validation=False)
+    request_dict = serializer.serialize_to_request(api_params, operation_model)
+    if not client._client_config.inject_host_prefix:
+        request_dict.pop("host_prefix", None)
+    if set_user_agent_header:
+        user_agent = client._user_agent_creator.to_string()
+    else:
+        user_agent = None
+    prepare_request_dict(
+        request_dict,
+        endpoint_url=endpoint_url,
+        user_agent=user_agent,
+        context=context,
+    )
+    return request_dict

{localstack_core-4.8.2.dev11 → localstack_core-4.8.2.dev13}/localstack-core/localstack/aws/handlers/analytics.py

@@ -60,7 +60,7 @@ class ServiceRequestCounter:
             if context.service_exception:
                 return context.service_exception.code
 
-            response = parse_response(context.operation, response)
+            response = parse_response(context.operation, context.protocol, response)
             return response["Error"]["Code"]
         except Exception:
             if config.DEBUG_ANALYTICS:

{localstack_core-4.8.2.dev11 → localstack_core-4.8.2.dev13}/localstack-core/localstack/aws/handlers/service.py

@@ -17,7 +17,7 @@ from ..chain import CompositeResponseHandler, ExceptionHandler, Handler, Handler
 from ..client import parse_response, parse_service_exception
 from ..protocol.parser import RequestParser, create_parser
 from ..protocol.serializer import create_serializer
-from ..protocol.service_router import determine_aws_service_model
+from ..protocol.service_router import determine_aws_protocol, determine_aws_service_model
 from ..skeleton import Skeleton, create_skeleton
 
 LOG = logging.getLogger(__name__)
@@ -33,6 +33,8 @@ class ServiceNameParser(Handler):
         # example). If it is already set, we can skip the parsing of the request. It is very important for S3, because
         # parsing the request will consume the data stream and prevent streaming.
         if context.service:
+            if not context.protocol:
+                context.protocol = determine_aws_protocol(context.request, context.service)
             return
 
         service_model = determine_aws_service_model(context.request)
@@ -41,6 +43,7 @@ class ServiceNameParser(Handler):
             return
 
         context.service = service_model
+        context.protocol = determine_aws_protocol(context.request, service_model)
 
 
 class ServiceRequestParser(Handler):
@@ -63,7 +66,7 @@ class ServiceRequestParser(Handler):
         return self.parse_and_enrich(context)
 
     def parse_and_enrich(self, context: RequestContext):
-        parser = create_parser(context.service)
+        parser = create_parser(context.service, context.protocol)
         operation, instance = parser.parse(context.request)
 
         # enrich context
@@ -137,7 +140,7 @@ class ServiceRequestRouter(Handler):
         operation_name = operation.name
         message = f"no handler for operation '{operation_name}' on service '{service_name}'"
         error = CommonServiceException("InternalFailure", message, status_code=501)
-        serializer = create_serializer(context.service)
+        serializer = create_serializer(context.service, context.protocol)
         return serializer.serialize_error_to_response(
             error, operation, context.request.headers, context.request_id
         )
@@ -209,7 +212,7 @@ class ServiceExceptionSerializer(ExceptionHandler):
             ).with_traceback(exception.__traceback__)
             context.service_exception = error
 
-        serializer = create_serializer(context.service)  # TODO: serializer cache
+        serializer = create_serializer(context.service, context.protocol)
         return serializer.serialize_error_to_response(
             error, operation, context.request.headers, context.request_id
         )
@@ -252,7 +255,9 @@ class ServiceResponseParser(Handler):
             return
 
         # in this case we need to parse the raw response
-        parsed = parse_response(context.operation, response, include_response_metadata=False)
+        parsed = parse_response(
+            context.operation, context.protocol, response, include_response_metadata=False
+        )
         if service_exception := parse_service_exception(response, parsed):
             context.service_exception = service_exception
         else:

{localstack_core-4.8.2.dev11 → localstack_core-4.8.2.dev13}/localstack-core/localstack/aws/protocol/parser.py

@@ -359,13 +359,11 @@ class RequestParser(abc.ABC):
 
     @staticmethod
     def _timestamp_unixtimestamp(timestamp_string: str) -> datetime.datetime:
-        dt = datetime.datetime.fromtimestamp(int(timestamp_string), tz=datetime.UTC)
-        return dt.replace(tzinfo=None)
+        return datetime.datetime.fromtimestamp(int(timestamp_string), tz=datetime.UTC)
 
     @staticmethod
     def _timestamp_unixtimestampmillis(timestamp_string: str) -> datetime.datetime:
-        dt = datetime.datetime.fromtimestamp(float(timestamp_string) / 1000, tz=datetime.UTC)
-        return dt.replace(tzinfo=None)
+        return datetime.datetime.fromtimestamp(float(timestamp_string) / 1000, tz=datetime.UTC)
 
     @staticmethod
     def _timestamp_rfc822(datetime_string: str) -> datetime.datetime:
@@ -1168,6 +1166,14 @@ class BaseCBORRequestParser(RequestParser, ABC):
     def _parse_blob(self, _, __, node: bytes, ___) -> bytes:
         return node
 
+    @_text_content
+    def _parse_timestamp(
+        self, _, shape: Shape, node: datetime.datetime | str, ___
+    ) -> datetime.datetime:
+        if isinstance(node, datetime.datetime):
+            return node
+        return super()._parse_timestamp(_, shape, node, ___)
+
     # This helper method is intended for use when parsing indefinite length items.
     # It does nothing if the next byte is not the break code.  If the next byte is
     # the break code, it advances past that byte and returns True so the calling
@@ -1266,8 +1272,6 @@ class BaseRpcV2RequestParser(RequestParser):
                 "RPC v2 does not accept 'X-Amz-Target' or 'X-Amzn-Target'. "
                 "Such requests are rejected for security reasons."
             )
-        # TODO: add this special path handling to the ServiceNameParser to allow RPC v2 service to be properly extracted
-        #  path = '/service/{service_name}/operation/{operation_name}'
         # The Smithy RPCv2 CBOR protocol will only use the last four segments of the URL when routing requests.
         rpc_v2_params = request.path.lstrip("/").split("/")
         if len(rpc_v2_params) < 4 or not (
@@ -1580,8 +1584,6 @@ def create_parser(service: ServiceModel, protocol: ProtocolName | None = None) -
         # this is not an "official" protocol defined from the spec, but is derived from ``json``
     }
 
-    # TODO: do we want to add a check if the user-defined protocol is part of the available ones in the ServiceModel?
-    #  or should it be checked once
     service_protocol = protocol or service.protocol
 
     # Try to select a service- and protocol-specific parser implementation

{localstack_core-4.8.2.dev11 → localstack_core-4.8.2.dev13}/localstack-core/localstack/aws/protocol/serializer.py

@@ -1773,6 +1773,8 @@ class CBORResponseSerializer(BaseCBORResponseSerializer):
         mime_type: str,
         request_id: str,
     ) -> bytes | None:
+        if shape is None:
+            return b""
         body = bytearray()
         self._serialize_data_item(body, params, shape)
         return bytes(body)
@@ -1839,6 +1841,8 @@ class RpcV2CBORResponseSerializer(BaseRpcV2ResponseSerializer, BaseCBORResponseS
         mime_type: str,
         request_id: str,
     ) -> bytes | None:
+        if shape is None:
+            return b""
         body = bytearray()
         self._serialize_data_item(body, params, shape)
         return bytes(body)
@@ -2263,9 +2267,6 @@ def create_serializer(
         #  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
@@ -2307,7 +2308,7 @@ def aws_response_serializer(
     def _decorate(fn):
         service_model = load_service(service_name, protocol=protocol)
         operation_model = service_model.operation_model(operation)
-        serializer = create_serializer(service_model)
+        serializer = create_serializer(service_model, protocol=protocol)
 
         def _proxy(*args, **kwargs) -> WerkzeugResponse:
             # extract request from function invocation (decorator can be used for methods as well as for functions).

{localstack_core-4.8.2.dev11 → localstack_core-4.8.2.dev13}/localstack-core/localstack/aws/protocol/service_router.py

@@ -6,9 +6,11 @@ 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):
     """
@@ -43,6 +62,7 @@ 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": {
@@ -248,10 +318,10 @@ 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")
         )
 
@@ -266,7 +336,25 @@ 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(
@@ -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_core-4.8.2.dev11 → localstack_core-4.8.2.dev13}/localstack-core/localstack/aws/skeleton.py

@@ -130,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: