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

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

@@ -1,9 +1,12 @@
 import copy
 import logging
+import os
+import re
 import uuid
+from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import UTC, datetime
-from typing import Final, Protocol
+from typing import Final, Protocol, TypeVar
 
 from localstack import config
 from localstack.aws.api.cloudformation import (
@@ -15,17 +18,14 @@ from localstack.aws.api.cloudformation import (
 from localstack.constants import INTERNAL_AWS_SECRET_ACCESS_KEY
 from localstack.services.cloudformation.analytics import track_resource_operation
 from localstack.services.cloudformation.deployment_utils import log_not_available_message
-from localstack.services.cloudformation.engine.template_deployer import REGEX_OUTPUT_APIGATEWAY
 from localstack.services.cloudformation.engine.v2.change_set_model import (
     NodeDependsOn,
     NodeOutput,
     NodeResource,
-    TerminalValueCreated,
-    TerminalValueModified,
-    TerminalValueUnchanged,
     is_nothing,
 )
 from localstack.services.cloudformation.engine.v2.change_set_model_preproc import (
+    _AWS_URL_SUFFIX,
     MOCKED_REFERENCE,
     ChangeSetModelPreproc,
     PreprocEntityDelta,
@@ -41,28 +41,50 @@ from localstack.services.cloudformation.resource_provider import (
     ResourceProviderPayload,
 )
 from localstack.services.cloudformation.v2.entities import ChangeSet, ResolvedResource
-from localstack.utils.urls import localstack_host
 
 LOG = logging.getLogger(__name__)
 
 EventOperationFromAction = {"Add": "CREATE", "Modify": "UPDATE", "Remove": "DELETE"}
 
+REGEX_OUTPUT_APIGATEWAY = re.compile(
+    rf"^(https?://.+\.execute-api\.)(?:[^-]+-){{2,3}}\d\.(amazonaws\.com|{_AWS_URL_SUFFIX})/?(.*)$"
+)
+
+_T = TypeVar("_T")
+
 
 @dataclass
 class ChangeSetModelExecutorResult:
     resources: dict[str, ResolvedResource]
     outputs: list[Output]
+    failure_message: str | None = None
 
 
 class DeferredAction(Protocol):
     def __call__(self) -> None: ...
 
 
+@dataclass
+class Deferred:
+    name: str
+    action: DeferredAction
+
+
+class TriggerRollback(Exception):
+    """
+    Sentinel exception to signal that the deployment should be stopped for a reason
+    """
+
+    def __init__(self, logical_resource_id: str, reason: str | None):
+        self.logical_resource_id = logical_resource_id
+        self.reason = reason
+
+
 class ChangeSetModelExecutor(ChangeSetModelPreproc):
     # TODO: add typing for resolved resources and parameters.
     resources: Final[dict[str, ResolvedResource]]
     outputs: Final[list[Output]]
-    _deferred_actions: list[DeferredAction]
+    _deferred_actions: list[Deferred]
 
     def __init__(self, change_set: ChangeSet):
         super().__init__(change_set=change_set)
@@ -76,24 +98,42 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
 
     def execute(self) -> ChangeSetModelExecutorResult:
         # constructive process
-        self.process()
+        failure_message = None
+        try:
+            self.process()
+        except TriggerRollback as e:
+            failure_message = e.reason
+        except Exception as e:
+            failure_message = str(e)
 
+        is_deletion = self._change_set.stack.status == StackStatus.DELETE_IN_PROGRESS
         if self._deferred_actions:
-            self._change_set.stack.set_stack_status(StackStatus.UPDATE_COMPLETE_CLEANUP_IN_PROGRESS)
+            if not is_deletion:
+                # TODO: correct status
+                # TODO: differentiate between update and create
+                self._change_set.stack.set_stack_status(
+                    StackStatus.ROLLBACK_IN_PROGRESS
+                    if failure_message
+                    else StackStatus.UPDATE_COMPLETE_CLEANUP_IN_PROGRESS
+                )
 
             # perform all deferred actions such as deletions. These must happen in reverse from their
             # defined order so that resource dependencies are honoured
             # TODO: errors will stop all rollbacks; get parity on this behaviour
-            for action in self._deferred_actions[::-1]:
-                action()
+            for deferred in self._deferred_actions[::-1]:
+                LOG.debug("executing deferred action: '%s'", deferred.name)
+                deferred.action()
+
+        if failure_message and not is_deletion:
+            # TODO: differentiate between update and create
+            self._change_set.stack.set_stack_status(StackStatus.ROLLBACK_COMPLETE)
 
         return ChangeSetModelExecutorResult(
-            resources=self.resources,
-            outputs=self.outputs,
+            resources=self.resources, outputs=self.outputs, failure_message=failure_message
         )
 
-    def _defer_action(self, action: DeferredAction):
-        self._deferred_actions.append(action)
+    def _defer_action(self, name: str, action: DeferredAction):
+        self._deferred_actions.append(Deferred(name=name, action=action))
 
     def _get_physical_id(self, logical_resource_id, strict: bool = True) -> str | None:
         physical_resource_id = None
@@ -129,9 +169,10 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
         else:
             status = f"{status_from_action}_{event_status.name}"
 
+        physical_resource_id = self._get_physical_id(logical_resource_id, False)
         self._change_set.stack.set_resource_status(
             logical_resource_id=logical_resource_id,
-            physical_resource_id=self._get_physical_id(logical_resource_id, False) or "",
+            physical_resource_id=physical_resource_id,
             resource_type=resource_type,
             status=ResourceStatus(status),
             resource_status_reason=reason,
@@ -184,6 +225,12 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
         try:
             delta = super().visit_node_resource(node_resource=node_resource)
         except Exception as e:
+            LOG.debug(
+                "preprocessing resource '%s' failed: %s",
+                node_resource.name,
+                e,
+                exc_info=LOG.isEnabledFor(logging.DEBUG) and config.CFN_VERBOSE_ERRORS,
+            )
             self._process_event(
                 action=node_resource.change_type.to_change_action(),
                 logical_resource_id=node_resource.name,
@@ -211,10 +258,24 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
         # Update the latest version of this resource for downstream references.
         if not is_nothing(after):
             after_logical_id = after.logical_id
-            after_physical_id: str = self._after_resource_physical_id(
-                resource_logical_id=after_logical_id
-            )
-            after.physical_resource_id = after_physical_id
+            resource = self.resources[after_logical_id]
+            resource_failed_to_deploy = resource["ResourceStatus"] in {
+                ResourceStatus.CREATE_FAILED,
+                ResourceStatus.UPDATE_FAILED,
+            }
+            if not resource_failed_to_deploy:
+                after_physical_id: str = self._after_resource_physical_id(
+                    resource_logical_id=after_logical_id
+                )
+                after.physical_resource_id = after_physical_id
+            after.status = resource["ResourceStatus"]
+
+            # terminate the deployment process
+            if resource_failed_to_deploy:
+                raise TriggerRollback(
+                    logical_resource_id=after_logical_id,
+                    reason=resource.get("ResourceStatusReason"),
+                )
         return delta
 
     def visit_node_output(
@@ -283,6 +344,7 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
                             resource_type=before.resource_type,
                             before_properties=before_properties,
                             after_properties=None,
+                            part_of_replacement=True,
                         )
                         self._process_event(
                             action=ChangeAction.Remove,
@@ -292,7 +354,7 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
                             reason=event.message,
                         )
 
-                    self._defer_action(cleanup)
+                    self._defer_action(f"cleanup-from-replacement-{name}", cleanup)
                 else:
                     event = self._execute_resource_action(
                         action=ChangeAction.Modify,
@@ -331,7 +393,7 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
                         reason=event.message,
                     )
 
-                self._defer_action(perform_deletion)
+                self._defer_action(f"type-migration-{name}", perform_deletion)
 
                 event = self._execute_resource_action(
                     action=ChangeAction.Add,
@@ -375,7 +437,7 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
                     reason=event.message,
                 )
 
-            self._defer_action(perform_deletion)
+            self._defer_action(f"remove-{name}", perform_deletion)
         elif not is_nothing(after):
             # Case: addition
             self._process_event(
@@ -417,6 +479,7 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
         resource_type: str,
         before_properties: PreprocProperties | None,
         after_properties: PreprocProperties | None,
+        part_of_replacement: bool = False,
     ) -> ProgressEvent:
         LOG.debug("Executing resource action: %s for resource '%s'", action, logical_resource_id)
         payload = self.create_resource_provider_payload(
@@ -454,9 +517,11 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
                 resource_type,
                 f'No resource provider found for "{resource_type}"',
             )
-            LOG.warning(
-                "Deployment of resource type %s successful due to config CFN_IGNORE_UNSUPPORTED_RESOURCE_TYPES"
-            )
+            if "CFN_IGNORE_UNSUPPORTED_RESOURCE_TYPES" not in os.environ:
+                LOG.warning(
+                    "Deployment of resource type %s succeeded, but will fail in upcoming LocalStack releases unless CFN_IGNORE_UNSUPPORTED_RESOURCE_TYPES is explicitly enabled.",
+                    resource_type,
+                )
             event = ProgressEvent(
                 OperationStatus.SUCCESS,
                 resource_model={},
@@ -473,6 +538,19 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
                 message=f"Resource type {resource_type} not supported",
             )
 
+        if part_of_replacement and action == ChangeAction.Remove:
+            # Early return as we don't want to update internal state of the executor if this is a
+            # cleanup of an old resource. The new resource has already been created and the state
+            # updated
+            return event
+
+        status_from_action = EventOperationFromAction[action.value]
+        resolved_resource = ResolvedResource(
+            Properties=event.resource_model,
+            LogicalResourceId=logical_resource_id,
+            Type=resource_type,
+            LastUpdatedTimestamp=datetime.now(UTC),
+        )
         match event.status:
             case OperationStatus.SUCCESS:
                 # merge the resources state with the external state
@@ -487,33 +565,29 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
 
                 # Don't update the resolved resources if we have deleted that resource
                 if action != ChangeAction.Remove:
-                    status_from_action = EventOperationFromAction[action.value]
                     physical_resource_id = (
                         extra_resource_properties["PhysicalResourceId"]
                         if resource_provider
                         else MOCKED_REFERENCE
                     )
-                    resolved_resource = ResolvedResource(
-                        Properties=event.resource_model,
-                        LogicalResourceId=logical_resource_id,
-                        Type=resource_type,
-                        LastUpdatedTimestamp=datetime.now(UTC),
-                        ResourceStatus=ResourceStatus(f"{status_from_action}_COMPLETE"),
-                        PhysicalResourceId=physical_resource_id,
+                    resolved_resource["PhysicalResourceId"] = physical_resource_id
+                    resolved_resource["ResourceStatus"] = ResourceStatus(
+                        f"{status_from_action}_COMPLETE"
                     )
                     # TODO: do we actually need this line?
                     resolved_resource.update(extra_resource_properties)
-
-                    self.resources[logical_resource_id] = resolved_resource
-
             case OperationStatus.FAILED:
                 reason = event.message
                 LOG.warning(
                     "Resource provider operation failed: '%s'",
                     reason,
                 )
+                resolved_resource["ResourceStatus"] = ResourceStatus(f"{status_from_action}_FAILED")
+                resolved_resource["ResourceStatusReason"] = reason
             case other:
                 raise NotImplementedError(f"Event status '{other}' not handled")
+
+        self.resources[logical_resource_id] = resolved_resource
         return event
 
     def create_resource_provider_payload(
@@ -572,43 +646,10 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
         }
         return resource_provider_payload
 
-    @staticmethod
-    def _replace_url_outputs_if_required(value: str) -> str:
-        api_match = REGEX_OUTPUT_APIGATEWAY.match(value)
-        if api_match and value not in config.CFN_STRING_REPLACEMENT_DENY_LIST:
-            prefix = api_match[1]
-            host = api_match[2]
-            path = api_match[3]
-            port = localstack_host().port
-            value = f"{prefix}{host}:{port}/{path}"
-            return value
-
-        return value
-
-    def visit_terminal_value_created(
-        self, value: TerminalValueCreated
-    ) -> PreprocEntityDelta[str, str]:
-        if isinstance(value.value, str):
-            after = self._replace_url_outputs_if_required(value.value)
-        else:
-            after = value.value
-        return PreprocEntityDelta(after=after)
-
-    def visit_terminal_value_modified(
-        self, value: TerminalValueModified
-    ) -> PreprocEntityDelta[str, str]:
-        # we only need to transform the after
-        if isinstance(value.modified_value, str):
-            after = self._replace_url_outputs_if_required(value.modified_value)
-        else:
-            after = value.modified_value
-        return PreprocEntityDelta(before=value.value, after=after)
-
-    def visit_terminal_value_unchanged(
-        self, terminal_value_unchanged: TerminalValueUnchanged
+    def _maybe_perform_on_delta(
+        self, delta: PreprocEntityDelta, f: Callable[[_T], _T]
     ) -> PreprocEntityDelta:
-        if isinstance(terminal_value_unchanged.value, str):
-            value = self._replace_url_outputs_if_required(terminal_value_unchanged.value)
-        else:
-            value = terminal_value_unchanged.value
-        return PreprocEntityDelta(before=value, after=value)
+        # we only care about the after state
+        if isinstance(delta.after, str):
+            delta.after = f(delta.after)
+        return delta