localstack-core 4.3.1.dev5__py3-none-any.whl → 4.3.1.dev27__py3-none-any.whl

localstack/services/cloudformation/engine/entities.py

@@ -297,6 +297,10 @@ class Stack:
         """Return dict of resources"""
         return dict(self.template_resources)
 
+    @resources.setter
+    def resources(self, resources: dict):
+        self.template["Resources"] = resources
+
     @property
     def template_resources(self):
         return self.template.setdefault("Resources", {})
@@ -370,8 +374,17 @@ class Stack:
 # TODO: what functionality of the Stack object do we rely on here?
 class StackChangeSet(Stack):
     update_graph: NodeTemplate | None
+    change_set_type: ChangeSetType | None
 
-    def __init__(self, account_id: str, region_name: str, stack: Stack, params=None, template=None):
+    def __init__(
+        self,
+        account_id: str,
+        region_name: str,
+        stack: Stack,
+        params=None,
+        template=None,
+        change_set_type: ChangeSetType | None = None,
+    ):
         if template is None:
             template = {}
         if params is None:
@@ -389,6 +402,7 @@ class StackChangeSet(Stack):
         self.stack = stack
         self.metadata["StackId"] = stack.stack_id
         self.metadata["Status"] = "CREATE_PENDING"
+        self.change_set_type = change_set_type
 
     @property
     def change_set_id(self):
@@ -412,5 +426,8 @@ class StackChangeSet(Stack):
         change_set_model = ChangeSetModel(
             before_template=before_template,
             after_template=after_template,
+            # TODO
+            before_parameters=None,
+            after_parameters=None,
         )
         self.update_graph = change_set_model.get_update_model()

localstack/services/cloudformation/engine/template_deployer.py

@@ -1409,15 +1409,6 @@ class TemplateDeployer:
             )  # TODO: why is there a fallback?
             resource["ResourceType"] = get_resource_type(resource)
 
