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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdk_factory
-Version: 0.16.11
+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.11 → cdk_factory-0.16.13}/pyproject.toml

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

{cdk_factory-0.16.11 → 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.13/src/cdk_factory/configurations/resources/ecs_cluster.py

@@ -0,0 +1,101 @@
+"""
+ECS Cluster Configuration
+
+Defines the configuration schema for ECS cluster stacks.
+"""
+
+from typing import Optional, Dict, Any, List
+
+
+class EcsClusterConfig:
+    """
+    Configuration for an ECS cluster.
+    
+    This class defines all the configurable parameters for an ECS cluster,
+    providing explicit control over cluster creation and settings.
+    """
+    
+    def __init__(self, config: Dict[str, Any]) -> None:
+        self._config = config or {}
+    
+    @property
+    def name(self) -> str:
+        """Name of the ECS cluster. Supports template variables like {{WORKLOAD_NAME}}-{{ENVIRONMENT}}-cluster"""
+        return self._config.get("name", "cluster")
+    
+    @property
+    def container_insights(self) -> bool:
+        """Enable container insights for the cluster"""
+        return self._config.get("container_insights", True)
+    
+    @property
+    def cluster_settings(self) -> Optional[List[Dict[str, str]]]:
+        """Additional cluster settings as name-value pairs"""
+        return self._config.get("cluster_settings")
+    
+    @property
+    def cloud_map_namespace(self) -> Optional[Dict[str, Any]]:
+        """Cloud Map namespace configuration for service discovery"""
+        return self._config.get("cloud_map_namespace")
+    
+    @property
+    def execute_command_configuration(self) -> Optional[Dict[str, Any]]:
+        """Execute command configuration for ECS"""
+        return self._config.get("execute_command_configuration")
+    
+    @property
+    def vpc_id(self) -> Optional[str]:
+        """VPC ID where the cluster should be created"""
+        return self._config.get("vpc_id")
+    
+    @property
+    def ssm_vpc_id(self) -> Optional[str]:
+        """SSM parameter path to import VPC ID"""
+        return self._config.get("ssm_vpc_id")
+    
+    @property
+    def create_instance_role(self) -> bool:
+        """Whether to create an ECS instance role"""
+        return self._config.get("create_instance_role", True)
+    
+    @property
+    def instance_role_name(self) -> Optional[str]:
+        """Custom name for the ECS instance role"""
+        return self._config.get("instance_role_name")
+    
+    @property
+    def instance_profile_name(self) -> Optional[str]:
+        """Custom name for the ECS instance profile"""
+        return self._config.get("instance_profile_name")
+    
+    @property
+    def managed_policies(self) -> List[str]:
+        """List of AWS managed policies to attach to the instance role"""
+        return self._config.get("managed_policies", [
+            "service-role/AmazonEC2ContainerServiceforEC2Role",
+            "AmazonSSMManagedInstanceCore"
+        ])
+    
+    @property
+    def inline_policies(self) -> Optional[Dict[str, Dict[str, Any]]]:
+        """Inline IAM policies to attach to the instance role"""
+        return self._config.get("inline_policies")
+    
+    @property
+    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.11 → cdk_factory-0.16.13}/src/cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py

@@ -632,56 +632,34 @@ class AutoScalingStack(IStack, VPCProviderMixin):
             # Scheduled action implementation would go here
             pass
 
-    def _create_ecs_cluster_if_needed(self, asg_name: str) -> None:
-        """Create ECS cluster if ECS configuration is detected"""
-        # Check if this is an ECS configuration by looking for ECS-related patterns
-        is_ecs_config = (
-            # Check if ECS managed policy is attached
-            any("AmazonEC2ContainerServiceforEC2Role" in policy for policy in self.asg_config.managed_policies) or
-            # Check for explicit ECS configuration
-            self.stack_config.dictionary.get("auto_scaling", {}).get("enable_ecs_cluster", False)
-        )
-        
-        if not is_ecs_config:
-            logger.debug("No ECS configuration detected, skipping cluster creation")
+    def _create_ecs_cluster_if_needed(self, asg_name: str):
+        """
+        ECS cluster creation should be handled by the dedicated EcsClusterStack module.
+        This method only handles SSM imports for cluster name injection.
+        """
+        # Check if ECS cluster name is available via SSM imports
+        if self.has_ssm_import("ecs_cluster_name"):
+            logger.info(f"ECS cluster name available via SSM imports")
+            # Inject cluster name into user data if available
+            if self.user_data and self.user_data_commands:
+                self._inject_cluster_name_into_user_data()
             return
         
