localstack-core 4.10.1.dev7__py3-none-any.whl → 4.11.2.dev14__py3-none-any.whl

localstack/aws/handlers/logging.py

@@ -1,7 +1,6 @@
 """Handlers for logging."""
 
 import logging
-import types
 from functools import cached_property
 
 from localstack.aws.api import RequestContext, ServiceException
@@ -25,10 +24,14 @@ class ExceptionLogger(ExceptionHandler):
         try:
             import moto.core.exceptions
 
-            self._moto_service_exception = moto.core.exceptions.ServiceException
+            self._skip_exceptions(
+                ServiceException,
+                moto.core.exceptions.ServiceException,
+                moto.core.exceptions.RESTError,
+            )
         except (ModuleNotFoundError, AttributeError):
             # Moto may not be available in stripped-down versions of LocalStack, like LocalStack S3 image.
-            self._moto_service_exception = types.EllipsisType
+            self._skip_exceptions = (ServiceException,)
 
     def __call__(
         self,
@@ -37,11 +40,12 @@ class ExceptionLogger(ExceptionHandler):
         context: RequestContext,
         response: Response,
     ):
-        if isinstance(exception, (ServiceException, self._moto_service_exception)):
+        if isinstance(exception, self._skip_exceptions):
             # We do not want to log an error/stacktrace if the handler is working as expected, but chooses to throw
             # a service exception. It may also throw a Moto ServiceException, which should not be logged either
             # because ServiceExceptionHandler understands it.
             return
+
         if self.logger.isEnabledFor(level=logging.DEBUG):
             self.logger.exception("exception during call chain", exc_info=exception)
         else:

localstack/aws/handlers/service.py

@@ -7,6 +7,7 @@ from collections import defaultdict
 from typing import Any
 
 from botocore.model import OperationModel, ServiceModel
+from plux.core.plugin import PluginDisabled
 
 from localstack import config
 from localstack.http import Response
@@ -157,14 +158,17 @@ class ServiceExceptionSerializer(ExceptionHandler):
     def __init__(self):
         self.handle_internal_failures = True
 
+        self._moto_service_exception = types.EllipsisType
+        self._moto_rest_error = types.EllipsisType
+
         try:
             import moto.core.exceptions
 
             self._moto_service_exception = moto.core.exceptions.ServiceException
+            self._moto_rest_error = moto.core.exceptions.RESTError
         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
+            LOG.debug("Unable to set up Moto exception translation: %s", exc)
 
     def __call__(
         self,
@@ -199,6 +203,12 @@ class ServiceExceptionSerializer(ExceptionHandler):
                 code=exception.code,
                 message=exception.message,
             )
+        elif isinstance(exception, self._moto_rest_error):
+            # Some Moto exceptions (like ones raised by EC2) are of type RESTError.
+            error = CommonServiceException(
+                code=exception.error_type,
+                message=exception.message,
+            )
 
         elif not isinstance(exception, ServiceException):
             if not self.handle_internal_failures:
@@ -222,7 +232,16 @@ class ServiceExceptionSerializer(ExceptionHandler):
                 operation = context.service.operation_model(context.service.operation_names[0])
                 msg = f"exception while calling {service_name} with unknown operation: {message}"
 