-        def _safe_lookup_is_deleted(r_id):
-            """handles the case where self.stack.resource_status(..) fails for whatever reason"""
-            try:
-                return self.stack.resource_status(r_id).get("ResourceStatus") == "DELETE_COMPLETE"
-            except Exception:
-                if config.CFN_VERBOSE_ERRORS:
-                    LOG.exception("failed to lookup if resource %s is deleted", r_id)
-                return True  # just an assumption
-
         ordered_resource_ids = list(
             order_resources(
                 resources=original_resources,

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

@@ -7,6 +7,7 @@ from typing import Any, Final, Generator, Optional, Union, cast
 
 from typing_extensions import TypeVar
 
+from localstack.aws.api.cloudformation import ChangeAction
 from localstack.utils.strings import camel_to_snake_case
 
 T = TypeVar("T")
@@ -66,6 +67,15 @@ class ChangeType(enum.Enum):
     def __str__(self):
         return self.value
 
+    def to_action(self) -> ChangeAction | None:
+        match self:
+            case self.CREATED:
+                return ChangeAction.Add
+            case self.MODIFIED:
+                return ChangeAction.Modify
+            case self.REMOVED:
+                return ChangeAction.Remove
+
     def for_child(self, child_change_type: ChangeType) -> ChangeType:
         if child_change_type == self:
             return self
@@ -113,22 +123,28 @@ class ChangeSetTerminal(ChangeSetEntity, abc.ABC): ...
 
 
 class NodeTemplate(ChangeSetNode):
+    mappings: Final[NodeMappings]
     parameters: Final[NodeParameters]
     conditions: Final[NodeConditions]
     resources: Final[NodeResources]
+    outputs: Final[NodeOutputs]
 
     def __init__(
         self,
         scope: Scope,
         change_type: ChangeType,
+        mappings: NodeMappings,
         parameters: NodeParameters,
         conditions: NodeConditions,
         resources: NodeResources,
+        outputs: NodeOutputs,
     ):
         super().__init__(scope=scope, change_type=change_type)
+        self.mappings = mappings
         self.parameters = parameters
         self.conditions = conditions
         self.resources = resources
+        self.outputs = outputs
 
 
 class NodeDivergence(ChangeSetNode):
@@ -168,6 +184,54 @@ class NodeParameters(ChangeSetNode):
         self.parameters = parameters
 
 
+class NodeMapping(ChangeSetNode):
+    name: Final[str]
+    bindings: Final[NodeObject]
+
+    def __init__(self, scope: Scope, change_type: ChangeType, name: str, bindings: NodeObject):
+        super().__init__(scope=scope, change_type=change_type)
+        self.name = name
+        self.bindings = bindings
+
+
+class NodeMappings(ChangeSetNode):
+    mappings: Final[list[NodeMapping]]
+
+    def __init__(self, scope: Scope, change_type: ChangeType, mappings: list[NodeMapping]):
+        super().__init__(scope=scope, change_type=change_type)
+        self.mappings = mappings
+
+
+class NodeOutput(ChangeSetNode):
+    name: Final[str]
+    value: Final[ChangeSetEntity]
+    export: Final[Optional[ChangeSetEntity]]
+    condition_reference: Final[Optional[TerminalValue]]
+
+    def __init__(
+        self,
+        scope: Scope,
+        change_type: ChangeType,
+        name: str,
+        value: ChangeSetEntity,
+        export: Optional[ChangeSetEntity],
+        conditional_reference: Optional[TerminalValue],
+    ):
+        super().__init__(scope=scope, change_type=change_type)
+        self.name = name
+        self.value = value
+        self.export = export
+        self.condition_reference = conditional_reference
+
+
+class NodeOutputs(ChangeSetNode):
+    outputs: Final[list[NodeOutput]]
+
+    def __init__(self, scope: Scope, change_type: ChangeType, outputs: list[NodeOutput]):
+        super().__init__(scope=scope, change_type=change_type)
+        self.outputs = outputs
+
+
 class NodeCondition(ChangeSetNode):
     name: Final[str]
     body: Final[ChangeSetEntity]
@@ -197,7 +261,7 @@ class NodeResources(ChangeSetNode):
 class NodeResource(ChangeSetNode):
     name: Final[str]
     type_: Final[ChangeSetTerminal]
-    condition_reference: Final[TerminalValue]
+    condition_reference: Final[Optional[TerminalValue]]
     properties: Final[NodeProperties]
 
     def __init__(
@@ -300,16 +364,28 @@ class TerminalValueUnchanged(TerminalValue):
 TypeKey: Final[str] = "Type"
 ConditionKey: Final[str] = "Condition"
 ConditionsKey: Final[str] = "Conditions"
+MappingsKey: Final[str] = "Mappings"
 ResourcesKey: Final[str] = "Resources"
 PropertiesKey: Final[str] = "Properties"
 ParametersKey: Final[str] = "Parameters"
+ValueKey: Final[str] = "Value"
+ExportKey: Final[str] = "Export"
+OutputsKey: Final[str] = "Outputs"
 # TODO: expand intrinsic functions set.
 RefKey: Final[str] = "Ref"
 FnIf: Final[str] = "Fn::If"
 FnNot: Final[str] = "Fn::Not"
 FnGetAttKey: Final[str] = "Fn::GetAtt"
 FnEqualsKey: Final[str] = "Fn::Equals"
-INTRINSIC_FUNCTIONS: Final[set[str]] = {RefKey, FnIf, FnNot, FnEqualsKey, FnGetAttKey}
+FnFindInMapKey: Final[str] = "Fn::FindInMap"
+INTRINSIC_FUNCTIONS: Final[set[str]] = {
+    RefKey,
+    FnIf,
+    FnNot,
+    FnEqualsKey,
+    FnGetAttKey,
+    FnFindInMapKey,
+}
 
 
 class ChangeSetModel:
@@ -455,6 +531,36 @@ class ChangeSetModel:
         node_resource = self._retrieve_or_visit_resource(resource_name=logical_id)
         return node_resource.change_type
 
+    def _resolve_intrinsic_function_fn_find_in_map(self, arguments: ChangeSetEntity) -> ChangeType:
+        if arguments.change_type != ChangeType.UNCHANGED:
+            return arguments.change_type
+        # TODO: validate arguments structure and type.
+        # TODO: add support for nested functions, here we assume the arguments are string literals.
+
+        if not isinstance(arguments, NodeArray) or not arguments.array:
+            raise RuntimeError()
+        argument_mapping_name = arguments.array[0]
+        if not isinstance(argument_mapping_name, TerminalValue):
+            raise NotImplementedError()
+        argument_top_level_key = arguments.array[1]
+        if not isinstance(argument_top_level_key, TerminalValue):
+            raise NotImplementedError()
+        argument_second_level_key = arguments.array[2]
+        if not isinstance(argument_second_level_key, TerminalValue):
+            raise NotImplementedError()
+        mapping_name = argument_mapping_name.value
+        top_level_key = argument_top_level_key.value
+        second_level_key = argument_second_level_key.value
+
+        node_mapping = self._retrieve_mapping(mapping_name=mapping_name)
+        # TODO: a lookup would be beneficial in this scenario too;
+        #  consider implications downstream and for replication.
+        top_level_object = node_mapping.bindings.bindings.get(top_level_key)
+        if not isinstance(top_level_object, NodeObject):
+            raise RuntimeError()
+        target_map_value = top_level_object.bindings.get(second_level_key)
+        return target_map_value.change_type
+
     def _resolve_intrinsic_function_fn_if(self, arguments: ChangeSetEntity) -> ChangeType:
         # TODO: validate arguments structure and type.
         if not isinstance(arguments, NodeArray) or not arguments.array:
@@ -507,17 +613,9 @@ class ChangeSetModel:
             binding_scope, (before_value, after_value) = self._safe_access_in(
                 scope, binding_name, before_object, after_object
             )
-            if self._is_intrinsic_function_name(function_name=binding_name):
-                value = self._visit_intrinsic_function(
-                    scope=binding_scope,
-                    intrinsic_function=binding_name,
-                    before_arguments=before_value,
-                    after_arguments=after_value,
-                )
-            else:
-                value = self._visit_value(
-                    scope=binding_scope, before_value=before_value, after_value=after_value
-                )
+            value = self._visit_value(
+                scope=binding_scope, before_value=before_value, after_value=after_value
+            )
             bindings[binding_name] = value
             change_type = change_type.for_child(value.change_type)
         node_object = NodeObject(scope=scope, change_type=change_type, bindings=bindings)
@@ -541,8 +639,11 @@ class ChangeSetModel:
         value = self._visited_scopes.get(scope)
         if isinstance(value, ChangeSetEntity):
             return value
+
+        before_type_name = self._type_name_of(before_value)
+        after_type_name = self._type_name_of(after_value)
         unset = object()
-        if type(before_value) is type(after_value):
+        if before_type_name == after_type_name:
             dominant_value = before_value
         elif self._is_created(before=before_value, after=after_value):
             dominant_value = after_value
@@ -551,6 +652,7 @@ class ChangeSetModel:
         else:
             dominant_value = unset
         if dominant_value is not unset:
+            dominant_type_name = self._type_name_of(dominant_value)
             if self._is_terminal(value=dominant_value):
                 value = self._visit_terminal_value(
                     scope=scope, before_value=before_value, after_value=after_value
@@ -563,6 +665,16 @@ class ChangeSetModel:
                 value = self._visit_array(
                     scope=scope, before_array=before_value, after_array=after_value
                 )
+            elif self._is_intrinsic_function_name(dominant_type_name):
+                intrinsic_function_scope, (before_arguments, after_arguments) = (
+                    self._safe_access_in(scope, dominant_type_name, before_value, after_value)
+                )
+                value = self._visit_intrinsic_function(
+                    scope=scope,
+                    intrinsic_function=dominant_type_name,
+                    before_arguments=before_arguments,
+                    after_arguments=after_arguments,
+                )
             else:
                 raise RuntimeError(f"Unsupported type {type(dominant_value)}")
         # Case: type divergence.
@@ -584,24 +696,24 @@ class ChangeSetModel:
         if isinstance(node_property, NodeProperty):
             return node_property
 
+        value = self._visit_value(
+            scope=scope, before_value=before_property, after_value=after_property
+        )
         if self._is_created(before=before_property, after=after_property):
             node_property = NodeProperty(
                 scope=scope,
                 change_type=ChangeType.CREATED,
                 name=property_name,
-                value=TerminalValueCreated(scope=scope, value=after_property),
+                value=value,
             )
         elif self._is_removed(before=before_property, after=after_property):
             node_property = NodeProperty(
                 scope=scope,
                 change_type=ChangeType.REMOVED,
                 name=property_name,
-                value=TerminalValueRemoved(scope=scope, value=before_property),
+                value=value,
             )
         else:
-            value = self._visit_value(
-                scope=scope, before_value=before_property, after_value=after_property
-            )
             node_property = NodeProperty(
                 scope=scope, change_type=value.change_type, name=property_name, value=value
             )
@@ -655,14 +767,17 @@ class ChangeSetModel:
             change_type = ChangeType.UNCHANGED
 
         # TODO: investigate behaviour with type changes, for now this is filler code.
-        _, type_str = self._safe_access_in(scope, TypeKey, before_resource)
+        _, type_str = self._safe_access_in(scope, TypeKey, after_resource)
 
+        condition_reference = None
         scope_condition, (before_condition, after_condition) = self._safe_access_in(
             scope, ConditionKey, before_resource, after_resource
         )
-        condition_reference = self._visit_terminal_value(
-            scope_condition, before_condition, after_condition
-        )
+        # TODO: condition references should be resolved for the condition's change_type?
+        if before_condition or after_condition:
+            condition_reference = self._visit_terminal_value(
+                scope_condition, before_condition, after_condition
+            )
 
         scope_properties, (before_properties, after_properties) = self._safe_access_in(
             scope, PropertiesKey, before_resource, after_resource
@@ -705,6 +820,36 @@ class ChangeSetModel:
             change_type = change_type.for_child(resource.change_type)
         return NodeResources(scope=scope, change_type=change_type, resources=resources)
 
+    def _visit_mapping(
+        self, scope: Scope, name: str, before_mapping: Maybe[dict], after_mapping: Maybe[dict]
+    ) -> NodeMapping:
+        bindings = self._visit_object(
+            scope=scope, before_object=before_mapping, after_object=after_mapping
+        )
+        return NodeMapping(
+            scope=scope, change_type=bindings.change_type, name=name, bindings=bindings
+        )
+
+    def _visit_mappings(
+        self, scope: Scope, before_mappings: Maybe[dict], after_mappings: Maybe[dict]
+    ) -> NodeMappings:
+        change_type = ChangeType.UNCHANGED
+        mappings: list[NodeMapping] = list()
+        mapping_names = self._safe_keys_of(before_mappings, after_mappings)
+        for mapping_name in mapping_names:
+            scope_mapping, (before_mapping, after_mapping) = self._safe_access_in(
+                scope, mapping_name, before_mappings, after_mappings
+            )
+            mapping = self._visit_mapping(
+                scope=scope,
+                name=mapping_name,
+                before_mapping=before_mapping,
+                after_mapping=after_mapping,
+            )
+            mappings.append(mapping)
+            change_type = change_type.for_child(mapping.change_type)
+        return NodeMappings(scope=scope, change_type=change_type, mappings=mappings)
+
     def _visit_dynamic_parameter(self, parameter_name: str) -> ChangeSetEntity:
         scope = Scope("Dynamic").open_scope("Parameters")
         scope_parameter, (before_parameter, after_parameter) = self._safe_access_in(
@@ -797,18 +942,9 @@ class ChangeSetModel:
         node_condition = self._visited_scopes.get(scope)
         if isinstance(node_condition, NodeCondition):
             return node_condition
-
-        # TODO: is schema validation/check necessary or can we trust the input at this point?
-        function_names: list[str] = self._safe_keys_of(before_condition, after_condition)
-        if len(function_names) == 1:
-            body = self._visit_object(
-                scope=scope, before_object=before_condition, after_object=after_condition
-            )
-        else:
-            body = self._visit_divergence(
-                scope=scope, before_value=before_condition, after_value=after_condition
-            )
-
+        body = self._visit_value(
+            scope=scope, before_value=before_condition, after_value=after_condition
+        )
         node_condition = NodeCondition(
             scope=scope, change_type=body.change_type, name=condition_name, body=body
         )
@@ -842,9 +978,75 @@ class ChangeSetModel:
         self._visited_scopes[scope] = node_conditions
         return node_conditions
 
+    def _visit_output(
+        self, scope: Scope, name: str, before_output: Maybe[dict], after_output: Maybe[dict]
+    ) -> NodeOutput:
+        change_type = ChangeType.UNCHANGED
+        scope_value, (before_value, after_value) = self._safe_access_in(
+            scope, ValueKey, before_output, after_output
+        )
+        value = self._visit_value(scope_value, before_value, after_value)
+        change_type = change_type.for_child(value.change_type)
+
+        export: Optional[ChangeSetEntity] = None
+        scope_export, (before_export, after_export) = self._safe_access_in(
+            scope, ExportKey, before_output, after_output
+        )
+        if before_export or after_export:
+            export = self._visit_value(scope_export, before_export, after_export)
+            change_type = change_type.for_child(export.change_type)
+
+        # TODO: condition references should be resolved for the condition's change_type?
+        condition_reference: Optional[TerminalValue] = None
+        scope_condition, (before_condition, after_condition) = self._safe_access_in(
+            scope, ConditionKey, before_output, after_output
+        )
+        if before_condition or after_condition:
+            condition_reference = self._visit_terminal_value(
+                scope_condition, before_condition, after_condition
+            )
+            change_type = change_type.for_child(condition_reference.change_type)
+
+        return NodeOutput(
+            scope=scope,
+            change_type=change_type,
+            name=name,
+            value=value,
+            export=export,
+            conditional_reference=condition_reference,
+        )
+
+    def _visit_outputs(
+        self, scope: Scope, before_outputs: Maybe[dict], after_outputs: Maybe[dict]
+    ) -> NodeOutputs:
+        change_type = ChangeType.UNCHANGED
+        outputs: list[NodeOutput] = list()
+        output_names: list[str] = self._safe_keys_of(before_outputs, after_outputs)
+        for output_name in output_names:
+            scope_output, (before_output, after_output) = self._safe_access_in(
+                scope, output_name, before_outputs, after_outputs
+            )
+            output = self._visit_output(
+                scope=scope_output,
+                name=output_name,
+                before_output=before_output,
+                after_output=after_output,
+            )
+            outputs.append(output)
+            change_type = change_type.for_child(output.change_type)
+        return NodeOutputs(scope=scope, change_type=change_type, outputs=outputs)
+
     def _model(self, before_template: Maybe[dict], after_template: Maybe[dict]) -> NodeTemplate:
         root_scope = Scope()
         # TODO: visit other child types
+
+        mappings_scope, (before_mappings, after_mappings) = self._safe_access_in(
+            root_scope, MappingsKey, before_template, after_template
+        )
+        mappings = self._visit_mappings(
+            scope=mappings_scope, before_mappings=before_mappings, after_mappings=after_mappings
+        )
+
         parameters_scope, (before_parameters, after_parameters) = self._safe_access_in(
             root_scope, ParametersKey, before_template, after_template
         )
@@ -872,13 +1074,22 @@ class ChangeSetModel:
             after_resources=after_resources,
         )
 
+        outputs_scope, (before_outputs, after_outputs) = self._safe_access_in(
+            root_scope, OutputsKey, before_template, after_template
+        )
+        outputs = self._visit_outputs(
+            scope=outputs_scope, before_outputs=before_outputs, after_outputs=after_outputs
+        )
+
         # TODO: compute the change_type of the template properly.
         return NodeTemplate(
             scope=root_scope,
             change_type=resources.change_type,
+            mappings=mappings,
             parameters=parameters,
             conditions=conditions,
             resources=resources,
+            outputs=outputs,
         )
 
     def _retrieve_condition_if_exists(self, condition_name: str) -> Optional[NodeCondition]:
@@ -919,6 +1130,23 @@ class ChangeSetModel:
             return node_parameter
         return None
 
+    def _retrieve_mapping(self, mapping_name) -> NodeMapping:
+        # TODO: add caching mechanism, and raise appropriate error if missing.
+        scope_mappings, (before_mappings, after_mappings) = self._safe_access_in(
+            Scope(), MappingsKey, self._before_template, self._after_template
+        )
+        before_mappings = before_mappings or dict()
+        after_mappings = after_mappings or dict()
+        if mapping_name in before_mappings or mapping_name in after_mappings:
+            scope_mapping, (before_mapping, after_mapping) = self._safe_access_in(
+                scope_mappings, mapping_name, before_mappings, after_mappings
+            )
+            node_mapping = self._visit_mapping(
+                scope_mapping, mapping_name, before_mapping, after_mapping
+            )
+            return node_mapping
+        raise RuntimeError()
+
     def _retrieve_or_visit_resource(self, resource_name: str) -> NodeResource:
         resources_scope, (before_resources, after_resources) = self._safe_access_in(
             Scope(),
@@ -974,13 +1202,30 @@ class ChangeSetModel:
                 break
         return parent_change_type
 
+    @staticmethod
+    def _name_if_intrinsic_function(value: Maybe[Any]) -> Optional[str]:
+        if isinstance(value, dict):
+            keys = ChangeSetModel._safe_keys_of(value)
+            if len(keys) == 1:
+                key_name = keys[0]
+                if ChangeSetModel._is_intrinsic_function_name(key_name):
+                    return key_name
+        return None
+
+    @staticmethod
+    def _type_name_of(value: Maybe[Any]) -> str:
+        maybe_intrinsic_function_name = ChangeSetModel._name_if_intrinsic_function(value)
+        if maybe_intrinsic_function_name is not None:
+            return maybe_intrinsic_function_name
+        return type(value).__name__
+
     @staticmethod
     def _is_terminal(value: Any) -> bool:
         return type(value) in {int, float, bool, str, None, NothingType}
 
     @staticmethod
     def _is_object(value: Any) -> bool:
-        return isinstance(value, dict)
+        return isinstance(value, dict) and ChangeSetModel._name_if_intrinsic_function(value) is None
 
     @staticmethod
     def _is_array(value: Any) -> bool: