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

localstack/aws/handlers/service.py

@@ -2,22 +2,23 @@
 
 import logging
 import traceback
+import types
 from collections import defaultdict
-from typing import Any, Dict, Union
+from typing import Any
 
 from botocore.model import OperationModel, ServiceModel
 
 from localstack import config
 from localstack.http import Response
-from localstack.utils.coverage_docs import get_coverage_link_for_service
 
+from ...utils.coverage_docs import get_coverage_link_for_service
 from ..api import CommonServiceException, RequestContext, ServiceException
 from ..api.core import ServiceOperation
 from ..chain import CompositeResponseHandler, ExceptionHandler, Handler, HandlerChain
 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 +34,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 +44,7 @@ class ServiceNameParser(Handler):
             return
 
         context.service = service_model
+        context.protocol = determine_aws_protocol(context.request, service_model)
 
 
 class ServiceRequestParser(Handler):
@@ -49,10 +53,10 @@ class ServiceRequestParser(Handler):
     already be resolved in the RequestContext (e.g., through a ServiceNameParser)
     """
 
-    parsers: Dict[str, RequestParser]
+    parsers: dict[str, RequestParser]
 
     def __init__(self):
-        self.parsers = dict()
+        self.parsers = {}
 
     def __call__(self, chain: HandlerChain, context: RequestContext, response: Response):
         # determine service
@@ -63,7 +67,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
@@ -89,10 +93,10 @@ class ServiceRequestRouter(Handler):
     Routes ServiceOperations to Handlers.
     """
 
-    handlers: Dict[ServiceOperation, Handler]
+    handlers: dict[ServiceOperation, Handler]
 
     def __init__(self):
-        self.handlers = dict()
+        self.handlers = {}
 
     def __call__(self, chain: HandlerChain, context: RequestContext, response: Response):
         if not context.service:
@@ -118,7 +122,7 @@ class ServiceRequestRouter(Handler):
 
         self.handlers[key] = handler
 
-    def add_provider(self, provider: Any, service: Union[str, ServiceModel]):
+    def add_provider(self, provider: Any, service: str | ServiceModel):
         self.add_skeleton(create_skeleton(service, provider))
 
     def add_skeleton(self, skeleton: Skeleton):
@@ -137,7 +141,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
         )
@@ -153,6 +157,15 @@ class ServiceExceptionSerializer(ExceptionHandler):
     def __init__(self):
         self.handle_internal_failures = True
 
