localstack-core 4.7.1.dev49__py3-none-any.whl → 4.10.1.dev12__py3-none-any.whl

localstack/services/cloudformation/v2/provider.py

@@ -1,8 +1,10 @@
 import copy
 import json
 import logging
+import re
 from collections import defaultdict
 from datetime import UTC, datetime
+from urllib.parse import urlencode
 
 from localstack import config
 from localstack.aws.api import RequestContext, handler
@@ -13,6 +15,7 @@ from localstack.aws.api.cloudformation import (
     ChangeSetNameOrId,
     ChangeSetNotFoundException,
     ChangeSetStatus,
+    ChangeSetSummary,
     ChangeSetType,
     ClientRequestToken,
     CreateChangeSetInput,
@@ -44,6 +47,7 @@ from localstack.aws.api.cloudformation import (
     IncludePropertyValues,
     InsufficientCapabilitiesException,
     InvalidChangeSetStatusException,
+    ListChangeSetsOutput,
     ListExportsOutput,
     ListStackResourcesOutput,
     ListStacksOutput,
@@ -51,6 +55,7 @@ from localstack.aws.api.cloudformation import (
     NextToken,
     Parameter,
     PhysicalResourceId,
+    ResourceStatus,
     RetainExceptOnCreate,
     RetainResources,
     RoleARN,
@@ -80,6 +85,7 @@ from localstack.aws.connect import connect_to
 from localstack.services.cloudformation import api_utils
 from localstack.services.cloudformation.engine import template_preparer
 from localstack.services.cloudformation.engine.parameters import resolve_ssm_parameter
+from localstack.services.cloudformation.engine.transformers import FailedTransformationException
 from localstack.services.cloudformation.engine.v2.change_set_model import (
     ChangeSetModel,
     ChangeType,
@@ -114,13 +120,19 @@ from localstack.services.cloudformation.v2.entities import (
     StackInstance,
     StackSet,
 )
-from localstack.services.cloudformation.v2.types import EngineParameter
+from localstack.services.cloudformation.v2.types import EngineParameter, engine_parameter_value
+from localstack.services.plugins import ServiceLifecycleHook
 from localstack.utils.collections import select_attributes
+from localstack.utils.numbers import is_number
 from localstack.utils.strings import short_uid
 from localstack.utils.threads import start_worker_thread
 
 LOG = logging.getLogger(__name__)
 
+SSM_PARAMETER_TYPE_RE = re.compile(
+    r"^AWS::SSM::Parameter::Value<(?P<listtype>List<)?(?P<innertype>[^>]+)>?>$"
+)
+
 
 def is_stack_arn(stack_name_or_id: str) -> bool:
     return ARN_STACK_REGEX.match(stack_name_or_id) is not None
@@ -208,10 +220,35 @@ def find_stack_instance(stack_set: StackSet, account: str, region: str) -> Stack
     return None
 
 
-class CloudformationProviderV2(CloudformationProvider):
+class CloudformationProviderV2(CloudformationProvider, ServiceLifecycleHook):
+    def on_before_start(self):
+        base = "https://github.com/localstack/localstack/issues/new"
+        query_args = {
+            "template": "bug-report.yml",
+            "labels": ",".join(
+                [
+                    "aws:cloudformation:v2",
+                    "status: triage needed",
+                    "type: bug",
+                ]
+            ),
+            "title": "CFNV2: ",
+        }
+        issue_url = "?".join([base, urlencode(query_args)])
+        LOG.info(
+            "You have opted in to the new CloudFormation deployment engine. "
+            "You can opt in to using the old engine by setting PROVIDER_OVERRIDE_CLOUDFORMATION=engine-legacy. "
+            "If you experience issues, please submit a bug report at this URL: %s",
+            issue_url,
+        )
+
     @staticmethod
     def _resolve_parameters(
-        template: dict | None, parameters: dict | None, account_id: str, region_name: str
+        template: dict | None,
+        parameters: dict | None,
+        account_id: str,
+        region_name: str,
+        before_parameters: dict | None,
     ) -> dict[str, EngineParameter]:
         template_parameters = template.get("Parameters", {})
         resolved_parameters = {}
@@ -220,19 +257,57 @@ class CloudformationProviderV2(CloudformationProvider):
             given_value = parameters.get(name)
             default_value = parameter.get("Default")
             resolved_parameter = EngineParameter(
-                type_=parameter["Type"], given_value=given_value, default_value=default_value
+                type_=parameter["Type"],
+                given_value=given_value,
+                default_value=default_value,
+                no_echo=parameter.get("NoEcho"),
             )
 
-            if parameter["Type"] == "AWS::SSM::Parameter::Value<String>":
-                # TODO: support other parameter types
-                try:
-                    resolved_parameter["resolved_value"] = resolve_ssm_parameter(
-                        account_id, region_name, given_value or default_value
-                    )
-                except Exception:
-                    raise ValidationError(
-                        f"Parameter {name} should either have input value or default value"
-                    )
+            # validate the type
+            if parameter["Type"] == "Number" and not is_number(
+                engine_parameter_value(resolved_parameter)
+            ):
+                raise ValidationError(f"Parameter '{name}' must be a number.")
+
+            # TODO: support other parameter types
+            if match := SSM_PARAMETER_TYPE_RE.match(parameter["Type"]):
+                inner_type = match.group("innertype")
+                is_list_type = match.group("listtype") is not None
+                if is_list_type or inner_type == "CommaDelimitedList":
+                    # list types
+                    try:
+                        resolved_value = resolve_ssm_parameter(
+                            account_id, region_name, given_value or default_value
+                        )
+                        resolved_parameter["resolved_value"] = resolved_value.split(",")
+                    except Exception:
+                        raise ValidationError(
+                            f"Parameter {name} should either have input value or default value"
+                        )
+                else:
+                    try:
+                        resolved_parameter["resolved_value"] = resolve_ssm_parameter(
+                            account_id, region_name, given_value or default_value
+                        )
+                    except Exception as e:
+                        # we could not find the parameter however CDK provides the resolved value rather than the
+                        # parameter name again so try to look up the value in the previous parameters
+                        if (
+                            before_parameters
+                            and (before_param := before_parameters.get(name))
+                            and isinstance(before_param, dict)
+                            and (resolved_value := before_param.get("resolved_value"))
+                        ):
+                            LOG.debug(
+                                "Parameter %s could not be resolved, using previous value of %s",
+                                name,
+                                resolved_value,
+                            )
+                            resolved_parameter["resolved_value"] = resolved_value
+                        else:
+                            raise ValidationError(
+                                f"Parameter {name} should either have input value or default value"
+                            ) from e
             elif given_value is None and default_value is None:
                 invalid_parameters.append(name)
                 continue
@@ -262,7 +337,7 @@ class CloudformationProviderV2(CloudformationProvider):
         after_template: dict | None,
         before_parameters: dict | None,
         after_parameters: dict | None,
-        previous_update_model: UpdateModel | None,
+        previous_update_model: UpdateModel | None = None,
     ):
         resolved_parameters = None
         if after_parameters is not None:
@@ -271,6 +346,7 @@ class CloudformationProviderV2(CloudformationProvider):
                 after_parameters,
                 change_set.stack.account_id,
                 change_set.stack.region_name,
+                before_parameters,
             )
 
         change_set.resolved_parameters = resolved_parameters
@@ -299,9 +375,18 @@ class CloudformationProviderV2(CloudformationProvider):
             before_template=before_template,
             after_template=after_template,
         )
-        transformed_before_template, transformed_after_template = (
-            change_set_model_transform.transform()
-        )
+        try:
+            transformed_before_template, transformed_after_template = (
+                change_set_model_transform.transform()
+            )
+        except FailedTransformationException as e:
+            change_set.status = ChangeSetStatus.FAILED
+            change_set.status_reason = e.message
+            change_set.stack.set_stack_status(
+                status=StackStatus.ROLLBACK_IN_PROGRESS, reason=e.message
+            )
+            change_set.stack.set_stack_status(status=StackStatus.CREATE_FAILED)
+            return
 
         # Remodel the update graph after the applying the global transforms.
         change_set_model = ChangeSetModel(
@@ -317,6 +402,7 @@ class CloudformationProviderV2(CloudformationProvider):
         # the transformations.
         update_model.before_runtime_cache.update(raw_update_model.before_runtime_cache)
         update_model.after_runtime_cache.update(raw_update_model.after_runtime_cache)
+        change_set.set_update_model(update_model)
 
         # perform validations
         validator = ChangeSetModelValidator(
@@ -324,16 +410,19 @@ class CloudformationProviderV2(CloudformationProvider):
         )
         validator.validate()
 
-        change_set.set_update_model(update_model)
+        # hacky
+        if transform := raw_update_model.node_template.transform:
+            if transform.global_transforms:
+                # global transforms should always be considered "MODIFIED"
+                update_model.node_template.change_type = ChangeType.MODIFIED
         change_set.processed_template = transformed_after_template
 
     @handler("CreateChangeSet", expand=False)
     def create_change_set(
         self, context: RequestContext, request: CreateChangeSetInput
     ) -> CreateChangeSetOutput:
-        try:
-            stack_name = request["StackName"]
-        except KeyError:
+        stack_name = request.get("StackName")
+        if not stack_name:
             # TODO: proper exception
             raise ValidationError("StackName must be specified")
         try:
@@ -363,12 +452,19 @@ class CloudformationProviderV2(CloudformationProvider):
         template_body = api_utils.extract_template_body(request)
         structured_template = template_preparer.parse_template(template_body)
 
+        if len(template_body) > 51200 and not template_url:
+            raise ValidationError(
+                f"1 validation error detected: Value '{template_body}' at 'templateBody' "
+                "failed to satisfy constraint: Member must have length less than or equal to 51200"
+            )
+
         # this is intentionally not in a util yet. Let's first see how the different operations deal with these before generalizing
         # handle ARN stack_name here (not valid for initial CREATE, since stack doesn't exist yet)
         if is_stack_arn(stack_name):
             stack = state.stacks_v2.get(stack_name)
             if not stack:
                 raise ValidationError(f"Stack '{stack_name}' does not exist.")
+            stack.capabilities = request.get("Capabilities") or []
         else:
             # stack name specified, so fetch the stack by name
             stack_candidates: list[Stack] = [
@@ -389,6 +485,8 @@ class CloudformationProviderV2(CloudformationProvider):
                 if not active_stack_candidates:
                     raise ValidationError(f"Stack '{stack_name}' does not exist.")
                 stack = active_stack_candidates[0]
+                # propagate capabilities from create change set request
+                stack.capabilities = request.get("Capabilities") or []
 
         # TODO: test if rollback status is allowed as well
         if (
@@ -399,6 +497,14 @@ class CloudformationProviderV2(CloudformationProvider):
                 f"Stack [{stack_name}] already exists and cannot be created again with the changeSet [{change_set_name}]."
             )
 
+        if change_set_type == ChangeSetType.UPDATE and (
+            stack.status == StackStatus.DELETE_COMPLETE
+            or stack.status == StackStatus.DELETE_IN_PROGRESS
+        ):
+            raise ValidationError(
+                f"Stack:{stack.stack_id} is in {stack.status} state and can not be updated."
+            )
+
         before_parameters: dict[str, Parameter] | None = None
         match change_set_type:
             case ChangeSetType.UPDATE:
@@ -445,7 +551,12 @@ class CloudformationProviderV2(CloudformationProvider):
             pass
 
         # create change set for the stack and apply changes
-        change_set = ChangeSet(stack, request, template=after_template, template_body=template_body)
+        change_set = ChangeSet(
+            stack,
+            request,
+            template=after_template,
+            template_body=template_body,
+        )
         self._setup_change_set_model(
             change_set=change_set,
             before_template=before_template,
@@ -454,23 +565,21 @@ class CloudformationProviderV2(CloudformationProvider):
             after_parameters=after_parameters,
             previous_update_model=previous_update_model,
         )
-
-        # TODO: handle the empty change set case
-        if not change_set.has_changes():
-            change_set.set_change_set_status(ChangeSetStatus.FAILED)
+        if change_set.status == ChangeSetStatus.FAILED:
             change_set.set_execution_status(ExecutionStatus.UNAVAILABLE)
-            change_set.status_reason = "The submitted information didn't contain changes. Submit different information to create a change set."
         else:
-            if stack.status in [StackStatus.CREATE_COMPLETE, StackStatus.UPDATE_COMPLETE]:
-                stack.set_stack_status(StackStatus.UPDATE_IN_PROGRESS)
+            if not change_set.has_changes():
+                change_set.set_change_set_status(ChangeSetStatus.FAILED)
+                change_set.set_execution_status(ExecutionStatus.UNAVAILABLE)
+                change_set.status_reason = "The submitted information didn't contain changes. Submit different information to create a change set."
             else:
-                stack.set_stack_status(StackStatus.REVIEW_IN_PROGRESS)
+                if stack.status not in [StackStatus.CREATE_COMPLETE, StackStatus.UPDATE_COMPLETE]:
+                    stack.set_stack_status(StackStatus.REVIEW_IN_PROGRESS, "User Initiated")
 
-            change_set.set_change_set_status(ChangeSetStatus.CREATE_COMPLETE)
+                change_set.set_change_set_status(ChangeSetStatus.CREATE_COMPLETE)
 
-        stack.change_set_ids.append(change_set.change_set_id)
+        stack.change_set_ids.add(change_set.change_set_id)
         state.change_sets[change_set.change_set_id] = change_set
-
         return CreateChangeSetOutput(StackId=stack.stack_id, Id=change_set.change_set_id)
 
     @handler("ExecuteChangeSet")
@@ -505,6 +614,8 @@ class CloudformationProviderV2(CloudformationProvider):
             raise RuntimeError("Programming error: no update graph found for change set")
 
         change_set.set_execution_status(ExecutionStatus.EXECUTE_IN_PROGRESS)
+        # propagate the tags as this is done during execution
+        change_set.stack.tags = change_set.tags
         change_set.stack.set_stack_status(
             StackStatus.UPDATE_IN_PROGRESS
             if change_set.change_set_type == ChangeSetType.UPDATE
@@ -516,15 +627,22 @@ class CloudformationProviderV2(CloudformationProvider):
         )
 
         def _run(*args):
-            try:
-                result = change_set_executor.execute()
+            # TODO: should this be cleared before or after execution?
+            change_set.stack.status_reason = None
+            result = change_set_executor.execute()
+            change_set.stack.resolved_parameters = change_set.resolved_parameters
+            change_set.stack.resolved_resources = result.resources
+            change_set.stack.template = change_set.template
+            change_set.stack.processed_template = change_set.processed_template
+            change_set.stack.template_body = change_set.template_body
+            change_set.stack.description = change_set.template.get("Description")
+
+            if not result.failure_message:
                 new_stack_status = StackStatus.UPDATE_COMPLETE
                 if change_set.change_set_type == ChangeSetType.CREATE:
                     new_stack_status = StackStatus.CREATE_COMPLETE
                 change_set.stack.set_stack_status(new_stack_status)
                 change_set.set_execution_status(ExecutionStatus.EXECUTE_COMPLETE)
-                change_set.stack.resolved_resources = result.resources
-                change_set.stack.resolved_parameters = change_set.resolved_parameters
                 change_set.stack.resolved_outputs = result.outputs
 
                 change_set.stack.resolved_exports = {}
@@ -533,36 +651,80 @@ class CloudformationProviderV2(CloudformationProvider):
                         change_set.stack.resolved_exports[export_name] = output["OutputValue"]
 
                 change_set.stack.change_set_id = change_set.change_set_id
-                change_set.stack.change_set_ids.append(change_set.change_set_id)
-
-                # if the deployment succeeded, update the stack's template representation to that
-                # which was just deployed
-                change_set.stack.template = change_set.template
-                change_set.stack.description = change_set.template.get("Description")
-                change_set.stack.processed_template = change_set.processed_template
-                change_set.stack.template_body = change_set.template_body
-            except Exception as e:
+            else:
                 LOG.error(
                     "Execute change set failed: %s",
-                    e,
+                    result.failure_message,
                     exc_info=LOG.isEnabledFor(logging.DEBUG) and config.CFN_VERBOSE_ERRORS,
                 )
-                new_stack_status = StackStatus.UPDATE_FAILED
-                if change_set.change_set_type == ChangeSetType.CREATE:
-                    new_stack_status = StackStatus.CREATE_FAILED
-
-                change_set.stack.set_stack_status(new_stack_status)
+                # stack status is taken care of in the executor
                 change_set.set_execution_status(ExecutionStatus.EXECUTE_FAILED)
-                change_set.stack.change_set_id = change_set.change_set_id
-                change_set.stack.change_set_ids.append(change_set.change_set_id)
+                change_set.stack.deletion_time = datetime.now(tz=UTC)
 
         start_worker_thread(_run)
 
         return ExecuteChangeSetOutput()
 
-    def _describe_change_set(
-        self, change_set: ChangeSet, include_property_values: bool
+    @staticmethod
+    def _render_resolved_parameters(
+        resolved_parameters: dict[str, EngineParameter],
+    ) -> list[Parameter]:
+        result = []
+        for name, resolved_parameter in resolved_parameters.items():
+            parameter = Parameter(
+                ParameterKey=name,
+                ParameterValue=resolved_parameter.get("given_value")
+                or resolved_parameter.get("default_value"),
+            )
+            if resolved_value := resolved_parameter.get("resolved_value"):
+                parameter["ResolvedValue"] = resolved_value
+
+            # TODO :what happens to the resolved value?
+            if resolved_parameter.get("no_echo", False):
+                parameter["ParameterValue"] = "****"
+            result.append(parameter)
+
+        return result
+
+    @handler("DescribeChangeSet")
+    def describe_change_set(
+        self,
+        context: RequestContext,
+        change_set_name: ChangeSetNameOrId,
+        stack_name: StackNameOrId | None = None,
+        next_token: NextToken | None = None,
+        include_property_values: IncludePropertyValues | None = None,
+        **kwargs,
     ) -> DescribeChangeSetOutput:
+        # TODO add support for include_property_values
+        # only relevant if change_set_name isn't an ARN
+        state = get_cloudformation_store(context.account_id, context.region)
+        change_set = find_change_set_v2(state, change_set_name, stack_name)
+
+        if not change_set:
+            raise ChangeSetNotFoundException(f"ChangeSet [{change_set_name}] does not exist")
+
+        # if the change set failed to create, then we can return a blank response
+        if change_set.status == ChangeSetStatus.FAILED:
+            return DescribeChangeSetOutput(
+                Status=change_set.status,
+                ChangeSetId=change_set.change_set_id,
+                ChangeSetName=change_set.change_set_name,
+                ExecutionStatus=change_set.execution_status,
+                RollbackConfiguration=RollbackConfiguration(),
+                StackId=change_set.stack.stack_id,
+                StackName=change_set.stack.stack_name,
+                CreationTime=change_set.creation_time,
+                Changes=[],
+                Capabilities=change_set.stack.capabilities,
+                StatusReason=change_set.status_reason,
+                Description=change_set.description,
+                # TODO: static information
+                IncludeNestedStacks=False,
+                NotificationARNs=[],
+                Tags=change_set.tags or None,
+            )
+
         # TODO: The ChangeSetModelDescriber currently matches AWS behavior by listing
         #       resource changes in the order they appear in the template. However, when
         #       a resource change is triggered indirectly (e.g., via Ref or GetAtt), the
@@ -591,36 +753,49 @@ class CloudformationProviderV2(CloudformationProvider):
             # TODO: static information
             IncludeNestedStacks=False,
             NotificationARNs=[],
+            Tags=change_set.tags or None,
         )
         if change_set.resolved_parameters:
-            result["Parameters"] = [
-                # TODO: add masking support.
-                Parameter(ParameterKey=key, ParameterValue=value)
-                for (key, value) in change_set.resolved_parameters.items()
-            ]
+            result["Parameters"] = self._render_resolved_parameters(change_set.resolved_parameters)
         return result
 
-    @handler("DescribeChangeSet")
-    def describe_change_set(
+    @handler("ListChangeSets")
+    def list_change_sets(
         self,
         context: RequestContext,
-        change_set_name: ChangeSetNameOrId,
-        stack_name: StackNameOrId | None = None,
-        next_token: NextToken | None = None,
-        include_property_values: IncludePropertyValues | None = None,
+        stack_name: StackNameOrId,
+        next_token: NextToken = None,
         **kwargs,
-    ) -> DescribeChangeSetOutput:
-        # TODO add support for include_property_values
-        # only relevant if change_set_name isn't an ARN
-        state = get_cloudformation_store(context.account_id, context.region)
-        change_set = find_change_set_v2(state, change_set_name, stack_name)
+    ) -> ListChangeSetsOutput:
+        store = get_cloudformation_store(account_id=context.account_id, region_name=context.region)
+        stack = find_stack_v2(store, stack_name)
+        if not stack:
+            raise StackNotFoundError(stack_name)
+        summaries = []
+        for change_set_id in stack.change_set_ids:
+            change_set = store.change_sets[change_set_id]
+            if (
+                change_set.status != ChangeSetStatus.CREATE_COMPLETE
+                or change_set.execution_status != ExecutionStatus.AVAILABLE
+            ):
+                continue
 
-        if not change_set:
-            raise ChangeSetNotFoundException(f"ChangeSet [{change_set_name}] does not exist")
-        result = self._describe_change_set(
-            change_set=change_set, include_property_values=include_property_values or False
-        )
-        return result
+            summaries.append(
+                ChangeSetSummary(
+                    StackId=change_set.stack.stack_id,
+                    StackName=change_set.stack.stack_name,
+                    ChangeSetId=change_set_id,
+                    ChangeSetName=change_set.change_set_name,
+                    ExecutionStatus=change_set.execution_status,
+                    Status=change_set.status,
+                    StatusReason=change_set.status_reason,
+                    CreationTime=change_set.creation_time,
+                    # mocked information
+                    IncludeNestedStacks=False,
+                )
+            )
+
+        return ListChangeSetsOutput(Summaries=summaries)
 
     @handler("DeleteChangeSet")
     def delete_change_set(
@@ -635,8 +810,22 @@ class CloudformationProviderV2(CloudformationProvider):
         if not change_set:
             return DeleteChangeSetOutput()
 
-        change_set.stack.change_set_ids.remove(change_set.change_set_id)
-        state.change_sets.pop(change_set.change_set_id)
+        try:
+            change_set.stack.change_set_ids.remove(change_set.change_set_id)
+        except KeyError:
+            LOG.warning(
+                "Could not disassociatei change set '%s' from stack '%s', it does not seem to be associated",
+                change_set.change_set_id,
+                change_set.stack.stack_id,
+            )
+        try:
+            state.change_sets.pop(change_set.change_set_id)
+        except KeyError:
+            # This _should_ never fail since if we cannot find the change set in the store (using
+            # `find_change_set_v2`) then we early return from this function
+            LOG.warning(
+                "Could not delete change set '%s', it does not exist", change_set.change_set_id
+            )
 
         return DeleteChangeSetOutput()
 
@@ -688,6 +877,12 @@ class CloudformationProviderV2(CloudformationProvider):
         template_body = api_utils.extract_template_body(request)
         structured_template = template_preparer.parse_template(template_body)
 
+        if len(template_body) > 51200 and not template_url:
+            raise ValidationError(
+                f"1 validation error detected: Value '{template_body}' at 'templateBody' "
+                "failed to satisfy constraint: Member must have length less than or equal to 51200"
+            )
+
         if "CAPABILITY_AUTO_EXPAND" not in request.get("Capabilities", []) and (
             "Transform" in structured_template.keys() or "Fn::Transform" in template_body
         ):
@@ -699,6 +894,7 @@ class CloudformationProviderV2(CloudformationProvider):
             account_id=context.account_id,
             region_name=context.region,
             request_payload=request,
+            tags=request.get("Tags"),
         )
         # TODO: what is the correct initial status?
         state.stacks_v2[stack.stack_id] = stack
@@ -727,6 +923,10 @@ class CloudformationProviderV2(CloudformationProvider):
             after_parameters=after_parameters,
             previous_update_model=None,
         )
+        if change_set.status == ChangeSetStatus.FAILED:
+            return CreateStackOutput(StackId=stack.stack_id)
+
+        stack.processed_template = change_set.processed_template
 
         # deployment process
         stack.set_stack_status(StackStatus.CREATE_IN_PROGRESS)
@@ -735,19 +935,26 @@ class CloudformationProviderV2(CloudformationProvider):
         def _run(*args):
             try:
                 result = change_set_executor.execute()
-                stack.set_stack_status(StackStatus.CREATE_COMPLETE)
                 stack.resolved_resources = result.resources
                 stack.resolved_outputs = result.outputs
+                if all(
+                    resource["ResourceStatus"] == ResourceStatus.CREATE_COMPLETE
+                    for resource in stack.resolved_resources.values()
+                ):
+                    stack.set_stack_status(StackStatus.CREATE_COMPLETE)
+                else:
+                    stack.set_stack_status(StackStatus.CREATE_FAILED)
+
                 # if the deployment succeeded, update the stack's template representation to that
                 # which was just deployed
                 stack.template = change_set.template
                 stack.template_body = change_set.template_body
+                stack.processed_template = change_set.processed_template
                 stack.resolved_parameters = change_set.resolved_parameters
                 stack.resolved_exports = {}
                 for output in result.outputs:
                     if export_name := output.get("ExportName"):
                         stack.resolved_exports[export_name] = output["OutputValue"]
-                stack.processed_template = change_set.processed_template
             except Exception as e:
                 LOG.error(
                     "Create Stack set failed: %s",
@@ -793,12 +1000,10 @@ class CloudformationProviderV2(CloudformationProvider):
 
         return DescribeStacksOutput(Stacks=describe_stack_output)
 
-    @staticmethod
-    def _describe_stack(stack: Stack) -> ApiStack:
+    def _describe_stack(self, stack: Stack) -> ApiStack:
         stack_description = ApiStack(
             Description=stack.description,
             CreationTime=stack.creation_time,
-            DeletionTime=stack.deletion_time,
             StackId=stack.stack_id,
             StackName=stack.stack_name,
             StackStatus=stack.status,
@@ -808,13 +1013,14 @@ class CloudformationProviderV2(CloudformationProvider):
             DriftInformation=StackDriftInformation(StackDriftStatus=StackDriftStatus.NOT_CHECKED),
             EnableTerminationProtection=stack.enable_termination_protection,
             RollbackConfiguration=RollbackConfiguration(),
-            Tags=[],
+            Tags=stack.tags,
             NotificationARNs=[],
-            # "Parameters": stack.resolved_parameters,
         )
         if stack.status != StackStatus.REVIEW_IN_PROGRESS:
             # TODO: actually track updated time
             stack_description["LastUpdatedTime"] = stack.creation_time
+        if stack.deletion_time:
+            stack_description["DeletionTime"] = stack.deletion_time
         if stack.capabilities:
             stack_description["Capabilities"] = stack.capabilities
         # TODO: confirm the logic for this
@@ -822,16 +1028,9 @@ class CloudformationProviderV2(CloudformationProvider):
             stack_description["ChangeSetId"] = change_set_id
 
         if stack.resolved_parameters:
-            stack_description["Parameters"] = []
-            for name, resolved_parameter in stack.resolved_parameters.items():
-                parameter = Parameter(
-                    ParameterKey=name,
-                    ParameterValue=resolved_parameter.get("given_value")
-                    or resolved_parameter.get("default_value"),
-                )
-                if resolved_value := resolved_parameter.get("resolved_value"):
-                    parameter["ResolvedValue"] = resolved_value
-                stack_description["Parameters"].append(parameter)
+            stack_description["Parameters"] = self._render_resolved_parameters(
+                stack.resolved_parameters
+            )
 
         if stack.resolved_outputs:
             stack_description["Outputs"] = stack.resolved_outputs
@@ -910,6 +1109,12 @@ class CloudformationProviderV2(CloudformationProvider):
 
         try:
             resource = stack.resolved_resources[logical_resource_id]
+            if resource.get("ResourceStatus") not in [
+                StackStatus.CREATE_COMPLETE,
+                StackStatus.UPDATE_COMPLETE,
+                StackStatus.ROLLBACK_COMPLETE,
+            ]:
+                raise KeyError
         except KeyError:
             raise ValidationError(
                 f"Resource {logical_resource_id} does not exist for stack {stack_name}"
@@ -923,6 +1128,7 @@ class CloudformationProviderV2(CloudformationProvider):
             ResourceType=resource["Type"],
             LastUpdatedTimestamp=resource["LastUpdatedTimestamp"],
             ResourceStatus=resource["ResourceStatus"],
+            DriftInformation={"StackResourceDriftStatus": "NOT_CHECKED"},
         )
         return DescribeStackResourceOutput(StackResourceDetail=resource_detail)
 
@@ -1168,10 +1374,19 @@ class CloudformationProviderV2(CloudformationProvider):
     ) -> GetTemplateOutput:
         state = get_cloudformation_store(context.account_id, context.region)
         if change_set_name:
+            if not is_changeset_arn(change_set_name) and not stack_name:
+                raise ValidationError("StackName is a required parameter.")
+
             change_set = find_change_set_v2(state, change_set_name, stack_name=stack_name)
+            if not change_set:
+                raise ChangeSetNotFoundException(f"ChangeSet [{change_set_name}] does not exist")
             stack = change_set.stack
         elif stack_name:
             stack = find_stack_v2(state, stack_name)
+            if not stack:
+                raise StackNotFoundError(
+                    stack_name, message_override=f"Stack with id {stack_name} does not exist"
+                )
         else:
             raise StackNotFoundError(stack_name)
 
@@ -1198,6 +1413,12 @@ class CloudformationProviderV2(CloudformationProvider):
             stack = find_stack_v2(state, stack_name)
             if not stack:
                 raise StackNotFoundError(stack_name)
+
+            if stack.status == StackStatus.REVIEW_IN_PROGRESS:
+                raise ValidationError(
+                    "GetTemplateSummary cannot be called on REVIEW_IN_PROGRESS stacks."
+                )
+
             template = stack.template
         else:
             template_body = request.get("TemplateBody")
@@ -1219,6 +1440,11 @@ class CloudformationProviderV2(CloudformationProvider):
             template = template_preparer.parse_template(template_body)
 
         id_summaries = defaultdict(list)
+        if "Resources" not in template:
+            raise ValidationError(
+                "Template format error: At least one Resources member must be defined."
+            )
+
         for resource_id, resource in template["Resources"].items():
             res_type = resource["Type"]
             id_summaries[res_type].append(resource_id)
@@ -1322,6 +1548,14 @@ class CloudformationProviderV2(CloudformationProvider):
                 raise RuntimeError("Multiple stacks matched, update matching logic")
             stack = active_stack_candidates[0]
 
+        if (
+            stack.status == StackStatus.DELETE_COMPLETE
+            or stack.status == StackStatus.DELETE_IN_PROGRESS
+        ):
+            raise ValidationError(
+                f"Stack:{stack.stack_id} is in {stack.status} state and can not be updated."
+            )
+
         # TODO: proper status modeling
         before_parameters = stack.resolved_parameters
         # TODO: reconsider the way parameters are modelled in the update graph process.
@@ -1358,7 +1592,7 @@ class CloudformationProviderV2(CloudformationProvider):
         # TODO: some changes are only detectable at runtime; consider using
         #       the ChangeSetModelDescriber, or a new custom visitors, to
         #       pick-up on runtime changes.
-        if change_set.update_model.node_template.change_type == ChangeType.UNCHANGED:
+        if not change_set.has_changes():
             raise ValidationError("No updates are to be performed.")
 
         stack.set_stack_status(StackStatus.UPDATE_IN_PROGRESS)
@@ -1438,10 +1672,7 @@ class CloudformationProviderV2(CloudformationProvider):
             stack.deletion_time = datetime.now(tz=UTC)
             return
 
-        previous_update_model = None
-        if stack.change_set_id:
-            if previous_change_set := find_change_set_v2(state, stack.change_set_id):
-                previous_update_model = previous_change_set.update_model
+        stack.set_stack_status(StackStatus.DELETE_IN_PROGRESS)
 
         # create a dummy change set
         change_set = ChangeSet(
@@ -1449,18 +1680,16 @@ class CloudformationProviderV2(CloudformationProvider):
         )  # noqa
         self._setup_change_set_model(
             change_set=change_set,
-            before_template=stack.template,
+            before_template=stack.processed_template,
             after_template=None,
             before_parameters=stack.resolved_parameters,
             after_parameters=None,
-            previous_update_model=previous_update_model,
         )
 
         change_set_executor = ChangeSetModelExecutor(change_set)
 
         def _run(*args):
             try:
-                stack.set_stack_status(StackStatus.DELETE_IN_PROGRESS)
                 change_set_executor.execute()
                 stack.set_stack_status(StackStatus.DELETE_COMPLETE)
                 stack.deletion_time = datetime.now(tz=UTC)
@@ -1474,6 +1703,7 @@ class CloudformationProviderV2(CloudformationProvider):
                 stack.set_stack_status(StackStatus.DELETE_FAILED)
 
         start_worker_thread(_run)
+        return ExecuteChangeSetOutput()
 
     @handler("ListExports")
     def list_exports(