-            status_code = 501 if config.FAIL_FAST else 500
+            # Check for license restricted plugin message and set status code to 501
+            if (
+                isinstance(exception, PluginDisabled)
+                and "not part of the active license agreement"
+                in str(getattr(exception, "reason", "")).lower()
+            ):
+                status_code = 501
+                msg = f"exception while calling {service_name}.{operation.name}: {str(getattr(exception, 'reason', ''))}"
+            else:
+                status_code = 501 if config.FAIL_FAST else 500
 
             error = CommonServiceException(
                 "InternalError", msg, status_code=status_code

localstack/aws/protocol/parser.py

@@ -1032,7 +1032,7 @@ class BaseCBORRequestParser(RequestParser, ABC):
             return method(stream, additional_info)
         else:
             raise ProtocolParserError(
-                f"Unsupported inital byte found for data item- "
+                f"Unsupported initial byte found for data item- "
                 f"Major type:{major_type}, Additional info: "
                 f"{additional_info}"
             )

localstack/aws/protocol/serializer.py

@@ -2192,7 +2192,7 @@ class S3ResponseSerializer(RestXMLResponseSerializer):
 
     def _prepare_additional_traits_in_xml(self, root: ETree.Element | None, request_id: str):
         # some tools (Serverless) require a newline after the "<?xml ...>\n" preamble line, e.g., for LocationConstraint
-        if root and not root.tail:
+        if root is not None and not root.tail:
             root.tail = "\n"
 
         root.attrib["xmlns"] = self.XML_NAMESPACE

localstack/aws/scaffold.py

@@ -188,9 +188,7 @@ class ShapeNode:
             if member in self.shape.required_members:
                 output.write(f"    {member}: IO[{q}{to_valid_python_name(shape.name)}{q}]\n")
             else:
-                output.write(
-                    f"    {member}: Optional[IO[{q}{to_valid_python_name(shape.name)}{q}]]\n"
-                )
+                output.write(f"    {member}: {q}IO[{to_valid_python_name(shape.name)}] | None{q}\n")
             del remaining_members[member]
         # render the streaming payload first
         if self.is_response and self.response_operation.has_streaming_output:
@@ -199,25 +197,26 @@ class ShapeNode:
             shape_name = to_valid_python_name(shape.name)
             if member in self.shape.required_members:
                 output.write(
-                    f"    {member}: Union[{q}{shape_name}{q}, IO[{q}{shape_name}{q}], Iterable[{q}{shape_name}{q}]]\n"
+                    f"    {member}: {q}{shape_name} | IO[{shape_name}] | Iterable[{shape_name}]{q}\n"
                 )
             else:
                 output.write(
-                    f"    {member}: Optional[Union[{q}{shape_name}{q}, IO[{q}{shape_name}{q}], Iterable[{q}{shape_name}{q}]]]\n"
+                    f"    {member}: {q}{shape_name} | IO[{shape_name}] | Iterable[{shape_name}] | None{q}\n"
                 )
             del remaining_members[member]
 
         for k, v in remaining_members.items():
+            shape_name = to_valid_python_name(v.name)
             if k in self.shape.required_members:
                 if v.serialization.get("eventstream"):
-                    output.write(f"    {k}: Iterator[{q}{to_valid_python_name(v.name)}{q}]\n")
+                    output.write(f"    {k}: Iterator[{q}{shape_name}{q}]\n")
                 else:
-                    output.write(f"    {k}: {q}{to_valid_python_name(v.name)}{q}\n")
+                    output.write(f"    {k}: {q}{shape_name}{q}\n")
             else:
                 if v.serialization.get("eventstream"):
-                    output.write(f"    {k}: Iterator[{q}{to_valid_python_name(v.name)}{q}]\n")
+                    output.write(f"    {k}: Iterator[{q}{shape_name}{q}]\n")
                 else:
-                    output.write(f"    {k}: Optional[{q}{to_valid_python_name(v.name)}{q}]\n")
+                    output.write(f"    {k}: {q}{shape_name} | None{q}\n")
 
     def _print_as_typed_dict(self, output, doc=True, quote_types=False):
         name = to_valid_python_name(self.shape.name)
@@ -236,7 +235,7 @@ class ShapeNode:
                 if v.serialization.get("eventstream"):
                     output.write(f'    "{k}": Iterator[{q}{member_name}{q}],\n')
                 else:
-                    output.write(f'    "{k}": Optional[{q}{member_name}{q}],\n')
+                    output.write(f'    "{k}": {q}{member_name} | None{q},\n')
         output.write("}, total=False)")
 
     def print_shape_doc(self, output, shape):
@@ -256,11 +255,11 @@ class ShapeNode:
             self._print_structure_declaration(output, doc, quote_types)
         elif isinstance(shape, ListShape):
             output.write(
-                f"{to_valid_python_name(shape.name)} = List[{q}{to_valid_python_name(shape.member.name)}{q}]"
+                f"{to_valid_python_name(shape.name)} = list[{q}{to_valid_python_name(shape.member.name)}{q}]"
             )
         elif isinstance(shape, MapShape):
             output.write(
-                f"{to_valid_python_name(shape.name)} = Dict[{q}{to_valid_python_name(shape.key.name)}{q}, {q}{to_valid_python_name(shape.value.name)}{q}]"
+                f"{to_valid_python_name(shape.name)} = dict[{q}{to_valid_python_name(shape.key.name)}{q}, {q}{to_valid_python_name(shape.value.name)}{q}]"
             )
         elif isinstance(shape, StringShape):
             if shape.enum:
@@ -316,9 +315,8 @@ class ShapeNode:
 def generate_service_types(output, service: ServiceModel, doc=True):
     output.write("from datetime import datetime\n")
     output.write("from enum import StrEnum\n")
-    output.write(
-        "from typing import Dict, List, Optional, Iterator, Iterable, IO, Union, TypedDict\n"
-    )
+    output.write("from typing import IO, TypedDict\n")
+    output.write("from collections.abc import Iterable, Iterator\n")
     output.write("\n")
     output.write(
         "from localstack.aws.api import handler, RequestContext, ServiceException, ServiceRequest"
@@ -372,8 +370,8 @@ def generate_service_api(output, service: ServiceModel, doc=True):
 
     output.write(f"class {class_name}:\n")
     output.write("\n")
-    output.write(f'    service = "{service.service_name}"\n')
-    output.write(f'    version = "{service.api_version}"\n')
+    output.write(f'    service: str = "{service.service_name}"\n')
+    output.write(f'    version: str = "{service.api_version}"\n')
     for op_name in service.operation_names:
         operation: OperationModel = service.operation_model(op_name)
 

localstack/cli/localstack.py

@@ -433,7 +433,7 @@ def _print_service_table(services: dict[str, str]) -> None:
 
 @localstack.command(name="start", short_help="Start LocalStack")
 @click.option("--docker", is_flag=True, help="Start LocalStack in a docker container [default]")
-@click.option("--host", is_flag=True, help="Start LocalStack directly on the host")
+@click.option("--host", is_flag=True, help="Start LocalStack directly on the host", deprecated=True)
 @click.option("--no-banner", is_flag=True, help="Disable LocalStack banner", default=False)
 @click.option(
     "-d", "--detached", is_flag=True, help="Start LocalStack in the background", default=False
@@ -532,6 +532,11 @@ def cmd_start(
             console.log("starting LocalStack in Docker mode :whale:")
 
     if host:
+        console.log(
+            "Warning: Starting LocalStack in host mode from the CLI is deprecated and will be removed soon. Please use the default Docker mode instead.",
+            style="bold red",
+        )
+
         # call hooks to prepare host
         bootstrap.prepare_host(console)
 

localstack/deprecations.py

@@ -35,12 +35,6 @@ class EnvVarDeprecation:
 # Please make sure this is in-sync with https://docs.localstack.cloud/references/configuration/
 #
 DEPRECATIONS = [
-    # Since 0.11.3 - HTTP / HTTPS multiplexing
-    EnvVarDeprecation(
-        "USE_SSL",
-        "0.11.3",
-        "Each endpoint now supports multiplexing HTTP/HTTPS traffic over the same port. Please remove this environment variable.",  # noqa
-    ),
     # Since 0.12.8 - PORT_UI was removed
     EnvVarDeprecation(
         "PORT_WEB_UI",

localstack/dev/kubernetes/__main__.py

@@ -9,6 +9,7 @@ EDGE_SERVICE_NODE_PORT = 30066
 NODE_PORT_START = 30010
 SERVICE_PORT_START = 4510
 NUMBER_OF_SERVICE_PORTS = 50
+EDGE_SERVICE_DNS_PORT = 31053
 
 
 @dataclasses.dataclass
@@ -144,7 +145,12 @@ def generate_mount_points(
     return mount_points
 
 
-def generate_k8s_cluster_config(mount_points: list[MountPoint], port: int = 4566):
+def generate_k8s_cluster_config(
+    mount_points: list[MountPoint],
+    port: int = 4566,
+    expose_dns: bool = False,
+    dns_port: int = 53,
+):
     volumes = [
         {
             "volume": f"{mount_point.host_path}:{mount_point.node_path}",
@@ -177,6 +183,16 @@ def generate_k8s_cluster_config(mount_points: list[MountPoint], port: int = 4566
         },
     ]
 
+    if expose_dns:
+        ports.append(
+            {
+                "nodeFilters": [
+                    "server:0",
+                ],
+                "port": f"{dns_port}:{EDGE_SERVICE_DNS_PORT}",
+            }
+        )
+
     config = {
         "apiVersion": "k3d.io/v1alpha5",
         "kind": "Simple",
@@ -279,7 +295,10 @@ def generate_k8s_helm_overrides(
             "end": SERVICE_PORT_START + NUMBER_OF_SERVICE_PORTS,
             "nodePortStart": NODE_PORT_START,
         },
-        "dnsService": True,
+        "dnsService": {
+            "enabled": True,
+            "nodePort": EDGE_SERVICE_DNS_PORT,
+        },
     }
     overrides = {
         "debug": True,
@@ -355,6 +374,18 @@ def print_file(content: dict, file_name: str):
     help="Port to expose from the kubernetes node",
     type=click.IntRange(0, 65535),
 )
+@click.option(
+    "--expose-dns",
+    is_flag=True,
+    default=False,
+    help="Expose DNS port from the kubernetes node.",
+)
+@click.option(
+    "--dns-port",
+    default=53,
+    help="DNS port to expose from the kubernetes node. It is applied only if --expose-dns is set.",
+    type=click.IntRange(0, 65535),
+)
 @click.argument("command", nargs=-1, required=False)
 def run(
     pro: bool = None,
@@ -367,13 +398,17 @@ def run(
     command: str = None,
     env: list[str] = None,
     port: int = None,
+    expose_dns: bool = False,
+    dns_port: int = 53,
 ):
     """
     A tool for localstack developers to generate the kubernetes cluster configuration file and the overrides to mount the localstack code into the cluster.
     """
     mount_points = generate_mount_points(pro, mount_moto, mount_entrypoints)
 
-    config = generate_k8s_cluster_config(mount_points, port=port)
+    config = generate_k8s_cluster_config(
+        mount_points, port=port, expose_dns=expose_dns, dns_port=dns_port
+    )
 
     overrides = generate_k8s_helm_overrides(mount_points, pro=pro, env=env)
 

localstack/services/acm/provider.py

@@ -10,6 +10,7 @@ from localstack.aws.api.acm import (
     RequestCertificateResponse,
 )
 from localstack.services import moto
+from localstack.state import StateVisitor
 from localstack.utils.patch import patch
 
 # reduce the validation wait time from 60 (default) to 10 seconds
@@ -100,6 +101,9 @@ def describe(describe_orig, self):
 
 
 class AcmProvider(AcmApi):
+    def accept_state_visitor(self, visitor: StateVisitor):
+        visitor.visit(acm_models.acm_backends)
+
     @handler("RequestCertificate", expand=False)
     def request_certificate(
         self,

localstack/services/apigateway/helpers.py

@@ -23,7 +23,7 @@ from localstack.aws.api.apigateway import (
     IntegrationType,
     Model,
     NotFoundException,
-    PutRestApiRequest,
+    PutMode,
     RequestValidator,
 )
 from localstack.constants import (
@@ -39,8 +39,7 @@ from localstack.services.apigateway.models import (
     apigateway_stores,
 )
 from localstack.utils import common
-from localstack.utils.json import parse_json_or_yaml
-from localstack.utils.strings import short_uid, to_bytes, to_str
+from localstack.utils.strings import short_uid, to_bytes
 from localstack.utils.urls import localstack_host
 
 LOG = logging.getLogger(__name__)
@@ -472,11 +471,9 @@ def add_documentation_parts(rest_api_container, documentation):
 
 
 def import_api_from_openapi_spec(
-    rest_api: MotoRestAPI, context: RequestContext, request: PutRestApiRequest
+    rest_api: MotoRestAPI, context: RequestContext, open_api_spec: dict, mode: PutMode
 ) -> tuple[MotoRestAPI, list[str]]:
     """Import an API from an OpenAPI spec document"""
-    body = parse_json_or_yaml(to_str(request["body"].read()))
-
     warnings = []
 
     # TODO There is an issue with the botocore specs so the parameters doesn't get populated as it should
@@ -484,15 +481,14 @@ def import_api_from_openapi_spec(
     # query_params = request.get("parameters") or {}
     query_params: dict = context.request.values.to_dict()
 
-    resolved_schema = resolve_references(copy.deepcopy(body), rest_api_id=rest_api.id)
+    resolved_schema = resolve_references(copy.deepcopy(open_api_spec), rest_api_id=rest_api.id)
     account_id = context.account_id
     region_name = context.region
 
     # TODO:
-    # 1. validate the "mode" property of the spec document, "merge" or "overwrite", and properly apply it
+    # 1. properly apply the mode (overwrite or merge)
     #    for now, it only considers it for the binaryMediaTypes
     # 2. validate the document type, "swagger" or "openapi"
-    mode = request.get("mode", "merge")
 
     rest_api.version = (
         str(version) if (version := resolved_schema.get("info", {}).get("version")) else None

localstack/services/apigateway/legacy/provider.py

@@ -42,6 +42,7 @@ from localstack.aws.api.apigateway import (
     DomainName,
     DomainNames,
     DomainNameStatus,
+    EndpointAccessMode,
     EndpointConfiguration,
     EndpointType,
     ExportResponse,
@@ -117,7 +118,11 @@ from localstack.services.apigateway.helpers import (
 from localstack.services.apigateway.legacy.helpers import multi_value_dict_for_list
 from localstack.services.apigateway.legacy.invocations import invoke_rest_api_from_request
 from localstack.services.apigateway.legacy.router_asf import ApigatewayRouter, to_invocation_context
-from localstack.services.apigateway.models import ApiGatewayStore, RestApiContainer
+from localstack.services.apigateway.models import (
+    ApiGatewayStore,
+    RestApiContainer,
+    apigateway_stores,
+)
 from localstack.services.apigateway.next_gen.execute_api.router import (
     ApiGatewayRouter as ApiGatewayRouterNextGen,
 )
@@ -125,6 +130,7 @@ from localstack.services.apigateway.patches import apply_patches
 from localstack.services.edge import ROUTER
 from localstack.services.moto import call_moto, call_moto_with_request
 from localstack.services.plugins import ServiceLifecycleHook
+from localstack.state import StateVisitor
 from localstack.utils.aws.arns import InvalidArnException, get_partition, parse_arn
 from localstack.utils.collections import (
     DelSafeDict,
@@ -191,6 +197,12 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
         apply_patches()
         self.router.register_routes()
 
+    def accept_state_visitor(self, visitor: StateVisitor):
+        from moto.apigateway import apigateway_backends
+
+        visitor.visit(apigateway_backends)
+        visitor.visit(apigateway_stores)
+
     @handler("TestInvokeMethod", expand=False)
     def test_invoke_method(
         self, context: RequestContext, request: TestInvokeMethodRequest
@@ -476,11 +488,19 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
 
     @handler("PutRestApi", expand=False)
     def put_rest_api(self, context: RequestContext, request: PutRestApiRequest) -> RestApi:
+        body_data = request["body"].read()
+        try:
+            openapi_spec = parse_json_or_yaml(to_str(body_data))
+        except Exception:
+            raise BadRequestException("Invalid OpenAPI input.")
         # TODO: take into account the mode: overwrite or merge
         # the default is now `merge`, but we are removing everything
         rest_api = get_moto_rest_api(context, request["restApiId"])
         rest_api, warnings = import_api_from_openapi_spec(
-            rest_api, context=context, request=request
+            rest_api,
+            context=context,
+            open_api_spec=openapi_spec,
+            mode=request.get("mode") or PutMode.merge,
         )
 
         rest_api.root_resource_id = get_moto_rest_api_root_resource(rest_api)
@@ -503,20 +523,21 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
         self,
         context: RequestContext,
         domain_name: String,
-        certificate_name: String = None,
-        certificate_body: String = None,
-        certificate_private_key: String = None,
-        certificate_chain: String = None,
-        certificate_arn: String = None,
-        regional_certificate_name: String = None,
-        regional_certificate_arn: String = None,
-        endpoint_configuration: EndpointConfiguration = None,
-        tags: MapOfStringToString = None,
-        security_policy: SecurityPolicy = None,
-        mutual_tls_authentication: MutualTlsAuthenticationInput = None,
-        ownership_verification_certificate_arn: String = None,
-        policy: String = None,
-        routing_mode: RoutingMode = None,
+        certificate_name: String | None = None,
+        certificate_body: String | None = None,
+        certificate_private_key: String | None = None,
+        certificate_chain: String | None = None,
+        certificate_arn: String | None = None,
+        regional_certificate_name: String | None = None,
+        regional_certificate_arn: String | None = None,
+        endpoint_configuration: EndpointConfiguration | None = None,
+        tags: MapOfStringToString | None = None,
+        security_policy: SecurityPolicy | None = None,
+        endpoint_access_mode: EndpointAccessMode | None = None,
+        mutual_tls_authentication: MutualTlsAuthenticationInput | None = None,
+        ownership_verification_certificate_arn: String | None = None,
+        policy: String | None = None,
+        routing_mode: RoutingMode | None = None,
         **kwargs,
     ) -> DomainName:
         if not domain_name:
@@ -1512,7 +1533,10 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
         **kwargs,
     ) -> DocumentationPartIds:
         body_data = body.read()
-        openapi_spec = parse_json_or_yaml(to_str(body_data))
+        try:
+            openapi_spec = parse_json_or_yaml(to_str(body_data))
+        except Exception:
+            raise BadRequestException("Unable to build importer with provided input.")
 
         rest_api_container = get_rest_api_container(context, rest_api_id=rest_api_id)
 
@@ -2012,7 +2036,11 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
         body_data = body.read()
 
         # create rest api
-        openapi_spec = parse_json_or_yaml(to_str(body_data))
+        try:
+            openapi_spec = parse_json_or_yaml(to_str(body_data))
+        except Exception:
+            raise BadRequestException("Invalid OpenAPI input.")
+
         create_api_request = CreateRestApiRequest(name=openapi_spec.get("info").get("title"))
         create_api_context = create_custom_context(
             context,
@@ -2053,12 +2081,20 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
         **kwargs,
     ) -> Integration:
         try:
-            response: Integration = call_moto(context)
-        except CommonServiceException as e:
-            # the Exception raised by moto does not have the right message not status code
-            if e.code == "NotFoundException":
-                raise NotFoundException("Invalid Integration identifier specified")
-            raise
+            moto_rest_api = get_moto_rest_api(context, rest_api_id)
+        except NotFoundException:
+            raise NotFoundException("Invalid Resource identifier specified")
+
+        if not (moto_resource := moto_rest_api.resources.get(resource_id)):
+            raise NotFoundException("Invalid Resource identifier specified")
+
+        if not (moto_method := moto_resource.resource_methods.get(http_method)):
+            raise NotFoundException("Invalid Method identifier specified")
+
+        if not moto_method.method_integration:
+            raise NotFoundException("Invalid Integration identifier specified")
+
+        response: Integration = call_moto(context)
 
         if integration_responses := response.get("integrationResponses"):
             for integration_response in integration_responses.values():

localstack/services/apigateway/patches.py

@@ -5,7 +5,6 @@ import logging
 from moto.apigateway import models as apigateway_models
 from moto.apigateway.exceptions import (
     DeploymentNotFoundException,
-    NoIntegrationDefined,
     RestAPINotFound,
     StageStillActive,
 )
@@ -113,14 +112,6 @@ def apply_patches():
         )
         return result
 
-    # patch integration error responses
-    @patch(apigateway_models.Resource.get_integration)
-    def apigateway_models_resource_get_integration(fn, self, method_type):
-        resource_method = self.resource_methods.get(method_type, {})
-        if not resource_method.method_integration:
-            raise NoIntegrationDefined()
-        return resource_method.method_integration
-
     @patch(apigateway_models.RestAPI.to_dict)
     def apigateway_models_rest_api_to_dict(fn, self):
         resp = fn(self)

localstack/services/cloudformation/engine/template_preparer.py

@@ -6,6 +6,7 @@ from localstack.services.cloudformation.engine.transformers import (
     apply_global_transformations,
     apply_intrinsic_transformations,
 )
+from localstack.services.cloudformation.engine.validations import ValidationError
 from localstack.utils.json import clone_safe
 
 LOG = logging.getLogger(__name__)
@@ -17,9 +18,12 @@ def parse_template(template: str) -> dict:
     except Exception:
         try:
             return clone_safe(yaml_parser.parse_yaml(template))
-        except Exception as e:
-            LOG.debug("Unable to parse CloudFormation template (%s): %s", e, template)
+        except ValidationError:
+            # The error is handled in the yaml parsing helper
             raise
+        except Exception:
+            # TODO: present the user with a better error message including error location
+            raise ValidationError("Template format error: YAML not well-formed.")
 
 
 def template_to_json(template: str) -> str:

localstack/services/cloudformation/engine/v2/change_set_model_preproc.py

@@ -677,6 +677,13 @@ class ChangeSetModelPreproc(ChangeSetModelVisitor):
             node_condition = self._get_node_condition_if_exists(
                 condition_name=condition_delta.before
             )
+            if is_nothing(node_condition):
+                # TODO: I don't think this is a possible state since for us to be evaluating the before state,
+                #  we must have successfully deployed the stack and as such this case was not reached before
+                raise ValidationError(
+                    f"Template error: unresolved condition dependency {condition_delta.before} in Fn::If"
+                )
+
             condition_value = self.visit(node_condition).before
             if condition_value:
                 arg_delta = self.visit(node_intrinsic_function.arguments.array[1])
@@ -688,6 +695,11 @@ class ChangeSetModelPreproc(ChangeSetModelVisitor):
             node_condition = self._get_node_condition_if_exists(
                 condition_name=condition_delta.after
             )
+            if is_nothing(node_condition):
+                raise ValidationError(
+                    f"Template error: unresolved condition dependency {condition_delta.after} in Fn::If"
+                )
+
             condition_value = self.visit(node_condition).after
             if condition_value:
                 arg_delta = self.visit(node_intrinsic_function.arguments.array[1])

localstack/services/cloudformation/provider.py

@@ -952,8 +952,8 @@ class CloudformationProvider(CloudformationApi):
     def describe_stack_events(
         self,
         context: RequestContext,
-        stack_name: StackName = None,
-        next_token: NextToken = None,
+        stack_name: StackName,
+        next_token: NextToken | None = None,
         **kwargs,
     ) -> DescribeStackEventsOutput:
         if stack_name is None: