localstack-core 4.5.1.dev42__tar.gz → 4.5.1.dev44__tar.gz

{localstack_core-4.5.1.dev42 → localstack_core-4.5.1.dev44}/PKG-INFO

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

{localstack_core-4.5.1.dev42 → localstack_core-4.5.1.dev44}/localstack-core/localstack/services/cloudformation/engine/v2/change_set_model.py

@@ -802,6 +802,7 @@ class ChangeSetModel:
         node_property = self._visited_scopes.get(scope)
         if isinstance(node_property, NodeProperty):
             return node_property
+        # TODO: Review the use of Fn::Transform as resource properties.
         value = self._visit_value(
             scope=scope, before_value=before_property, after_value=after_property
         )
@@ -1156,14 +1157,30 @@ class ChangeSetModel:
     @staticmethod
     def _normalise_transformer_value(value: Maybe[str | list[Any]]) -> Maybe[list[Any]]:
         # To simplify downstream logics, reduce the type options to array of transformations.
-        # TODO: add validation logic
+        # TODO: add further validation logic
         # TODO: should we sort to avoid detecting user-side ordering changes as template changes?
         if isinstance(value, NothingType):
             return value
         elif isinstance(value, str):
             value = [NormalisedGlobalTransformDefinition(Name=value, Parameters=Nothing)]