-        # Generate cluster name from stack configuration
-        cluster_name = f"{self.workload.name}-{self.workload.environment}-cluster"
-        
-        logger.info(f"Creating ECS cluster: {cluster_name}")
-        
-        # Create ECS cluster
-        self.ecs_cluster = ecs.Cluster(
-            self,
-            "ECSCluster",
-            cluster_name=cluster_name,
-            vpc=self.vpc,
-            container_insights=True
-        )
-        
-        # Inject the cluster name into user data if user data exists
-        if self.user_data and self.user_data_commands:
-            self._inject_cluster_name_into_user_data(cluster_name)
-        
-        # Export cluster name
-        cdk.CfnOutput(
-            self,
-            f"{cluster_name}-name",
-            value=self.ecs_cluster.cluster_name,
-            export_name=f"{self.deployment.build_resource_name(cluster_name)}-name",
-        )
-        
-        # Export cluster ARN
-        cdk.CfnOutput(
-            self,
-            f"{cluster_name}-arn",
-            value=self.ecs_cluster.cluster_arn,
-            export_name=f"{self.deployment.build_resource_name(cluster_name)}-arn",
+        logger.warning(
+            "No ECS cluster name found in SSM imports. "
+            "Use the dedicated EcsClusterStack module to create ECS clusters."
         )
 
-    def _inject_cluster_name_into_user_data(self, cluster_name: str) -> None:
-        """Inject the ECS cluster name into user data commands"""
+    def _inject_cluster_name_into_user_data(self) -> None:
+        """Inject the ECS cluster name into user data commands using SSM imports"""
+        # Check if ECS cluster name is available via SSM imports
+        if self.has_ssm_import("ecs_cluster_name"):
+            cluster_name = self.get_ssm_imported_value("ecs_cluster_name")
+            logger.info(f"Using ECS cluster name from SSM: {cluster_name}")
+        else:
+            logger.warning("No ECS cluster name found in SSM imports, skipping cluster name injection")
+            return
+        
         injected_commands = []
         cluster_name_injected = False
         

cdk_factory-0.16.13/src/cdk_factory/stack_library/ecs/__init__.py

@@ -0,0 +1,14 @@
+"""
+ECS Stack Library
+
+Contains ECS-related stack modules for creating and managing
+ECS clusters, services, and related resources.
+"""
+
+from .ecs_cluster_stack import EcsClusterStack
+from .ecs_service_stack import EcsServiceStack
+
+__all__ = [
+    "EcsClusterStack",
+    "EcsServiceStack"
+]

cdk_factory-0.16.13/src/cdk_factory/stack_library/ecs/ecs_cluster_stack.py

@@ -0,0 +1,246 @@
+"""
+ECS Cluster Stack Module
+
+Provides a dedicated stack for creating and configuring ECS clusters
+with proper configurability and explicit resource management.
+"""
+
+import logging
+from typing import Optional, Dict, Any
+
+from aws_cdk import (
+    aws_ecs as ecs,
+    aws_iam as iam,
+    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.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__)
+
+
+@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
+    - Cluster settings
+    - SSM parameter exports
+    - IAM role configurations
+    """
+
+    def __init__(self, scope: Construct, id: str, **kwargs) -> None:
+        """
+        Initialize the ECS Cluster stack.
+        
+        Args:
+            scope: The CDK construct scope
+            id: The construct ID
+        """
+        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: {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()
+        
+        # Create IAM roles if needed
+        self._create_iam_roles()
+        
+        # Export cluster information
+        self._export_cluster_info()
+        
+        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"})
+
+        # 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.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
+            ),
+            execute_command_configuration=(
+                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",
+        )
+
+        # 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",
+        )
+
+        logger.info("Created ECS instance role and profile")
+
+    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(
+            self, "ClusterNameParameter",
+            self.ecs_config.name,
+            f"/{self.deployment.name}/{self.workload.name}/ecs/cluster/name",
+            "ECS Cluster Name",
+        )
+
+        # Export cluster ARN
+        self.export_ssm_parameter(
+            self, "ClusterArnParameter",
+            self.ecs_cluster.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"):
+            self.export_ssm_parameter(
+                self, "InstanceRoleArnParameter",
+                self.instance_role.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",
+        )
+
+        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",
+        )
+
+        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",
+            )

cdk_factory-0.16.13/src/cdk_factory/version.py

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

cdk_factory-0.16.11/src/cdk_factory/version.py

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