localstack-core 4.6.1.dev60__py3-none-any.whl → 4.10.1.dev12__py3-none-any.whl

localstack/services/cloudformation/scaffolding/__main__.py

@@ -3,11 +3,12 @@ from __future__ import annotations
 import json
 import os
 import zipfile
+from collections.abc import Generator
 from dataclasses import dataclass
 from enum import Enum, auto
 from functools import reduce
 from pathlib import Path
-from typing import Any, Generator, Literal, Optional, TypedDict, TypeVar
+from typing import Any, Literal, TypedDict, TypeVar
 
 import click
 from jinja2 import Environment, FileSystemLoader
@@ -40,12 +41,12 @@ SERVICE_NAME_MAP = {
 
 
 class Property(TypedDict):
-    type: Optional[Literal["str"]]
-    items: Optional[dict]
+    type: Literal["str"] | None
+    items: dict | None
 
 
 class HandlerDefinition(TypedDict):
-    permissions: Optional[list[str]]
+    permissions: list[str] | None
 
 
 class HandlersDefinition(TypedDict):
@@ -58,8 +59,8 @@ class HandlersDefinition(TypedDict):
 
 class ResourceSchema(TypedDict):
     typeName: str
-    description: Optional[str]
-    required: Optional[list[str]]
+    description: str | None
+    required: list[str] | None
     properties: dict[str, Property]
     handlers: HandlersDefinition
 
@@ -171,7 +172,7 @@ def tests_root_dir(pro: bool = False) -> Path:
 def template_path(
     resource_name: ResourceName,
     file_type: FileType,
-    root: Optional[Path] = None,
+    root: Path | None = None,
     pro: bool = False,
 ) -> Path:
     """
@@ -266,11 +267,11 @@ class TemplateRenderer:
             # FileType.cloudcontrol_test: "test_cloudcontrol_template.py.j2",
             FileType.parity_test: "test_parity_template.py.j2",
         }
-        kwargs = dict(
-            name=resource_name.full_name,  # AWS::SNS::Topic
-            resource=resource_name.provider_name(),  # SNSTopic
-            scaffolding_version=f"v{SCAFFOLDING_VERSION}",
-        )
+        kwargs = {
+            "name": resource_name.full_name,  # AWS::SNS::Topic
+            "resource": resource_name.provider_name(),  # SNSTopic
+            "scaffolding_version": f"v{SCAFFOLDING_VERSION}",
+        }
         # TODO: we might want to segregate each provider in its own directory
         # e.g. .../resource_providers/aws_iam_role/test_X.py vs. .../resource_providers/iam/test_X.py
         # add extra parameters

localstack/services/cloudformation/scaffolding/propgen.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 import logging
 import textwrap
 from dataclasses import dataclass
-from typing import Optional, TypedDict
+from typing import TypedDict
 
 LOG = logging.getLogger(__name__)
 
@@ -86,7 +86,7 @@ class Schema(TypedDict):
     properties: dict
     definitions: dict
     typeName: str
-    required: Optional[list[str]]
+    required: list[str] | None
 
 
 TYPE_MAP = {

localstack/services/cloudformation/service_models.py

@@ -13,8 +13,8 @@ class DependencyNotYetSatisfied(Exception):
     """Exception indicating that a resource dependency is not (yet) deployed/available."""
 
     def __init__(self, resource_ids, message=None):
-        message = message or "Unresolved dependencies: %s" % resource_ids
-        super(DependencyNotYetSatisfied, self).__init__(message)
+        message = message or f"Unresolved dependencies: {resource_ids}"
+        super().__init__(message)
         resource_ids = resource_ids if isinstance(resource_ids, list) else [resource_ids]
         self.resource_ids = resource_ids
 

localstack/services/cloudformation/stores.py

@@ -1,10 +1,10 @@
 import logging
-from typing import Optional
 
-from localstack.aws.api.cloudformation import StackStatus
+from localstack.aws.api.cloudformation import Export, StackStatus
 from localstack.services.cloudformation.engine.entities import Stack, StackChangeSet, StackSet
 from localstack.services.cloudformation.v2.entities import ChangeSet as ChangeSetV2
 from localstack.services.cloudformation.v2.entities import Stack as StackV2
+from localstack.services.cloudformation.v2.entities import StackSet as StackSetV2
 from localstack.services.stores import AccountRegionBundle, BaseStore, LocalAttribute
 
 LOG = logging.getLogger(__name__)
@@ -19,35 +19,49 @@ class CloudFormationStore(BaseStore):
 
     # maps stack set ID to stack set details
     stack_sets: dict[str, StackSet] = LocalAttribute(default=dict)
+    stack_sets_v2: dict[str, StackSetV2] = LocalAttribute(default=dict)
 
     # maps macro ID to macros
     macros: dict[str, dict] = LocalAttribute(default=dict)
 
-    # exports: dict[str, str]
     @property
-    def exports(self):
-        exports = []
-        output_keys = {}
+    def exports(self) -> dict[str, Export]:
+        exports = {}
+
         for stack_id, stack in self.stacks.items():
+            if stack.status == StackStatus.DELETE_COMPLETE:
+                continue
+
             for output in stack.resolved_outputs:
                 export_name = output.get("ExportName")
                 if not export_name:
                     continue
-                if export_name in output_keys:
+                if export_name in exports.keys():
                     # TODO: raise exception on stack creation in case of duplicate exports
                     LOG.warning(
                         "Found duplicate export name %s in stacks: %s %s",
                         export_name,
-                        output_keys[export_name],
+                        output["OutputValue"],
                         stack.stack_id,
                     )
-                entry = {
-                    "ExportingStackId": stack.stack_id,
-                    "Name": export_name,
-                    "Value": output["OutputValue"],
-                }
-                exports.append(entry)
-                output_keys[export_name] = stack.stack_id
+                exports[export_name] = Export(
+                    ExportingStackId=stack.stack_id, Name=export_name, Value=output["OutputValue"]
+                )
+
+        return exports
+
+    @property
+    def exports_v2(self) -> dict[str, Export]:
+        exports = {}
+        stacks_v2 = self.stacks_v2.values()
+        for stack in stacks_v2:
+            if stack.status == StackStatus.DELETE_COMPLETE:
+                continue
+            for export_name, export_value in stack.resolved_exports.items():
+                exports[export_name] = Export(
+                    ExportingStackId=stack.stack_id, Name=export_name, Value=export_value
+                )
+
         return exports
 
 
@@ -112,9 +126,9 @@ def find_change_set(
     account_id: str,
     region_name: str,
     cs_name: str,
-    stack_name: Optional[str] = None,
+    stack_name: str | None = None,
     active_only: bool = False,
-) -> Optional[StackChangeSet]:
+) -> StackChangeSet | None:
     store = get_cloudformation_store(account_id, region_name)
     for stack in store.stacks.values():
         if active_only and stack.status == StackStatus.DELETE_COMPLETE:
@@ -126,9 +140,6 @@ def find_change_set(
     return None
 
 
-def exports_map(account_id: str, region_name: str):
-    result = {}
+def exports_map(account_id: str, region_name: str) -> dict[str, Export]:
     store = get_cloudformation_store(account_id, region_name)
-    for export in store.exports:
-        result[export["Name"]] = export
-    return result
+    return {**store.exports, **store.exports_v2}

localstack/services/cloudformation/v2/entities.py

@@ -1,6 +1,5 @@
-import copy
-from datetime import datetime, timezone
-from typing import NotRequired, Optional, TypedDict
+from datetime import UTC, datetime
+from typing import NotRequired, TypedDict
 
 from localstack.aws.api.cloudformation import (
     Capability,
@@ -8,40 +7,41 @@ from localstack.aws.api.cloudformation import (
     ChangeSetType,
     CreateChangeSetInput,
     CreateStackInput,
+    CreateStackSetInput,
     ExecutionStatus,
     Output,
-    Parameter,
     ResourceStatus,
-    StackDriftInformation,
-    StackDriftStatus,
     StackEvent,
+    StackInstanceComprehensiveStatus,
+    StackInstanceDetailedStatus,
+    StackInstanceStatus,
     StackResource,
+    StackSetOperation,
     StackStatus,
     StackStatusReason,
+    Tag,
 )
 from localstack.aws.api.cloudformation import (
-    Stack as ApiStack,
+    Parameter as ApiParameter,
 )
 from localstack.services.cloudformation.engine.entities import (
-    StackIdentifier,
+    StackIdentifierV2,
 )
 from localstack.services.cloudformation.engine.v2.change_set_model import (
     ChangeType,
     UpdateModel,
 )
+from localstack.services.cloudformation.v2.types import EngineParameter, ResolvedResource
 from localstack.utils.aws import arns
 from localstack.utils.strings import long_uid, short_uid
 
 
-class ResolvedResource(TypedDict):
-    Type: str
-    Properties: dict
-
-
 class Stack:
     stack_name: str
-    parameters: list[Parameter]
+    description: str | None
+    parameters: list[ApiParameter]
     change_set_id: str | None
+    change_set_ids: set[str]
     status: StackStatus
     status_reason: StackStatusReason | None
     stack_id: str
@@ -50,42 +50,45 @@ class Stack:
     events: list[StackEvent]
     capabilities: list[Capability]
     enable_termination_protection: bool
+    template: dict | None
     processed_template: dict | None
+    template_body: str | None
+    tags: list[Tag]
 
     # state after deploy
-    resolved_parameters: dict[str, str]
+    resolved_parameters: dict[str, EngineParameter]
     resolved_resources: dict[str, ResolvedResource]
-    resolved_outputs: dict[str, str]
+    resolved_outputs: list[Output]
     resource_states: dict[str, StackResource]
+    resolved_exports: dict[str, str]
 
     def __init__(
         self,
         account_id: str,
         region_name: str,
         request_payload: CreateChangeSetInput | CreateStackInput,
-        template: dict | None = None,
-        template_body: str | None = None,
         initial_status: StackStatus = StackStatus.CREATE_IN_PROGRESS,
+        tags: list[Tag] | None = None,
     ):
         self.account_id = account_id
         self.region_name = region_name
-        self.template = template
-        self.template_original = copy.deepcopy(self.template)
-        self.template_body = template_body
         self.status = initial_status
         self.status_reason = None
-        self.change_set_ids = []
-        self.creation_time = datetime.now(tz=timezone.utc)
+        self.change_set_ids = set()
+        self.creation_time = datetime.now(tz=UTC)
         self.deletion_time = None
         self.change_set_id = None
         self.enable_termination_protection = False
+        self.template = None
         self.processed_template = None
+        self.template_body = None
+        self.tags = tags or []
 
         self.stack_name = request_payload["StackName"]
         self.parameters = request_payload.get("Parameters", [])
         self.stack_id = arns.cloudformation_stack_arn(
             self.stack_name,
-            stack_id=StackIdentifier(
+            stack_id=StackIdentifierV2(
                 account_id=self.account_id, region=self.region_name, stack_name=self.stack_name
             ).generate(tags=request_payload.get("Tags")),
             account_id=self.account_id,
@@ -99,16 +102,24 @@ class Stack:
         # state after deploy
         self.resolved_parameters = {}
         self.resolved_resources = {}
-        self.resolved_outputs = {}
+        self.resolved_outputs = []
         self.resource_states = {}
         self.events = []
+        self.resolved_exports = {}
+        self.description = None
 
     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)
+        self._store_event(
+            resource_id=self.stack_name,
+            resource_type="AWS::CloudFormation::Stack",
+            physical_resource_id=self.stack_id,
+            status=status,
+            status_reason=reason,
+        )
 
     def set_resource_status(
         self,
@@ -125,7 +136,7 @@ class Stack:
             LogicalResourceId=logical_resource_id,
             PhysicalResourceId=physical_resource_id,
             ResourceType=resource_type,
-            Timestamp=datetime.now(tz=timezone.utc),
+            Timestamp=datetime.now(tz=UTC),
             ResourceStatus=status,
             ResourceStatusReason=resource_status_reason,
         )
@@ -137,78 +148,39 @@ class Stack:
             self.resource_states.pop(logical_resource_id)
         else:
             self.resource_states[logical_resource_id] = resource_description
-        self._store_event(logical_resource_id, physical_resource_id, status, resource_status_reason)
+
+        self._store_event(
+            resource_id=logical_resource_id,
+            resource_type=resource_type,
+            physical_resource_id=physical_resource_id,
+            status=status,
+            status_reason=resource_status_reason,
+        )
 
     def _store_event(
         self,
         resource_id: str = None,
-        physical_res_id: str = None,
-        status: str = "",
+        resource_type: str | None = "",
+        physical_resource_id: str = None,
+        status: StackStatus | ResourceStatus = "",
         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=UTC),
+            StackId=self.stack_id,
+            StackName=self.stack_name,
+            LogicalResourceId=resource_id,
+            PhysicalResourceId=physical_resource_id,
+            ResourceStatus=status,
+            ResourceType=resource_type,
         )
 
-        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 = {
-            "CreationTime": self.creation_time,
-            "DeletionTime": self.deletion_time,
-            "StackId": self.stack_id,
-            "StackName": self.stack_name,
-            "StackStatus": self.status,
-            "StackStatusReason": self.status_reason,
-            # fake values
-            "DisableRollback": False,
-            "DriftInformation": StackDriftInformation(
-                StackDriftStatus=StackDriftStatus.NOT_CHECKED
-            ),
-            "EnableTerminationProtection": self.enable_termination_protection,
-            "LastUpdatedTime": self.creation_time,
-            "RollbackConfiguration": {},
-            "Tags": [],
-            "NotificationARNs": [],
-            "Capabilities": self.capabilities,
-            "Parameters": self.parameters,
-        }
-        # TODO: confirm the logic for this
-        if change_set_id := self.change_set_id:
-            result["ChangeSetId"] = change_set_id
-
-        if self.resolved_outputs:
-            describe_outputs = []
-            for key, value in self.resolved_outputs.items():
-                describe_outputs.append(
-                    Output(
-                        # TODO(parity): Description, ExportName
-                        # TODO(parity): what happens on describe stack when the stack has not been deployed yet?
-                        OutputKey=key,
-                        OutputValue=value,
-                    )
-                )
-            result["Outputs"] = describe_outputs
-        return result
-
     def is_active(self) -> bool:
         return self.status != StackStatus.DELETE_COMPLETE
 
@@ -222,34 +194,44 @@ class ChangeSet:
     change_set_name: str
     change_set_id: str
     change_set_type: ChangeSetType
-    update_model: Optional[UpdateModel]
+    update_model: UpdateModel | None
     status: ChangeSetStatus
     status_reason: str | None
     execution_status: ExecutionStatus
     creation_time: datetime
+    processed_template: dict | None
+    resolved_parameters: dict[str, EngineParameter]
+    description: str | None
+    tags: list[Tag]
 
     def __init__(
         self,
         stack: Stack,
         request_payload: ChangeSetRequestPayload,
+        template_body: str,
         template: dict | None = None,
     ):
         self.stack = stack
+        self.template_body = template_body
         self.template = template
         self.status = ChangeSetStatus.CREATE_IN_PROGRESS
         self.status_reason = None
         self.execution_status = ExecutionStatus.AVAILABLE
         self.update_model = None
-        self.creation_time = datetime.now(tz=timezone.utc)
+        self.creation_time = datetime.now(tz=UTC)
+        self.resolved_parameters = {}
+        self.tags = request_payload.get("Tags") or []
 
         self.change_set_name = request_payload["ChangeSetName"]
         self.change_set_type = request_payload.get("ChangeSetType", ChangeSetType.UPDATE)
+        self.description = request_payload.get("Description")
         self.change_set_id = arns.cloudformation_change_set_arn(
             self.change_set_name,
             change_set_id=short_uid(),
             account_id=self.stack.account_id,
             region_name=self.stack.region_name,
         )
+        self.processed_template = None
 
     def set_update_model(self, update_model: UpdateModel) -> None:
         self.update_model = update_model
@@ -270,3 +252,36 @@ class ChangeSet:
     @property
     def region_name(self) -> str:
         return self.stack.region_name
+
+
+class StackInstance:
+    def __init__(
+        self, account_id: str, region_name: str, stack_set_id: str, operation_id: str, stack_id: str
+    ):
+        self.account_id = account_id
+        self.region_name = region_name
+        self.stack_set_id = stack_set_id
+        self.operation_id = operation_id
+        self.stack_id = stack_id
+
+        self.status: StackInstanceStatus = StackInstanceStatus.CURRENT
+        self.stack_instance_status = StackInstanceComprehensiveStatus(
+            DetailedStatus=StackInstanceDetailedStatus.SUCCEEDED
+        )
+
+
+class StackSet:
+    stack_instances: list[StackInstance]
+    operations: dict[str, StackSetOperation]
+
+    def __init__(self, account_id: str, region_name: str, request_payload: CreateStackSetInput):
+        self.account_id = account_id
+        self.region_name = region_name
+
+        self.stack_set_name = request_payload["StackSetName"]
+        self.stack_set_id = f"{self.stack_set_name}:{long_uid()}"
+        self.template_body = request_payload.get("TemplateBody")
+        self.template_url = request_payload.get("TemplateURL")
+
+        self.stack_instances = []
+        self.operations = {}