+        try:
+            import moto.core.exceptions
+
+            self._moto_service_exception = moto.core.exceptions.ServiceException
+        except (ModuleNotFoundError, AttributeError) as exc:
+            # Moto may not be available in stripped-down versions of LocalStack, like LocalStack S3 image.
+            LOG.debug("Unable to set up Moto ServiceException translation: %s", exc)
+            self._moto_service_exception = types.EllipsisType
+
     def __call__(
         self,
         chain: HandlerChain,
@@ -176,43 +189,48 @@ class ServiceExceptionSerializer(ExceptionHandler):
             action_name = operation.name
             exception_message: str | None = exception.args[0] if exception.args else None
             message = exception_message or get_coverage_link_for_service(service_name, action_name)
-            LOG.info(message)
             error = CommonServiceException("InternalFailure", message, status_code=501)
-            context.service_exception = error
+            LOG.info(message)
+
+        elif isinstance(exception, self._moto_service_exception):
+            # Translate Moto ServiceException to native ServiceException if Moto is available.
+            # This allows handler chain to gracefully handles Moto errors when provider handlers invoke Moto methods directly.
+            error = CommonServiceException(
+                code=exception.code,
+                message=exception.message,
+            )
 
         elif not isinstance(exception, ServiceException):
             if not self.handle_internal_failures:
                 return
 
-            if config.DEBUG:
-                exception = "".join(
+            if config.INCLUDE_STACK_TRACES_IN_HTTP_RESPONSE:
+                message = "".join(
                     traceback.format_exception(
                         type(exception), value=exception, tb=exception.__traceback__
                     )
                 )
+            else:
+                message = str(exception)
 
             # wrap exception for serialization
             if operation:
                 operation_name = operation.name
-                msg = "exception while calling %s.%s: %s" % (
-                    service_name,
-                    operation_name,
-                    exception,
-                )
+                msg = f"exception while calling {service_name}.{operation_name}: {message}"
             else:
                 # just use any operation for mocking purposes (the parser needs it to populate the default response)
                 operation = context.service.operation_model(context.service.operation_names[0])
-                msg = "exception while calling %s with unknown operation: %s" % (
-                    service_name,
-                    exception,
-                )
+                msg = f"exception while calling {service_name} with unknown operation: {message}"
 
             status_code = 501 if config.FAIL_FAST else 500
 
-            error = CommonServiceException("InternalError", msg, status_code=status_code)
-            context.service_exception = error
+            error = CommonServiceException(
+                "InternalError", msg, status_code=status_code
+            ).with_traceback(exception.__traceback__)
 
-        serializer = create_serializer(context.service)  # TODO: serializer cache
+        context.service_exception = error
+
+        serializer = create_serializer(context.service, context.protocol)
         return serializer.serialize_error_to_response(
             error, operation, context.request.headers, context.request_id
         )
@@ -255,7 +273,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:
@@ -278,7 +298,7 @@ class ServiceResponseHandlers(Handler):
     are only called if the request context has a service, and there are handlers for that particular service.
     """
 
-    handlers: Dict[str, CompositeResponseHandler]
+    handlers: dict[str, CompositeResponseHandler]
 
     def __init__(self):
         self.handlers = defaultdict(CompositeResponseHandler)

localstack/aws/mocking.py

@@ -4,7 +4,7 @@ import random
 import re
 from datetime import date, datetime
 from functools import lru_cache, singledispatch
-from typing import Dict, List, Optional, Set, Tuple, Union, cast
+from typing import cast
 
 import botocore
 import networkx
@@ -32,18 +32,9 @@ types = {
     "boolean",
 }
 
-Instance = Union[
-    Dict[str, "Instance"],
-    List["Instance"],
-    str,
-    bytes,
-    map,
-    list,
-    float,
-    int,
-    bool,
-    date,
-]
+Instance = (
+    dict[str, "Instance"] | list["Instance"] | str | bytes | map | list | float | int | bool | date
+)
 
 # https://github.com/boto/botocore/issues/2623
 StringShape.METADATA_ATTRS.append("pattern")
@@ -66,14 +57,14 @@ DEFAULT_ARN = "arn:aws:ec2:us-east-1:1234567890123:instance/i-abcde0123456789f"
 
 
 class ShapeGraph(networkx.DiGraph):
-    root: Union[ListShape, StructureShape, MapShape]
-    cycle: List[Tuple[str, str]]
-    cycle_shapes: List[str]
+    root: ListShape | StructureShape | MapShape
+    cycle: list[tuple[str, str]]
+    cycle_shapes: list[str]
 
 
 def populate_graph(graph: networkx.DiGraph, root: Shape):
-    stack: List[Shape] = [root]
-    visited: Set[str] = set()
+    stack: list[Shape] = [root]
+    visited: set[str] = set()
 
     while stack:
         cur = stack.pop()
@@ -108,7 +99,7 @@ def shape_graph(root: Shape) -> ShapeGraph:
     graph.root = root
     populate_graph(graph, root)
 
-    cycles = list()
+    cycles = []
     shapes = set()
     for node in graph.nodes:
         try:
@@ -230,14 +221,14 @@ custom_arns = {
 
 
 @singledispatch
-def generate_instance(shape: Shape, graph: ShapeGraph) -> Optional[Instance]:
+def generate_instance(shape: Shape, graph: ShapeGraph) -> Instance | None:
     if shape is None:
         return None
-    raise ValueError("could not generate shape for type %s" % shape.type_name)
+    raise ValueError(f"could not generate shape for type {shape.type_name}")
 
 
 @generate_instance.register
-def _(shape: StructureShape, graph: ShapeGraph) -> Dict[str, Instance]:
+def _(shape: StructureShape, graph: ShapeGraph) -> dict[str, Instance]:
     if shape.is_tagged_union:
         k, v = random.choice(list(shape.members.items()))
         members = {k: v}
@@ -255,14 +246,14 @@ def _(shape: StructureShape, graph: ShapeGraph) -> Dict[str, Instance]:
 
 
 @generate_instance.register
-def _(shape: ListShape, graph: ShapeGraph) -> List[Instance]:
+def _(shape: ListShape, graph: ShapeGraph) -> list[Instance]:
     if shape.name in graph.cycle_shapes:
         return []
     return [generate_instance(shape.member, graph) for _ in range(shape.metadata.get("min", 1))]
 
 
 @generate_instance.register
-def _(shape: MapShape, graph: ShapeGraph) -> Dict[str, Instance]:
+def _(shape: MapShape, graph: ShapeGraph) -> dict[str, Instance]:
     if shape.name in graph.cycle_shapes:
         return {}
     return {generate_instance(shape.key, graph): generate_instance(shape.value, graph)}
@@ -379,7 +370,7 @@ def _(shape: StringShape, graph: ShapeGraph) -> str:
 
 
 @generate_instance.register
-def _(shape: Shape, graph: ShapeGraph) -> Union[int, float, bool, bytes, date]:
+def _(shape: Shape, graph: ShapeGraph) -> int | float | bool | bytes | date:
     if shape.type_name in ["integer", "long"]:
         return shape.metadata.get("min", 1)
     if shape.type_name in ["float", "double"]:
@@ -392,7 +383,7 @@ def _(shape: Shape, graph: ShapeGraph) -> Union[int, float, bool, bytes, date]:
     if shape.type_name == "timestamp":
         return datetime.now()
 
-    raise ValueError("unknown type %s" % shape.type_name)
+    raise ValueError(f"unknown type {shape.type_name}")
 
 
 def generate_response(operation: OperationModel):
@@ -427,7 +418,7 @@ def create_mocking_dispatch_table(service) -> DispatchTable:
     return dispatch_table
 
 
-@lru_cache()
+@lru_cache
 def get_mocking_skeleton(service: str) -> Skeleton:
     service = load_service(service)
     return Skeleton(service, create_mocking_dispatch_table(service))

localstack/aws/patches.py

@@ -20,12 +20,12 @@ def patch_moto_instance_tracker_meta():
         cls = super(InstanceTrackerMeta, meta).__new__(meta, name, bases, dct)
         if name == "BaseModel":
             return cls
-        cls.instances = []
+        cls.instances_tracked = []
         return cls
 
     @patch(BaseModel.__new__, pass_target=False)
     def new_basemodel(cls, *args, **kwargs):
-        # skip cls.instances.append(..) which is done by the original/upstream constructor
+        # skip cls.instances_tracked.append(..) which is done by the original/upstream constructor
         instance = super(BaseModel, cls).__new__(cls)
         return instance
 

localstack/aws/protocol/op_router.py

@@ -1,5 +1,6 @@
 from collections import defaultdict
-from typing import Any, Dict, List, Mapping, NamedTuple, Optional, Tuple
+from collections.abc import Mapping
+from typing import Any, NamedTuple
 from urllib.parse import parse_qs, unquote
 
 from botocore.model import OperationModel, ServiceModel, StructureShape
@@ -24,8 +25,8 @@ class _HttpOperation(NamedTuple):
     operation: OperationModel
     path: str
     method: str
-    query_args: Mapping[str, List[str]]
-    header_args: List[str]
+    query_args: Mapping[str, list[str]]
+    header_args: list[str]
     deprecated: bool
 
     @staticmethod
@@ -49,11 +50,11 @@ class _HttpOperation(NamedTuple):
         path_query = uri.split("?")
         path = path_query[0]
         header_args = []
-        query_args: Dict[str, List[str]] = {}
+        query_args: dict[str, list[str]] = {}
 
         if len(path_query) > 1:
             # parse the query args of the request URI (they are mandatory)
-            query_args: Dict[str, List[str]] = parse_qs(path_query[1], keep_blank_values=True)
+            query_args: dict[str, list[str]] = parse_qs(path_query[1], keep_blank_values=True)
             # for mandatory keys without values, keep an empty list (instead of [''] - the result of parse_qs)
             query_args = {k: filter(None, v) for k, v in query_args.items()}
 
@@ -85,8 +86,8 @@ class _RequiredArgsRule:
     """
 
     endpoint: Any
-    required_query_args: Optional[Mapping[str, List[Any]]]
-    required_header_args: List[str]
+    required_query_args: Mapping[str, list[Any]] | None
+    required_header_args: list[str]
     match_score: int
 
     def __init__(self, operation: _HttpOperation) -> None:
@@ -139,7 +140,7 @@ class _RequestMatchingRule(StrictMethodRule):
     """
 
     def __init__(
-        self, string: str, operations: List[_HttpOperation], method: str, **kwargs
+        self, string: str, operations: list[_HttpOperation], method: str, **kwargs
     ) -> None:
         super().__init__(string=string, method=method, **kwargs)
         # Create a rule which checks all required arguments (not only the path and method)
@@ -174,7 +175,7 @@ def _create_service_map(service: ServiceModel) -> Map:
     rules = []
 
     # group all operations by their path and method
-    path_index: Dict[(str, str), List[_HttpOperation]] = defaultdict(list)
+    path_index: dict[(str, str), list[_HttpOperation]] = defaultdict(list)
     for op in ops:
         http_op = _HttpOperation.from_operation(op)
         path_index[(http_op.path, http_op.method)].append(http_op)
@@ -216,7 +217,7 @@ class RestServiceOperationRouter:
     def __init__(self, service: ServiceModel):
         self._map = _create_service_map(service)
 
-    def match(self, request: Request) -> Tuple[OperationModel, Mapping[str, Any]]:
+    def match(self, request: Request) -> tuple[OperationModel, Mapping[str, Any]]:
         """
         Matches the given request to the operation it targets (or raises an exception if no operation matches).