-        elif not isinstance(value, list):
-            raise RuntimeError(f"Invalid type for Transformer: '{value}'")
+        elif isinstance(value, list):
+            tmp_value = list()
+            for item in value:
+                if isinstance(item, str):
+                    tmp_value.append(
+                        NormalisedGlobalTransformDefinition(Name=item, Parameters=Nothing)
+                    )
+                else:
+                    tmp_value.append(item)
+            value = tmp_value
+        elif isinstance(value, dict):
+            if "Name" not in value:
+                raise RuntimeError(f"Missing 'Name' field in Transform definition '{value}'")
+            name = value["Name"]
+            parameters = value.get("Parameters", Nothing)
+            value = [NormalisedGlobalTransformDefinition(Name=name, Parameters=parameters)]
+        else:
+            raise RuntimeError(f"Invalid Transform definition: '{value}'")
         return value
 
     def _visit_transform(
@@ -1325,7 +1342,8 @@ class ChangeSetModel:
     def _safe_access_in(scope: Scope, key: str, *objects: Maybe[dict]) -> tuple[Scope, Maybe[Any]]:
         results = list()
         for obj in objects:
-            # TODO: raise errors if not dict
+            if not isinstance(obj, (dict, NothingType)):
+                raise RuntimeError(f"Invalid definition type at '{obj}'")
             if not isinstance(obj, NothingType):
                 results.append(obj.get(key, Nothing))
             else:

{localstack_core-4.5.1.dev42 → localstack_core-4.5.1.dev44}/localstack-core/localstack/services/cloudformation/engine/v2/change_set_model_executor.py

@@ -36,6 +36,8 @@ from localstack.services.cloudformation.v2.entities import ChangeSet
 
 LOG = logging.getLogger(__name__)
 
+EventOperationFromAction = {"Add": "CREATE", "Modify": "UPDATE", "Remove": "DELETE"}
+
 
 @dataclass
 class ChangeSetModelExecutorResult:
@@ -86,6 +88,50 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
         self.resolved_parameters[node_parameter.name] = delta.after
         return delta
 
+    def _get_physical_id(self, logical_resource_id, strict: bool = True) -> str | None:
+        physical_resource_id = None
+        try:
+            physical_resource_id = self._after_resource_physical_id(logical_resource_id)
+        except RuntimeError:
+            # The physical id is missing or is set to None, which is invalid.
+            pass
+        if physical_resource_id is None:
+            # The physical resource id is None after an update that didn't rewrite the resource, the previous
+            # resource id is therefore the current physical id of this resource.
+
+            try:
+                physical_resource_id = self._before_resource_physical_id(logical_resource_id)
+            except RuntimeError as e:
+                if strict:
+                    raise e
+        return physical_resource_id
+
+    def _process_event(
+        self,
+        action: ChangeAction,
+        logical_resource_id,
+        event_status: OperationStatus,
+        special_action: str = None,
+        reason: str = None,
+        resource_type=None,
+    ):
+        status_from_action = special_action or EventOperationFromAction[action.value]
+        if event_status == OperationStatus.SUCCESS:
+            status = f"{status_from_action}_COMPLETE"
+        else:
+            status = f"{status_from_action}_{event_status.name}"
+
+        self._change_set.stack.set_resource_status(
+            logical_resource_id=logical_resource_id,
+            physical_resource_id=self._get_physical_id(logical_resource_id, False),
+            resource_type=resource_type,
+            status=ResourceStatus(status),
+            resource_status_reason=reason,
+        )
+
+        if event_status == OperationStatus.FAILED:
+            self._change_set.stack.set_stack_status(StackStatus(status))
+
     def _after_deployed_property_value_of(
         self, resource_logical_id: str, property_name: str
     ) -> str:
@@ -173,20 +219,29 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
                 # XXX hacky, stick the previous resources' properties into the payload
                 before_properties = self._merge_before_properties(name, before)
 
-                self._execute_resource_action(
+                self._process_event(ChangeAction.Modify, name, OperationStatus.IN_PROGRESS)
+                event = self._execute_resource_action(
                     action=ChangeAction.Modify,
                     logical_resource_id=name,
                     resource_type=before.resource_type,
                     before_properties=before_properties,
                     after_properties=after.properties,
                 )
+                self._process_event(
+                    ChangeAction.Modify,
+                    name,
+                    event.status,
+                    reason=event.message,
+                    resource_type=before.resource_type,
+                )
             # Case: type migration.
             # TODO: Add test to assert that on type change the resources are replaced.
             else:
                 # XXX hacky, stick the previous resources' properties into the payload
                 before_properties = self._merge_before_properties(name, before)
                 # Register a Removed for the previous type.
-                self._execute_resource_action(
+
+                event = self._execute_resource_action(
                     action=ChangeAction.Remove,
                     logical_resource_id=name,
                     resource_type=before.resource_type,
@@ -194,35 +249,74 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
                     after_properties=None,
                 )
                 # Register a Create for the next type.
-                self._execute_resource_action(
+                self._process_event(
+                    ChangeAction.Modify,
+                    name,
+                    event.status,
+                    reason=event.message,
+                    resource_type=before.resource_type,
+                )
+                event = self._execute_resource_action(
                     action=ChangeAction.Add,
                     logical_resource_id=name,
                     resource_type=after.resource_type,
                     before_properties=None,
                     after_properties=after.properties,
                 )
+                self._process_event(
+                    ChangeAction.Modify,
+                    name,
+                    event.status,
+                    reason=event.message,
+                    resource_type=before.resource_type,
+                )
         elif not is_nothing(before):
             # Case: removal
             # XXX hacky, stick the previous resources' properties into the payload
             # XXX hacky, stick the previous resources' properties into the payload
             before_properties = self._merge_before_properties(name, before)
-
-            self._execute_resource_action(
+            self._process_event(
+                ChangeAction.Remove,
+                name,
+                OperationStatus.IN_PROGRESS,
+                resource_type=before.resource_type,
+            )
+            event = self._execute_resource_action(
                 action=ChangeAction.Remove,
                 logical_resource_id=name,
                 resource_type=before.resource_type,
                 before_properties=before_properties,
                 after_properties=None,
             )
+            self._process_event(
+                ChangeAction.Remove,
+                name,
+                event.status,
+                reason=event.message,
+                resource_type=before.resource_type,
+            )
         elif not is_nothing(after):
             # Case: addition
-            self._execute_resource_action(
+            self._process_event(
+                ChangeAction.Add,
+                name,
+                OperationStatus.IN_PROGRESS,
+                resource_type=after.resource_type,
+            )
+            event = self._execute_resource_action(
                 action=ChangeAction.Add,
                 logical_resource_id=name,
                 resource_type=after.resource_type,
                 before_properties=None,
                 after_properties=after.properties,
             )
+            self._process_event(
+                ChangeAction.Add,
+                name,
+                event.status,
+                reason=event.message,
+                resource_type=after.resource_type,
+            )
 
     def _merge_before_properties(
         self, name: str, preproc_resource: PreprocResource
@@ -242,7 +336,7 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
         resource_type: str,
         before_properties: Optional[PreprocProperties],
         after_properties: Optional[PreprocProperties],
-    ) -> None:
+    ) -> ProgressEvent:
         LOG.debug("Executing resource action: %s for resource '%s'", action, logical_resource_id)
         resource_provider_executor = ResourceProviderExecutor(
             stack_name=self._change_set.stack.stack_name, stack_id=self._change_set.stack.stack_id
@@ -272,16 +366,6 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
                     exc_info=LOG.isEnabledFor(logging.DEBUG),
                 )
                 stack = self._change_set.stack
-                match stack.status:
-                    case StackStatus.CREATE_IN_PROGRESS:
-                        stack.set_stack_status(StackStatus.CREATE_FAILED, reason=reason)
-                    case StackStatus.UPDATE_IN_PROGRESS:
-                        stack.set_stack_status(StackStatus.UPDATE_FAILED, reason=reason)
-                    case StackStatus.DELETE_IN_PROGRESS:
-                        stack.set_stack_status(StackStatus.DELETE_FAILED, reason=reason)
-                    case _:
-                        raise NotImplementedError(f"Unexpected stack status: {stack.status}")
-                # update resource status
                 stack.set_resource_status(
                     logical_resource_id=logical_resource_id,
                     # TODO,
@@ -292,7 +376,11 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
                     else ResourceStatus.UPDATE_FAILED,
                     resource_status_reason=reason,
                 )
-                return
+                event = ProgressEvent(
+                    OperationStatus.FAILED,
+                    resource_model={},
+                    message=f"Resource provider operation failed: {reason}",
+                )
 
         self.resources.setdefault(logical_resource_id, {"Properties": {}})
         match event.status:
@@ -313,28 +401,8 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
                 self.resources[logical_resource_id]["LogicalResourceId"] = logical_resource_id
                 self.resources[logical_resource_id]["Type"] = resource_type
 
-                # TODO: review why the physical id is returned as None during updates
-                # TODO: abstract this in member function of resource classes instead
-                physical_resource_id = None
-                try:
-                    physical_resource_id = self._after_resource_physical_id(logical_resource_id)
-                except RuntimeError:
-                    # The physical id is missing or is set to None, which is invalid.
-                    pass
-                if physical_resource_id is None:
-                    # The physical resource id is None after an update that didn't rewrite the resource, the previous
-                    # resource id is therefore the current physical id of this resource.
-                    physical_resource_id = self._before_resource_physical_id(logical_resource_id)
-                    self.resources[logical_resource_id]["PhysicalResourceId"] = physical_resource_id
-
-                self._change_set.stack.set_resource_status(
-                    logical_resource_id=logical_resource_id,
-                    physical_resource_id=physical_resource_id,
-                    resource_type=resource_type,
-                    status=ResourceStatus.CREATE_COMPLETE
-                    if action == ChangeAction.Add
-                    else ResourceStatus.UPDATE_COMPLETE,
-                )
+                physical_resource_id = self._get_physical_id(logical_resource_id)
+                self.resources[logical_resource_id]["PhysicalResourceId"] = physical_resource_id
 
             case OperationStatus.FAILED:
                 reason = event.message
@@ -342,29 +410,9 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
                     "Resource provider operation failed: '%s'",
                     reason,
                 )
-                # TODO: duplication
-                stack = self._change_set.stack
-                match stack.status:
-                    case StackStatus.CREATE_IN_PROGRESS:
-                        stack.set_stack_status(StackStatus.CREATE_FAILED, reason=reason)
-                    case StackStatus.UPDATE_IN_PROGRESS:
-                        stack.set_stack_status(StackStatus.UPDATE_FAILED, reason=reason)
-                    case StackStatus.DELETE_IN_PROGRESS:
-                        stack.set_stack_status(StackStatus.DELETE_FAILED, reason=reason)
-                    case _:
-                        raise NotImplementedError(f"Unhandled stack status: '{stack.status}'")
-                stack.set_resource_status(
-                    logical_resource_id=logical_resource_id,
-                    # TODO
-                    physical_resource_id="",
-                    resource_type=resource_type,
-                    status=ResourceStatus.CREATE_FAILED
-                    if action == ChangeAction.Add
-                    else ResourceStatus.UPDATE_FAILED,
-                    resource_status_reason=reason,
-                )
             case other:
                 raise NotImplementedError(f"Event status '{other}' not handled")
+        return event
 
     def create_resource_provider_payload(
         self,

{localstack_core-4.5.1.dev42 → localstack_core-4.5.1.dev44}/localstack-core/localstack/services/cloudformation/engine/v2/change_set_model_preproc.py

@@ -27,6 +27,7 @@ from localstack.services.cloudformation.engine.v2.change_set_model import (
     NodeOutput,
     NodeOutputs,
     NodeParameter,
+    NodeParameters,
     NodeProperties,
     NodeProperty,
     NodeResource,
@@ -882,6 +883,21 @@ class ChangeSetModelPreproc(ChangeSetModelVisitor):
         bindings_delta = self.visit(node_mapping.bindings)
         return bindings_delta
 
+    def visit_node_parameters(
+        self, node_parameters: NodeParameters
+    ) -> PreprocEntityDelta[dict[str, Any], dict[str, Any]]:
+        before_parameters = dict()
+        after_parameters = dict()
+        for parameter in node_parameters.parameters:
+            parameter_delta = self.visit(parameter)
+            parameter_before = parameter_delta.before
+            if not is_nothing(parameter_before):
+                before_parameters[parameter.name] = parameter_before
+            parameter_after = parameter_delta.after
+            if not is_nothing(parameter_after):
+                after_parameters[parameter.name] = parameter_after
+        return PreprocEntityDelta(before=before_parameters, after=after_parameters)
+
     def visit_node_parameter(self, node_parameter: NodeParameter) -> PreprocEntityDelta:
         dynamic_value = node_parameter.dynamic_value
         dynamic_delta = self.visit(dynamic_value)

{localstack_core-4.5.1.dev42 → localstack_core-4.5.1.dev44}/localstack-core/localstack/services/cloudformation/engine/v2/change_set_model_transform.py

@@ -1,16 +1,21 @@
 import copy
+import logging
 import os
-from typing import Final, Optional
+from typing import Any, Final, Optional, TypedDict
 
 import boto3
 from samtranslator.translator.transform import transform as transform_sam
 
 from localstack.services.cloudformation.engine.policy_loader import create_policy_loader
-from localstack.services.cloudformation.engine.transformers import FailedTransformationException
+from localstack.services.cloudformation.engine.transformers import (
+    FailedTransformationException,
+    execute_macro,
+)
 from localstack.services.cloudformation.engine.v2.change_set_model import (
     ChangeType,
     Maybe,
     NodeGlobalTransform,
+    NodeParameter,
     NodeTransform,
     Nothing,
     is_nothing,
@@ -19,9 +24,14 @@ from localstack.services.cloudformation.engine.v2.change_set_model_preproc impor
     ChangeSetModelPreproc,
     PreprocEntityDelta,
 )
+from localstack.services.cloudformation.stores import get_cloudformation_store
 from localstack.services.cloudformation.v2.entities import ChangeSet
 
+LOG = logging.getLogger(__name__)
+
 SERVERLESS_TRANSFORM = "AWS::Serverless-2016-10-31"
+EXTENSIONS_TRANSFORM = "AWS::LanguageExtensions"
+SECRETSMANAGER_TRANSFORM = "AWS::SecretsManager-2020-07-23"
 
 
 # TODO: evaluate the use of subtypes to represent and validate types of transforms
@@ -34,6 +44,13 @@ class GlobalTransform:
         self.parameters = parameters
 
 
+class TransformPreprocParameter(TypedDict):
+    # TODO: expand
+    ParameterKey: str
+    ParameterValue: Any
+    ParameterType: Optional[str]
+
+
 class ChangeSetModelTransform(ChangeSetModelPreproc):
     _before_parameters: Final[dict]
     _after_parameters: Final[dict]
@@ -54,9 +71,48 @@ class ChangeSetModelTransform(ChangeSetModelPreproc):
         self._before_template = before_template or Nothing
         self._after_template = after_template or Nothing
 
+    def visit_node_parameter(
+        self, node_parameter: NodeParameter
+    ) -> PreprocEntityDelta[
+        dict[str, TransformPreprocParameter], dict[str, TransformPreprocParameter]
+    ]:
+        # Enable compatability with v1 util.
+        # TODO: port v1's SSM parameter resolution
+
+        parameter_value_delta = super().visit_node_parameter(node_parameter=node_parameter)
+        parameter_value_before = parameter_value_delta.before
+        parameter_value_after = parameter_value_delta.after
+
+        parameter_type_delta = self.visit(node_parameter.type_)
+        parameter_type_before = parameter_type_delta.before
+        parameter_type_after = parameter_type_delta.after
+
+        parameter_key = node_parameter.name
+
+        before = Nothing
+        if not is_nothing(parameter_value_before):
+            before = TransformPreprocParameter(
+                ParameterKey=parameter_key,
+                ParameterValue=parameter_value_before,
+                ParameterType=parameter_type_before
+                if not is_nothing(parameter_type_before)
+                else None,
+            )
+        after = Nothing
+        if not is_nothing(parameter_value_after):
+            after = TransformPreprocParameter(
+                ParameterKey=parameter_key,
+                ParameterValue=parameter_value_after,
+                ParameterType=parameter_type_after
+                if not is_nothing(parameter_type_after)
+                else None,
+            )
+
+        return PreprocEntityDelta(before=before, after=after)
+
     # Ported from v1:
     @staticmethod
-    def _apply_serverless_transformation(
+    def _apply_global_serverless_transformation(
         region_name: str, template: dict, parameters: dict
     ) -> dict:
         """only returns string when parsing SAM template, otherwise None"""
@@ -79,19 +135,65 @@ class ChangeSetModelTransform(ChangeSetModelPreproc):
             if region_before is not None:
                 os.environ["AWS_DEFAULT_REGION"] = region_before
 
+    @staticmethod
+    def _apply_global_macro_transformation(
+        account_id: str,
+        region_name,
+        global_transform: GlobalTransform,
+        template: dict,
+        parameters: dict,
+    ) -> Optional[dict]:
+        macro_name = global_transform.name
+        macros_store = get_cloudformation_store(
+            account_id=account_id, region_name=region_name
+        ).macros
+        macro = macros_store.get(macro_name)
+        if macro is None:
+            raise RuntimeError(f"No definitions for global transform '{macro_name}'")
+        transformation_parameters = global_transform.parameters or dict()
+        transformed_template = execute_macro(
+            account_id,
+            region_name,
+            parsed_template=template,
+            macro=macro,
+            stack_parameters=parameters,
+            transformation_parameters=transformation_parameters,
+        )
+        # The type annotation on the v1 util appears to be incorrect.
+        return transformed_template  # noqa
+
     def _apply_global_transform(
         self, global_transform: GlobalTransform, template: dict, parameters: dict
     ) -> dict:
-        if global_transform.name == SERVERLESS_TRANSFORM:
-            return self._apply_serverless_transformation(
+        transform_name = global_transform.name
+        if transform_name == EXTENSIONS_TRANSFORM:
+            # Applied lazily in downstream tasks (see ChangeSetModelPreproc).
+            transformed_template = template
+        elif transform_name == SERVERLESS_TRANSFORM:
+            transformed_template = self._apply_global_serverless_transformation(
                 region_name=self._change_set.region_name,
                 template=template,
                 parameters=parameters,
             )
-        # TODO: expand support
-        raise RuntimeError(f"Unsupported global transform '{global_transform.name}'")
+        elif transform_name == SECRETSMANAGER_TRANSFORM:
+            # https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-aws-secretsmanager.html
+            LOG.warning("%s is not yet supported. Ignoring.", SECRETSMANAGER_TRANSFORM)
+            transformed_template = template
+        else:
+            transformed_template = self._apply_global_macro_transformation(
+                account_id=self._change_set.account_id,
+                region_name=self._change_set.region_name,
+                global_transform=global_transform,
+                template=template,
+                parameters=parameters,
+            )
+        return transformed_template
 
     def transform(self) -> tuple[dict, dict]:
+        parameters_delta = self.visit_node_parameters(self._node_template.parameters)
+        parameters_before = parameters_delta.before
+        parameters_after = parameters_delta.after
+
         transform_delta: PreprocEntityDelta[list[GlobalTransform], list[GlobalTransform]] = (
             self.visit_node_transform(self._node_template.transform)
         )
@@ -104,17 +206,17 @@ class ChangeSetModelTransform(ChangeSetModelPreproc):
             for before_global_transform in transform_before:
                 transformed_before_template = self._apply_global_transform(
                     global_transform=before_global_transform,
-                    parameters=self._before_parameters,
+                    parameters=parameters_before,
                     template=transformed_before_template,
                 )
 
         transformed_after_template = self._after_template
-        if not is_nothing(transform_before) and not is_nothing(self._after_template):
+        if not is_nothing(transform_after) and not is_nothing(self._after_template):
             transformed_after_template = self._after_template
             for after_global_transform in transform_after:
                 transformed_after_template = self._apply_global_transform(
                     global_transform=after_global_transform,
-                    parameters=self._after_parameters,
+                    parameters=parameters_after,
                     template=transformed_after_template,
                 )
 

{localstack_core-4.5.1.dev42 → localstack_core-4.5.1.dev44}/localstack-core/localstack/services/cloudformation/v2/entities.py

@@ -11,6 +11,7 @@ from localstack.aws.api.cloudformation import (
     ResourceStatus,
     StackDriftInformation,
     StackDriftStatus,
+    StackEvent,
     StackResource,
     StackStatus,
     StackStatusReason,
@@ -26,7 +27,7 @@ from localstack.services.cloudformation.engine.v2.change_set_model import (
     NodeTemplate,
 )
 from localstack.utils.aws import arns
-from localstack.utils.strings import short_uid
+from localstack.utils.strings import long_uid, short_uid
 
 
 class ResolvedResource(TypedDict):
@@ -43,6 +44,7 @@ class Stack:
     stack_id: str
     creation_time: datetime
     deletion_time: datetime | None
+    events = list[StackEvent]
 
     # state after deploy
     resolved_parameters: dict[str, str]
@@ -89,12 +91,15 @@ class Stack:
         self.resolved_resources = {}
         self.resolved_outputs = {}
         self.resource_states = {}
+        self.events = []
 
     def set_stack_status(self, status: StackStatus, reason: StackStatusReason | None = None):
         self.status = status
         if reason:
             self.status_reason = reason
 
+        self._store_event(self.stack_name, self.stack_id, status.value, status_reason=reason)
+
     def set_resource_status(
         self,
         *,
@@ -104,7 +109,7 @@ class Stack:
         status: ResourceStatus,
         resource_status_reason: str | None = None,
     ):
-        self.resource_states[logical_resource_id] = StackResource(
+        resource_description = StackResource(
             StackName=self.stack_name,
             StackId=self.stack_id,
             LogicalResourceId=logical_resource_id,
@@ -115,6 +120,43 @@ class Stack:
             ResourceStatusReason=resource_status_reason,
         )
 
+        if not resource_status_reason:
+            resource_description.pop("ResourceStatusReason")
+
+        self.resource_states[logical_resource_id] = resource_description
+        self._store_event(logical_resource_id, physical_resource_id, status, resource_status_reason)
+
+    def _store_event(
+        self,
+        resource_id: str = None,
+        physical_res_id: str = None,
+        status: str = "",
+        status_reason: str = "",
+    ):
+        resource_id = resource_id
+        physical_res_id = physical_res_id
+        resource_type = (
+            self.template.get("Resources", {})
+            .get(resource_id, {})
+            .get("Type", "AWS::CloudFormation::Stack")
+        )
+
+        event: StackEvent = {
+            "EventId": long_uid(),
+            "Timestamp": datetime.now(tz=timezone.utc),
+            "StackId": self.stack_id,
+            "StackName": self.stack_name,
+            "LogicalResourceId": resource_id,
+            "PhysicalResourceId": physical_res_id,
+            "ResourceStatus": status,
+            "ResourceType": resource_type,
+        }
+
+        if status_reason:
+            event["ResourceStatusReason"] = status_reason
+
+        self.events.insert(0, event)
+
     def describe_details(self) -> ApiStack:
         result = {
             "ChangeSetId": self.change_set_id,

{localstack_core-4.5.1.dev42 → localstack_core-4.5.1.dev44}/localstack-core/localstack/services/cloudformation/v2/provider.py

@@ -236,7 +236,10 @@ class CloudformationProviderV2(CloudformationProvider):
                     raise ValidationError(f"Stack '{stack_name}' does not exist.")
                 stack = active_stack_candidates[0]
 
-        stack.set_stack_status(StackStatus.REVIEW_IN_PROGRESS)
+        if stack.status in [StackStatus.CREATE_COMPLETE, StackStatus.UPDATE_COMPLETE]:
+            stack.set_stack_status(StackStatus.UPDATE_IN_PROGRESS)
+        else:
+            stack.set_stack_status(StackStatus.REVIEW_IN_PROGRESS)
 
         # TODO: test if rollback status is allowed as well
         if (
@@ -472,7 +475,9 @@ class CloudformationProviderV2(CloudformationProvider):
         next_token: NextToken = None,
         **kwargs,
     ) -> DescribeStackEventsOutput:
-        return DescribeStackEventsOutput(StackEvents=[])
+        state = get_cloudformation_store(context.account_id, context.region)
+        stack = find_stack_v2(state, stack_name)
+        return DescribeStackEventsOutput(StackEvents=stack.events)
 
     @handler("DeleteStack")
     def delete_stack(