cdk-factory 0.16.12__tar.gz → 0.16.13__tar.gz

{cdk_factory-0.16.12 → cdk_factory-0.16.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdk_factory
-Version: 0.16.12
+Version: 0.16.13
 Summary: CDK Factory. A QuickStarter and best practices setup for CDK projects
 Author-email: Eric Wilson <eric.wilson@geekcafe.com>
 License: MIT License

{cdk_factory-0.16.12 → cdk_factory-0.16.13}/pyproject.toml

@@ -33,7 +33,7 @@ markers = [
 [project]
 
 name = "cdk_factory"
-version = "0.16.12"
+version = "0.16.13"
 authors = [
   { name="Eric Wilson", email="eric.wilson@geekcafe.com" }
 ]

{cdk_factory-0.16.12 → cdk_factory-0.16.13}/src/cdk_factory/configurations/cdk_config.py

@@ -183,9 +183,11 @@ class CdkConfig:
         if self._resolved_config_file_path is None:
             raise ValueError("Config file path is not set")
 
-        file_name = f".dynamic_{os.path.basename(self._resolved_config_file_path)}"
+        file_name = os.path.join(".dynamic", os.path.basename(self._resolved_config_file_path))
         path = os.path.join(Path(self._resolved_config_file_path).parent, file_name)
-
+        
+        if not os.path.exists(Path(path).parent):
+            os.makedirs(Path(path).parent)
         cdk = config.get("cdk", {})
         if replacements and len(replacements) > 0:
             config = JsonLoadingUtility.recursive_replace(config, replacements)
@@ -214,7 +216,7 @@ class CdkConfig:
             value = static_value
         elif environment_variable_name is not None and not value:
             value = os.environ.get(environment_variable_name, None)
-            if value is None and required:
+            if (value is None or str(value).strip() == "") and required:
                 raise ValueError(
                     f"Failed to get value for environment variable {environment_variable_name}"
                 )

{cdk_factory-0.16.12 → cdk_factory-0.16.13}/src/cdk_factory/configurations/resources/ecs_cluster.py

@@ -85,3 +85,17 @@ class EcsClusterConfig:
     def export_ssm_parameters(self) -> bool:
         """Whether to export cluster information to SSM parameters"""
         return self._config.get("export_ssm_parameters", True)
+
+    
+    @property
+    def ssm_exports(self) -> Dict[str, str]:
+        """SSM parameter exports"""
+        return self._config.get("ssm_exports", {})
+
+    @property
+    def ssm_imports(self) -> Dict[str, Any]:
+        """SSM parameter imports"""
+        # Check both nested and flat structures for backwards compatibility
+        if "ssm" in self._config and "imports" in self._config["ssm"]:
+            return self._config["ssm"]["imports"]
+        return self._config.get("ssm_imports", {})

{cdk_factory-0.16.12 → cdk_factory-0.16.13}/src/cdk_factory/stack_library/ecs/ecs_cluster_stack.py

@@ -6,33 +6,31 @@ with proper configurability and explicit resource management.
 """
 
 import logging
-from typing import Optional, Dict, Any, List
+from typing import Optional, Dict, Any
 
 from aws_cdk import (
     aws_ecs as ecs,
-    aws_ec2 as ec2,
     aws_iam as iam,
-    aws_ssm as ssm,
-    RemovalPolicy,
-    Stack,
-    CfnOutput
+    CfnOutput,
 )
 from constructs import Construct
 
 from cdk_factory.configurations.stack import StackConfig
 from cdk_factory.configurations.deployment import DeploymentConfig
 from cdk_factory.configurations.workload import WorkloadConfig
-from cdk_factory.interfaces.ssm_parameter_mixin import SsmParameterMixin
+from cdk_factory.interfaces.vpc_provider_mixin import VPCProviderMixin
 from cdk_factory.configurations.resources.ecs_cluster import EcsClusterConfig
-
+from cdk_factory.stack.stack_module_registry import register_stack
+from cdk_factory.interfaces.istack import IStack
 
 logger = logging.getLogger(__name__)
 
 
-class EcsClusterStack(Stack, SsmParameterMixin):
+@register_stack("ecs_cluster_stack")
+class EcsClusterStack(IStack, VPCProviderMixin):
     """
     A dedicated stack for creating and managing ECS clusters.
-    
+
     This stack provides explicit configuration of ECS clusters including:
     - Cluster naming
     - Container insights
@@ -40,38 +38,64 @@ class EcsClusterStack(Stack, SsmParameterMixin):
     - SSM parameter exports
     - IAM role configurations
     """
-    
-    def __init__(
-        self,
-        scope: Construct,
-        construct_id: str,
-        stack_config: StackConfig,
-        deployment: DeploymentConfig,
-        workload: WorkloadConfig,
-        **kwargs
-    ):
+
+    def __init__(self, scope: Construct, id: str, **kwargs) -> None:
         """
         Initialize the ECS Cluster stack.
         
         Args:
             scope: The CDK construct scope
-            construct_id: The construct ID
-            stack_config: Stack configuration
-            deployment: Deployment configuration
-            workload: Workload configuration
+            id: The construct ID
         """
-        super().__init__(scope, construct_id, **kwargs)
+        super().__init__(scope, id, **kwargs)
+        
+        self._initialize_vpc_cache()
+        
+        self.ecs_config: Optional[EcsClusterConfig] = None
+        self.stack_config: Optional[StackConfig] = None
+        self.deployment: Optional[DeploymentConfig] = None
+        self.workload: Optional[WorkloadConfig] = None
+        self.ecs_cluster: Optional[ecs.Cluster] = None
+        self.instance_role: Optional[iam.Role] = None
+        self.instance_profile: Optional[iam.CfnInstanceProfile] = None
         
+        # SSM imported values
+        self.ssm_imported_values: Dict[str, Any] = {}
+
+    
+
+    def build(
+        self,
+        stack_config: StackConfig,
+        deployment: DeploymentConfig,
+        workload: WorkloadConfig,
+    ) -> None:
+        """Build the ECS Cluster stack"""
+        self._build(stack_config, deployment, workload)
+
+    def _build(
+        self,
+        stack_config: StackConfig,
+        deployment: DeploymentConfig,
+        workload: WorkloadConfig,
+    ) -> None:
+        """Internal build method for the ECS Cluster stack"""
         self.stack_config = stack_config
         self.deployment = deployment
         self.workload = workload
         
+        # Initialize VPC cache from mixin
+        self._initialize_vpc_cache()
+        
         # Load ECS cluster configuration
         self.ecs_config: EcsClusterConfig = EcsClusterConfig(
             stack_config.dictionary.get("ecs_cluster", {})
         )
         
-        logger.info(f"Creating ECS Cluster stack: {construct_id}")
+        logger.info(f"Creating ECS Cluster stack: {self.stack_name}")
+        
+        # Process SSM imports first
+        self.process_ssm_imports(self.ecs_config, deployment, "ECS Cluster")
         
         # Create the ECS cluster
         self._create_ecs_cluster()
@@ -82,159 +106,141 @@ class EcsClusterStack(Stack, SsmParameterMixin):
         # Export cluster information
         self._export_cluster_info()
         
-        logger.info(f"ECS Cluster stack created: {construct_id}")
-    
+        logger.info(f"ECS Cluster stack created: {self.stack_name}")
+
     def _create_ecs_cluster(self):
         """Create the ECS cluster with explicit configuration."""
         logger.info(f"Creating ECS cluster: {self.ecs_config.name}")
-        
+
         # Build cluster settings
         cluster_settings = []
-        
+
         # Add container insights if enabled
         if self.ecs_config.container_insights:
-            cluster_settings.append({
-                "name": "containerInsights",
-                "value": "enabled"
-            })
-        
+            cluster_settings.append({"name": "containerInsights", "value": "enabled"})
+
         # Add custom cluster settings
         if self.ecs_config.cluster_settings:
             cluster_settings.extend(self.ecs_config.cluster_settings)
-        
+
         # Create the ECS cluster
+        self.vpc = self.resolve_vpc(
+            config=self.ecs_config,
+            deployment=self.deployment,
+            workload=self.workload
+        )
+        
         self.ecs_cluster = ecs.Cluster(
             self,
             "ECSCluster",
             cluster_name=self.ecs_config.name,
-            vpc=self._get_vpc(),
+            vpc=self.vpc,
             container_insights=self.ecs_config.container_insights,
             default_cloud_map_namespace=(
-                self.ecs_config.cloud_map_namespace 
-                if self.ecs_config.cloud_map_namespace else None
+                self.ecs_config.cloud_map_namespace
+                if self.ecs_config.cloud_map_namespace
+                else None
             ),
             execute_command_configuration=(
-                self.ecs_config.execute_command_configuration 
-                if self.ecs_config.execute_command_configuration else None
-            )
+                self.ecs_config.execute_command_configuration
+                if self.ecs_config.execute_command_configuration
+                else None
+            ),
         )
-        
+
         logger.info(f"Created ECS cluster: {self.ecs_config.name}")
-    
+
     def _create_iam_roles(self):
         """Create IAM roles for the ECS cluster if configured."""
         if not self.ecs_config.create_instance_role:
             return
-        
+
         logger.info("Creating ECS instance role")
-        
+
         # Create the instance role
         self.instance_role = iam.Role(
             self,
             "ECSInstanceRole",
             assumed_by=iam.ServicePrincipal("ec2.amazonaws.com"),
-            role_name=self.ecs_config.instance_role_name or f"{self.ecs_config.name}-instance-role"
+            role_name=self.ecs_config.instance_role_name
+            or f"{self.ecs_config.name}-instance-role",
         )
-        
+
         # Add managed policies
         for policy in self.ecs_config.managed_policies:
             self.instance_role.add_managed_policy(
                 iam.ManagedPolicy.from_aws_managed_policy_name(policy)
             )
-        
+
         # Add inline policies if provided
         if self.ecs_config.inline_policies:
             for policy_name, policy_document in self.ecs_config.inline_policies.items():
                 self.instance_role.add_to_policy(
                     iam.PolicyStatement.from_json(policy_document)
                 )
-        
+
         # Create instance profile
         self.instance_profile = iam.CfnInstanceProfile(
             self,
             "ECSInstanceProfile",
             roles=[self.instance_role.role_name],
-            instance_profile_name=self.ecs_config.instance_profile_name or f"{self.ecs_config.name}-instance-profile"
+            instance_profile_name=self.ecs_config.instance_profile_name
+            or f"{self.ecs_config.name}-instance-profile",
         )
-        
+
         logger.info("Created ECS instance role and profile")
-    
-    def _get_vpc(self):
-        """Get the VPC for the ECS cluster."""
-        if self.ecs_config.vpc_id:
-            # Import VPC by ID
-            return ec2.Vpc.from_lookup(
-                self,
-                "VPC",
-                vpc_id=self.ecs_config.vpc_id
-            )
-        elif self.ecs_config.ssm_vpc_id:
-            # Import VPC from SSM
-            vpc_id = self._import_ssm_parameter_value(
-                self.ecs_config.ssm_vpc_id,
-                required=True
-            )
-            return ec2.Vpc.from_lookup(
-                self,
-                "VPC", 
-                vpc_id=vpc_id
-            )
-        else:
-            # Use default VPC
-            return ec2.Vpc.from_lookup(
-                self,
-                "VPC",
-                is_default=True
-            )
-    
+
     def _export_cluster_info(self):
         """Export cluster information via SSM parameters and CloudFormation outputs."""
         logger.info("Exporting ECS cluster information")
-        
+
         # Export cluster name
         self.export_ssm_parameter(
-            f"/{self.deployment.name}/{self.workload.name}/ecs/cluster/name",
+            self, "ClusterNameParameter",
             self.ecs_config.name,
-            "ECS Cluster Name"
+            f"/{self.deployment.name}/{self.workload.name}/ecs/cluster/name",
+            "ECS Cluster Name",
         )
-        
+
         # Export cluster ARN
         self.export_ssm_parameter(
-            f"/{self.deployment.name}/{self.workload.name}/ecs/cluster/arn",
+            self, "ClusterArnParameter",
             self.ecs_cluster.cluster_arn,
-            "ECS Cluster ARN"
+            f"/{self.deployment.name}/{self.workload.name}/ecs/cluster/arn",
+            "ECS Cluster ARN",
         )
-        
+
         # Export instance role ARN if created
-        if hasattr(self, 'instance_role'):
+        if hasattr(self, "instance_role"):
             self.export_ssm_parameter(
-                f"/{self.deployment.name}/{self.workload.name}/ecs/instance-role/arn",
+                self, "InstanceRoleArnParameter",
                 self.instance_role.role_arn,
-                "ECS Instance Role ARN"
+                f"/{self.deployment.name}/{self.workload.name}/ecs/instance-role/arn",
+                "ECS Instance Role ARN",
             )
-        
+
         # CloudFormation outputs
         CfnOutput(
             self,
             "cluster-name",
             value=self.ecs_config.name,
             description=f"Name of the ECS cluster: {self.ecs_config.name}",
-            export_name=f"{self.deployment.name}-ecs-cluster-name"
+            export_name=f"{self.deployment.name}-ecs-cluster-name",
         )
-        
+
         CfnOutput(
             self,
             "cluster-arn",
             value=self.ecs_cluster.cluster_arn,
             description=f"ARN of the ECS cluster: {self.ecs_config.name}",
-            export_name=f"{self.deployment.name}-ecs-cluster-arn"
+            export_name=f"{self.deployment.name}-ecs-cluster-arn",
         )
-        
-        if hasattr(self, 'instance_role'):
+
+        if hasattr(self, "instance_role"):
             CfnOutput(
                 self,
                 "instance-role-arn",
                 value=self.instance_role.role_arn,
                 description=f"ARN of the ECS instance role: {self.ecs_config.name}",
-                export_name=f"{self.deployment.name}-ecs-instance-role-arn"
+                export_name=f"{self.deployment.name}-ecs-instance-role-arn",
             )

cdk_factory-0.16.13/src/cdk_factory/version.py

@@ -0,0 +1 @@
+__version__ = "0.16.13"

cdk_factory-0.16.12/src/cdk_factory/version.py

@@ -1 +0,0 @@
-__version__ = "0.16.12"