cdk-factory 0.18.0__py3-none-any.whl → 0.18.4__py3-none-any.whl

cdk_factory/configurations/resources/ecs_cluster.py

@@ -18,6 +18,11 @@ class EcsClusterConfig:
     def __init__(self, config: Dict[str, Any]) -> None:
         self._config = config or {}
     
+    @property
+    def dictionary(self) -> Dict[str, Any]:
+        """Access to the underlying configuration dictionary (for compatibility with SSM mixin)"""
+        return self._config
+    
     @property
     def name(self) -> str:
         """Name of the ECS cluster. Supports template variables like {{WORKLOAD_NAME}}-{{ENVIRONMENT}}-cluster"""

cdk_factory/stack_library/auto_scaling/auto_scaling_old.py

@@ -0,0 +1,721 @@
+"""
+Auto Scaling Group Stack Pattern for CDK-Factory
+Maintainers: Eric Wilson
+MIT License.  See Project Root for the license information.
+"""
+
+from typing import Dict, Any, List, Optional
+
+import aws_cdk as cdk
+from aws_cdk import aws_ec2 as ec2
+from aws_cdk import aws_autoscaling as autoscaling
+from aws_cdk import aws_cloudwatch as cloudwatch
+from aws_cdk import aws_iam as iam
+from aws_cdk import aws_ssm as ssm
+from aws_cdk import aws_ecs as ecs
+from aws_cdk import Duration, Stack
+from aws_lambda_powertools import Logger
+from constructs import Construct
+
+from cdk_factory.configurations.deployment import DeploymentConfig
+from cdk_factory.configurations.stack import StackConfig
+from cdk_factory.configurations.resources.auto_scaling import AutoScalingConfig
+from cdk_factory.interfaces.istack import IStack
+from cdk_factory.interfaces.vpc_provider_mixin import VPCProviderMixin
+from cdk_factory.stack.stack_module_registry import register_stack
+from cdk_factory.workload.workload_factory import WorkloadConfig
+
+logger = Logger(service="AutoScalingStack")
+
+
+@register_stack("auto_scaling_library_module_old")
+@register_stack("auto_scaling_stack_old")
+class AutoScalingStack(IStack, VPCProviderMixin):
+    """
+    Reusable stack for AWS Auto Scaling Groups.
+    Supports creating EC2 Auto Scaling Groups with customizable configurations.
+    
+    Uses enhanced SsmParameterMixin (via IStack) to eliminate SSM code duplication.
+    """
+
+    def __init__(self, scope: Construct, id: str, **kwargs) -> None:
+        # Initialize parent class properly - IStack inherits from enhanced SsmParameterMixin
+        super().__init__(scope, id, **kwargs)
+        
+        # Initialize VPC cache from mixin
+        self._initialize_vpc_cache()
+        
+        self.asg_config = None
+        self.stack_config = None
+        self.deployment = None
+        self.workload = None
+        self.security_groups = []
+        self.auto_scaling_group = None
+        self.launch_template = None
+        self.instance_role = None
+        self.user_data = None
+        self.user_data_commands = []  # Store raw commands for ECS cluster detection
+        self.ecs_cluster = None
+        
+        # SSM imports storage is now handled by the enhanced SsmParameterMixin via IStack
+        # VPC caching is now handled by VPCProviderMixin
+
+    def build(
+        self,
+        stack_config: StackConfig,
+        deployment: DeploymentConfig,
+        workload: WorkloadConfig,
+    ) -> None:
+        """Build the Auto Scaling Group stack"""
+        self._build(stack_config, deployment, workload)
+
+    def _build(
+        self,
+        stack_config: StackConfig,
+        deployment: DeploymentConfig,
+        workload: WorkloadConfig,
+    ) -> None:
+        """Internal build method for the Auto Scaling Group stack"""
+        self.stack_config = stack_config
+        self.deployment = deployment
+        self.workload = workload
+
+        self.asg_config = AutoScalingConfig(
+            stack_config.dictionary.get("auto_scaling", {}), deployment
+        )
+        asg_name = deployment.build_resource_name(self.asg_config.name)
+
+        # Process SSM imports using enhanced SsmParameterMixin
+        self.process_ssm_imports(self.asg_config, deployment, "Auto Scaling Group")
+
+        # Get security groups
+        self.security_groups = self._get_security_groups()
+
+        # Create IAM role for instances
+        self.instance_role = self._create_instance_role(asg_name)
+
+        # Create user data
+        self.user_data = self._create_user_data()
+
+        # Create ECS cluster if ECS configuration is detected
+        # This must happen before launch template creation so user data can be updated
+        self._create_ecs_cluster_if_needed(asg_name)
+
+        # Create launch template
+        self.launch_template = self._create_launch_template(asg_name)
+
+        # Create Auto Scaling Group
+        self.auto_scaling_group = self._create_auto_scaling_group(asg_name)
+
+        # Add scaling policies
+        self._add_scaling_policies()
+
+        # Add scheduled actions
+        self._add_scheduled_actions()
+
+        # Export resources
+        self._export_resources(asg_name)
+
+    @property
+    def vpc(self) -> ec2.IVpc:
+        """Get the VPC for the Auto Scaling Group using VPCProviderMixin"""
+        if not self.asg_config:
+            raise AttributeError("AutoScalingStack not properly initialized. Call build() first.")
+
+        # Use VPCProviderMixin to resolve VPC with proper subnet handling
+        return self.resolve_vpc(
+            config=self.asg_config,
+            deployment=self.deployment,
+            workload=self.workload
+        )
+
+    def _get_target_group_arns(self) -> List[str]:
+        """Get target group ARNs from SSM imports using enhanced SsmParameterMixin"""
+        target_group_arns = []
+
+        # Check if we have SSM imports for target groups using enhanced mixin
+        if self.has_ssm_import("target_group_arns"):
+            imported_tg_arns = self.get_ssm_imported_value("target_group_arns", [])
+            if isinstance(imported_tg_arns, list):
+                target_group_arns.extend(imported_tg_arns)
+            else:
+                target_group_arns.append(imported_tg_arns)
+
+        # see if we have any directly defined in the config
+        if self.asg_config.target_group_arns:
+            for arn in self.asg_config.target_group_arns:
+                logger.info(f"Adding target group ARN: {arn}")
+                target_group_arns.append(arn)
+
+        return target_group_arns
+
+    def _attach_target_groups(self, asg: autoscaling.AutoScalingGroup) -> None:
+        """Attach the Auto Scaling Group to target groups"""
+        target_group_arns = self._get_target_group_arns()
+
+        if not target_group_arns:
+            logger.warning("No target group ARNs found for Auto Scaling Group")
+            print(
+                "⚠️ No target group ARNs found for Auto Scaling Group.  Nothing will be attached."
+            )
+            return
+
+        # Get the underlying CloudFormation resource to add target group ARNs
+        cfn_asg = asg.node.default_child
+        cfn_asg.add_property_override("TargetGroupARNs", target_group_arns)
+
+    def _get_security_groups(self) -> List[ec2.ISecurityGroup]:
+        """Get security groups for the Auto Scaling Group"""
+        security_groups = []
+        for sg_id in self.asg_config.security_group_ids:
+            # if the security group id contains a comma, it is a list of security group ids
+            if "," in sg_id:
+                blocks = sg_id.split(",")
+                for block in blocks:
+                    security_groups.append(
+                        ec2.SecurityGroup.from_security_group_id(
+                            self, f"SecurityGroup-{block}", block
+                        )
+                    )
+            else:
+                # TODO: add some additional checks to make it more robust
+                security_groups.append(
+                    ec2.SecurityGroup.from_security_group_id(
+                        self, f"SecurityGroup-{sg_id}", sg_id
+                    )
+                )
+        return security_groups
+
+    def _create_instance_role(self, asg_name: str) -> iam.Role:
+        """Create IAM role for EC2 instances"""
+        role = iam.Role(
+            self,
+            f"{asg_name}-InstanceRole",
+            assumed_by=iam.ServicePrincipal("ec2.amazonaws.com"),
+            role_name=f"{asg_name}-role",
+        )
+
+        # Add managed policies
+        for policy_name in self.asg_config.managed_policies:
+            role.add_managed_policy(
+                iam.ManagedPolicy.from_aws_managed_policy_name(policy_name)
+            )
+
+        # Add inline policies (for custom permissions like S3 bucket access)
+        for policy_config in self.asg_config.iam_inline_policies:
+            policy_name = policy_config.get("name", "CustomPolicy")
+            statements = policy_config.get("statements", [])
+            
+            if not statements:
+                logger.warning(f"No statements found for inline policy {policy_name}, skipping")
+                continue
+            
+            # Build policy statements
+            policy_statements = []
+            for stmt in statements:
+                effect = iam.Effect.ALLOW if stmt.get("effect", "Allow") == "Allow" else iam.Effect.DENY
+                actions = stmt.get("actions", [])
+                resources = stmt.get("resources", [])
+                
+                if not actions or not resources:
+                    logger.warning(f"Incomplete statement in policy {policy_name}, skipping")
+                    continue
+                
+                policy_statements.append(
+                    iam.PolicyStatement(
+                        effect=effect,
+                        actions=actions,
+                        resources=resources
+                    )
+                )
+            
+            if policy_statements:
+                role.add_to_principal_policy(policy_statements[0])
+                for stmt in policy_statements[1:]:
+                    role.add_to_principal_policy(stmt)
+                
+                logger.info(f"Added inline policy {policy_name} with {len(policy_statements)} statements")
+
+        return role
+
+    def _create_user_data(self) -> ec2.UserData:
+        """Create user data for EC2 instances"""
+        user_data = ec2.UserData.for_linux()
+
+        # Store raw commands for ECS cluster detection
+        self.user_data_commands = ["set -euxo pipefail"]
+
+        # Add base commands
+        user_data.add_commands("set -euxo pipefail")
+
+        # Add custom commands from config (with variable substitution)
+        for command in self.asg_config.user_data_commands:
+            # Perform variable substitution on the command
+            substituted_command = self._substitute_variables(command)
+            user_data.add_commands(substituted_command)
+            self.user_data_commands.append(substituted_command)
+
+        # Add user data scripts from files (with variable substitution)
+        if self.asg_config.user_data_scripts:
+            self._add_user_data_scripts_from_files(user_data)
+
+        # Add container configuration if specified
+        container_config = self.asg_config.container_config
+        if container_config:
+            self._add_container_user_data(user_data, container_config)
+
+        return user_data
+
+    def _add_user_data_scripts_from_files(self, user_data: ec2.UserData) -> None:
+        """
+        Add user data scripts from external files with variable substitution.
+        Supports loading shell scripts and injecting them into user data with
+        placeholder replacement.
+        """
+        from pathlib import Path
+        
+        for script_config in self.asg_config.user_data_scripts:
+            script_type = script_config.get("type", "file")
+            
+            if script_type == "file":
+                # Load script from file
+                script_path = script_config.get("path")
+                if not script_path:
+                    logger.warning("Script path not specified, skipping")
+                    continue
+                
+                # Resolve path (relative to project root or absolute)
+                path = Path(script_path)
+                if not path.is_absolute():
+                    # Try relative to current working directory
+                    path = Path.cwd() / script_path
+                
+                if not path.exists():
+                    logger.warning(f"Script file not found: {path}, skipping")
+                    continue
+                
+                # Read script content
+                try:
+                    with open(path, 'r') as f:
+                        script_content = f.read()
+                except Exception as e:
+                    logger.error(f"Failed to read script file {path}: {e}")
+                    continue
+                    
+            elif script_type == "inline":
+                # Use inline script content
+                script_content = script_config.get("content", "")
+                if not script_content:
+                    logger.warning("Inline script content is empty, skipping")
+                    continue
+            else:
+                logger.warning(f"Unknown script type: {script_type}, skipping")
+                continue
+            
+            # Perform variable substitution
+            variables = script_config.get("variables", {})
+            for var_name, var_value in variables.items():
+                placeholder = f"{{{{{var_name}}}}}"  # {{VAR_NAME}}
+                script_content = script_content.replace(placeholder, str(var_value))
+            
+            # Add script to user data
+            # Split by lines and add each line as a command
+            for line in script_content.split('\n'):
+                if line.strip():  # Skip empty lines
+                    user_data.add_commands(line)
+            
+            logger.info(f"Added user data script from {script_type}: {script_config.get('path', 'inline')}")
+
+    def _substitute_variables(self, command: str) -> str:
+        """
+        Perform variable substitution on a user data command.
+        Uses workload and deployment configuration for substitution.
+        """
+        if not command:
+            return command
+            
+        # Start with the original command
+        substituted_command = command
+        
+        # Define available variables for substitution
+        variables = {}
+        
+        # Add workload variables
+        if self.workload:
+            variables.update({
+                "WORKLOAD_NAME": getattr(self.workload, 'name', ''),
+                "ENVIRONMENT": getattr(self.workload, 'environment', ''),
+                "WORKLOAD": getattr(self.workload, 'name', ''),
+            })
+        
+        # Add deployment variables
+        if self.deployment:
+            variables.update({
+                "DEPLOYMENT_NAME": getattr(self.deployment, 'name', ''),
+                "REGION": getattr(self.deployment, 'region', ''),
+                "ACCOUNT": getattr(self.deployment, 'account', ''),
+            })
+        
+        # Add stack-level variables
+        variables.update({
+            "STACK_NAME": self.stack_name,
+        })
+        
+        # Perform substitution
+        for var_name, var_value in variables.items():
+            if var_value is not None:
+                placeholder = f"{{{{{var_name}}}}}"  # {{VAR_NAME}}
+                substituted_command = substituted_command.replace(placeholder, str(var_value))
+        
+        return substituted_command
+
+    def _add_container_user_data(
+        self, user_data: ec2.UserData, container_config: Dict[str, Any]
+    ) -> None:
+        """Add container-specific user data commands"""
+        # Install Docker
+        user_data.add_commands(
+            "dnf -y update", "dnf -y install docker jq", "systemctl enable --now docker"
+        )
+
+        # ECR configuration
+        if "ecr" in container_config:
+            ecr_config = container_config["ecr"]
+            user_data.add_commands(
+                f"ACCOUNT_ID={ecr_config.get('account_id', self.account)}",
+                f"REGION={ecr_config.get('region', self.region)}",
+                f"REPO={ecr_config.get('repo', 'app')}",
+                f"TAG={ecr_config.get('tag', 'latest')}",
+                "aws ecr get-login-password --region $REGION | docker login --username AWS --password-stdin ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com",
+                "docker pull ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/${REPO}:${TAG}",
+            )
+
+        # Database configuration
+        if "database" in container_config:
+            db_config = container_config["database"]
+            secret_arn = db_config.get("secret_arn", "")
+            if secret_arn:
+                user_data.add_commands(
+                    f"DB_SECRET_ARN={secret_arn}",
+                    'if [ -n "$DB_SECRET_ARN" ]; then DB_JSON=$(aws secretsmanager get-secret-value --secret-id $DB_SECRET_ARN --query SecretString --output text --region $REGION); fi',
+                    'if [ -n "$DB_SECRET_ARN" ]; then DB_HOST=$(echo $DB_JSON | jq -r .host); DB_USER=$(echo $DB_JSON | jq -r .username); DB_PASS=$(echo $DB_JSON | jq -r .password); DB_NAME=$(echo $DB_JSON | jq -r .dbname); fi',
+                )
+
+        # Run container
+        if "run_command" in container_config:
+            user_data.add_commands(container_config["run_command"])
+        elif "ecr" in container_config:
+            port = container_config.get("port", 8080)
+            user_data.add_commands(
+                f"docker run -d --name app -p {port}:{port} "
+                '-e DB_HOST="$DB_HOST" -e DB_USER="$DB_USER" -e DB_PASS="$DB_PASS" -e DB_NAME="$DB_NAME" '
+                "--restart=always ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/${REPO}:${TAG}"
+            )
+
+    def _create_launch_template(self, asg_name: str) -> ec2.LaunchTemplate:
+        """Create launch template for the Auto Scaling Group"""
+        # Get AMI
+        ami = None
+        if self.asg_config.ami_id:
+            ami = ec2.MachineImage.generic_linux({self.region: self.asg_config.ami_id})
+        else:
+            if self.asg_config.ami_type == "amazon-linux-2023":
+                ami = ec2.MachineImage.latest_amazon_linux2023()
+            elif self.asg_config.ami_type == "amazon-linux-2":
+                ami = ec2.MachineImage.latest_amazon_linux2()
+            else:
+                ami = ec2.MachineImage.latest_amazon_linux2023()
+
+        # Parse instance type
+        instance_type_str = self.asg_config.instance_type
+        instance_type = None
+
+        if "." in instance_type_str:
+            parts = instance_type_str.split(".")
+            if len(parts) == 2:
+                try:
+                    instance_class = ec2.InstanceClass[parts[0].upper()]
+                    instance_size = ec2.InstanceSize[parts[1].upper()]
+                    instance_type = ec2.InstanceType.of(instance_class, instance_size)
+                except (KeyError, ValueError):
+                    instance_type = ec2.InstanceType(instance_type_str)
+            else:
+                instance_type = ec2.InstanceType(instance_type_str)
+        else:
+            instance_type = ec2.InstanceType(instance_type_str)
+
+        # Create block device mappings
+        block_devices = []
+        for device in self.asg_config.block_devices:
+            block_devices.append(
+                ec2.BlockDevice(
+                    device_name=device.get("device_name", "/dev/xvda"),
+                    volume=ec2.BlockDeviceVolume.ebs(
+                        volume_size=device.get("volume_size", 8),
+                        volume_type=ec2.EbsDeviceVolumeType(
+                            str(device.get("volume_type", "gp3")).upper()
+                        ),
+                        delete_on_termination=device.get("delete_on_termination", True),
+                        encrypted=device.get("encrypted", True),
+                    ),
+                )
+            )
+
+        # Create launch template
+        launch_template = ec2.LaunchTemplate(
+            self,
+            f"{asg_name}-LaunchTemplate",
+            machine_image=ami,
+            instance_type=instance_type,
+            role=self.instance_role,
+            security_group=self.security_groups[0] if self.security_groups else None,
+            user_data=self.user_data,
+            detailed_monitoring=self.asg_config.detailed_monitoring,
+            block_devices=block_devices if block_devices else None,
+        )
+
+        return launch_template
+
+    def _create_auto_scaling_group(self, asg_name: str) -> autoscaling.AutoScalingGroup:
+        """Create the Auto Scaling Group"""
+        # Configure subnet selection
+        subnet_group_name = self.asg_config.subnet_group_name
+        subnets = ec2.SubnetSelection(subnet_group_name=subnet_group_name)
+
+        # Configure health check
+        health_check_type = autoscaling.HealthCheck.ec2()
+        if self.asg_config.health_check_type.upper() == "ELB":
+            health_check_type = autoscaling.HealthCheck.elb(
+                grace=Duration.seconds(self.asg_config.health_check_grace_period)
+            )
+
+        # Create Auto Scaling Group
+        asg = autoscaling.AutoScalingGroup(
+            self,
+            asg_name,
+            vpc=self.vpc,
+            vpc_subnets=subnets,
+            min_capacity=self.asg_config.min_capacity,
+            max_capacity=self.asg_config.max_capacity,
+            desired_capacity=self.asg_config.desired_capacity,
+            launch_template=self.launch_template,
+            health_check=health_check_type,
+            cooldown=Duration.seconds(self.asg_config.cooldown),
+            termination_policies=[
+                autoscaling.TerminationPolicy(policy)
+                for policy in self.asg_config.termination_policies
+            ],
+        )
+
+        # Attach to target groups after ASG creation
+        self._attach_target_groups(asg)
+
+        # Configure update policy
+        # Only apply update policy if it was explicitly configured
+        if "update_policy" in self.stack_config.dictionary.get("auto_scaling", {}):
+            update_policy = self.asg_config.update_policy
+            # Apply the update policy to the ASG's CloudFormation resource
+            cfn_asg = asg.node.default_child
+            cfn_asg.add_override(
+                "UpdatePolicy",
+                {
+                    "AutoScalingRollingUpdate": {
+                        "MinInstancesInService": update_policy.get(
+                            "min_instances_in_service", 1
+                        ),
+                        "MaxBatchSize": update_policy.get("max_batch_size", 1),
+                        "PauseTime": f"PT{update_policy.get('pause_time', 300) // 60}M",
+                    }
+                },
+            )
+
+        # Add tags
+        for key, value in self.asg_config.tags.items():
+            cdk.Tags.of(asg).add(key, value)
+
+        return asg
+
+    def _configure_scaling_policies(self) -> None:
+        """Configure scaling policies for the Auto Scaling Group"""
+        for policy in self.asg_config.scaling_policies:
+            policy_type = policy.get("type", "target_tracking")
+
+            if policy_type == "target_tracking":
+                self.auto_scaling_group.scale_on_metric(
+                    f"{self.asg_config.name}-{policy.get('name', 'scaling-policy')}",
+                    metric=self._get_metric(policy),
+                    scaling_steps=self._get_scaling_steps(policy),
+                    adjustment_type=autoscaling.AdjustmentType.CHANGE_IN_CAPACITY,
+                )
+            elif policy_type == "step":
+                self.auto_scaling_group.scale_on_metric(
+                    f"{self.asg_config.name}-{policy.get('name', 'scaling-policy')}",
+                    metric=self._get_metric(policy),
+                    scaling_steps=self._get_scaling_steps(policy),
+                    adjustment_type=autoscaling.AdjustmentType.CHANGE_IN_CAPACITY,
+                )
+
+    def _get_metric(self, policy: Dict[str, Any]) -> cloudwatch.Metric:
+        """Get metric for scaling policy"""
+        # This is a simplified implementation
+        # In a real-world scenario, you would use CloudWatch metrics
+        return cloudwatch.Metric(
+            namespace="AWS/EC2",
+            metric_name=policy.get("metric_name", "CPUUtilization"),
+            dimensions_map={
+                "AutoScalingGroupName": self.auto_scaling_group.auto_scaling_group_name
+            },
+            statistic=policy.get("statistic", "Average"),
+            period=Duration.seconds(policy.get("period", 60)),
+        )
+
+    def _get_scaling_steps(
+        self, policy: Dict[str, Any]
+    ) -> List[autoscaling.ScalingInterval]:
+        """Get scaling steps for scaling policy"""
+        steps = policy.get("steps", [])
+        scaling_intervals = []
+
+        for step in steps:
+            # Handle upper bound - if not specified, don't set it (let CDK handle it)
+            interval_kwargs = {
+                "lower": step.get("lower", 0),
+                "change": step.get("change", 1),
+            }
+
+            # Only set upper if it's explicitly provided
+            if "upper" in step:
+                interval_kwargs["upper"] = step["upper"]
+
+            scaling_intervals.append(autoscaling.ScalingInterval(**interval_kwargs))
+
+        return scaling_intervals
+
+    def _add_outputs(self, asg_name: str) -> None:
+        """Add CloudFormation outputs for the Auto Scaling Group"""
+        if self.auto_scaling_group:
+            # Auto Scaling Group Name
+            cdk.CfnOutput(
+                self,
+                f"{asg_name}-name",
+                value=self.auto_scaling_group.auto_scaling_group_name,
+                export_name=f"{self.deployment.build_resource_name(asg_name)}-name",
+            )
+
+            # Auto Scaling Group ARN
+            cdk.CfnOutput(
+                self,
+                f"{asg_name}-arn",
+                value=self.auto_scaling_group.auto_scaling_group_arn,
+                export_name=f"{self.deployment.build_resource_name(asg_name)}-arn",
+            )
+
+            # Launch Template ID
+            if self.launch_template:
+                cdk.CfnOutput(
+                    self,
+                    f"{asg_name}-launch-template-id",
+                    value=self.launch_template.launch_template_id,
+                    export_name=f"{self.deployment.build_resource_name(asg_name)}-launch-template-id",
+                )
+
+    
+    def _add_scaling_policies(self) -> None:
+        """Add scaling policies to the Auto Scaling Group"""
+        for policy_config in self.asg_config.scaling_policies:
+            # Scaling policy implementation would go here
+            pass
+
+    def _add_scheduled_actions(self) -> None:
+        """Add scheduled actions to the Auto Scaling Group"""
+        for action_config in self.asg_config.scheduled_actions:
+            # Scheduled action implementation would go here
+            pass
+
+    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
+        
+        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) -> 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
+        
+        for command in self.user_data_commands:
+            # If this command already sets ECS_CLUSTER, replace it
+            if 'ECS_CLUSTER=' in command:
+                # Replace existing ECS_CLUSTER setting with our cluster name
+                parts = command.split('ECS_CLUSTER=')
+                if len(parts) > 1:
+                    # Keep everything before ECS_CLUSTER=, add our cluster name, then add the rest
+                    before = parts[0]
+                    after_parts = parts[1].split(None, 1)  # Split on first whitespace
+                    after = after_parts[1] if len(after_parts) > 1 else ''
+                    new_command = f"{before}ECS_CLUSTER={cluster_name} {after}".strip()
+                    injected_commands.append(new_command)
+                    cluster_name_injected = True
+                else:
+                    injected_commands.append(f"{command}ECS_CLUSTER={cluster_name}")
+                    cluster_name_injected = True
+            else:
+                injected_commands.append(command)
+        
+        # If no ECS_CLUSTER was found in existing commands, add it
+        if not cluster_name_injected:
+            injected_commands.append(f"echo ECS_CLUSTER={cluster_name} >> /etc/ecs/ecs.config")
+        
+        # Update the user data with the injected commands
+        self.user_data_commands = injected_commands
+        
+        # If user data object exists, we need to recreate it with the updated commands
+        if hasattr(self, 'user_data') and self.user_data:
+            self.user_data = self._recreate_user_data_with_commands(injected_commands)
+
+    def _recreate_user_data_with_commands(self, commands: List[str]) -> ec2.UserData:
+        """Recreate user data with updated commands"""
+        user_data = ec2.UserData.for_linux()
+        
+        for command in commands:
+            user_data.add_commands(command)
+        
+        return user_data
+
+    def _export_resources(self, asg_name: str) -> None:
+        """Export stack resources to SSM and CloudFormation outputs"""
+        # Export ASG name
+        cdk.CfnOutput(
+            self,
+            f"{asg_name}-name",
+            value=self.auto_scaling_group.auto_scaling_group_name,
+            export_name=f"{self.deployment.build_resource_name(asg_name)}-name",
+        )
+
+        # Export ASG ARN
+        cdk.CfnOutput(
+            self,
+            f"{asg_name}-arn",
+            value=self.auto_scaling_group.auto_scaling_group_arn,
+            export_name=f"{self.deployment.build_resource_name(asg_name)}-arn",
+        )

cdk_factory/stack_library/auto_scaling/auto_scaling_stack_standardized.py

@@ -497,14 +497,18 @@ class AutoScalingStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
         # Get the underlying CloudFormation resource to add update policy
         cfn_asg = self.auto_scaling_group.node.default_child
         
-        # Clear any existing update policy and set the rolling update policy
-        cfn_asg.add_property_override("UpdatePolicy", {
-            "AutoScalingRollingUpdate": {
-                "MinInstancesInService": update_policy.get("min_instances_in_service", 1),
-                "MaxBatchSize": update_policy.get("max_batch_size", 1),
-                "PauseTime": f"PT{update_policy.get('pause_time', 300)}S"
-            }
-        })
+        # Get existing update policy or create new one
+        existing_policy = getattr(cfn_asg, 'update_policy', {})
+        
+        # Merge rolling update policy with existing policy
+        existing_policy["AutoScalingRollingUpdate"] = {
+            "MinInstancesInService": update_policy.get("min_instances_in_service", 1),
+            "MaxBatchSize": update_policy.get("max_batch_size", 1),
+            "PauseTime": f"PT{update_policy.get('pause_time', 300)}S"
+        }
+        
+        # Set the merged policy
+        cfn_asg.update_policy = existing_policy
         
         logger.info("Added rolling update policy to Auto Scaling Group")
 

cdk_factory/stack_library/ecs/ecs_cluster_stack_standardized.py

@@ -118,7 +118,9 @@ class EcsClusterStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
         self._export_cluster_info()
         
         # Export SSM parameters
+        logger.info("Starting SSM parameter export for ECS cluster")
         self._export_ssm_parameters()
+        logger.info("Completed SSM parameter export for ECS cluster")
         
         logger.info(f"ECS Cluster stack created: {cluster_name}")
 
@@ -174,6 +176,8 @@ class EcsClusterStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
 
     def _create_iam_roles(self):
         """Create IAM roles for the ECS cluster if configured."""
+        logger.info(f"create_instance_role setting: {self.ecs_config.create_instance_role}")
+        
         if not self.ecs_config.create_instance_role:
             logger.info("Skipping instance role creation (disabled in config)")
             return
@@ -193,14 +197,18 @@ class EcsClusterStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
             role_name=f"{self.ecs_config.name}-ecs-instance-role",
         )
 
+        logger.info(f"Created ECS instance role: {self.instance_role.role_name}")
+
         # Create instance profile
         self.instance_profile = iam.CfnInstanceProfile(
             self,
             "ECSInstanceProfile",
-            roles=[self.instance_role.role_name],
             instance_profile_name=f"{self.ecs_config.name}-ecs-instance-profile",
+            roles=[self.instance_role.role_name],
         )
 
+        logger.info(f"Created ECS instance profile: {self.instance_profile.instance_profile_name}")
+
         logger.info("ECS instance role and profile created")
 
     def _export_cluster_info(self):
@@ -254,31 +262,51 @@ class EcsClusterStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
 
     def _export_ssm_parameters(self) -> None:
         """Export SSM parameters using standardized approach"""
+        logger.info("=== Starting SSM Parameter Export ===")
+        
         if not self.ecs_cluster:
             logger.warning("No ECS cluster to export")
             return
 
+        logger.info(f"ECS cluster found: {self.ecs_cluster.cluster_name}")
+        logger.info(f"SSM exports configured: {self.ssm_config.get('exports', {})}")
+
         # Prepare resource values for export
         resource_values = {
             "cluster_name": self.ecs_cluster.cluster_name,
             "cluster_arn": self.ecs_cluster.cluster_arn,
-            "instance_role_arn": self.instance_role.role_arn,
         }
         
+        # Add instance role ARN if created
+        if self.instance_role:
+            resource_values["instance_role_arn"] = self.instance_role.role_arn
+            logger.info(f"Instance role ARN added: {self.instance_role.role_name}")
+        else:
+            logger.info("No instance role to export")
+        
         # Add security group ID if available
         if hasattr(self.ecs_cluster, 'connections') and self.ecs_cluster.connections:
             security_groups = self.ecs_cluster.connections.security_groups
             if security_groups:
                 resource_values["security_group_id"] = security_groups[0].security_group_id
+                logger.info(f"Security group ID added: {security_groups[0].security_group_id}")
         
         # Add instance profile ARN if created
         if self.instance_profile:
             resource_values["instance_profile_arn"] = self.instance_profile.attr_arn
+            logger.info(f"Instance profile ARN added: {self.instance_profile.instance_profile_name}")
 
         # Export using standardized SSM mixin
-        exported_params = self.export_standardized_ssm_parameters(resource_values)
-        
-        logger.info(f"Exported SSM parameters: {exported_params}")
+        logger.info(f"Resource values available for export: {list(resource_values.keys())}")
+        for key, value in resource_values.items():
+            logger.info(f"  {key}: {value}")
+            
+        try:
+            exported_params = self.export_standardized_ssm_parameters(resource_values)
+            logger.info(f"Successfully exported SSM parameters: {exported_params}")
+        except Exception as e:
+            logger.error(f"Failed to export SSM parameters: {str(e)}")
+            raise
 
     # Backward compatibility methods
     def process_ssm_imports(self, config: Any, deployment: DeploymentConfig, resource_type: str = "resource") -> None:

cdk_factory/version.py

@@ -1 +1 @@
-__version__ = "0.18.0"
+__version__ = "0.18.4"

{cdk_factory-0.18.0.dist-info → cdk_factory-0.18.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdk_factory
-Version: 0.18.0
+Version: 0.18.4
 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.18.0.dist-info → cdk_factory-0.18.4.dist-info}/RECORD

@@ -2,7 +2,7 @@ cdk_factory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cdk_factory/app.py,sha256=RnX0-pwdTAPAdKJK_j13Zl8anf9zYKBwboR0KA8K8xM,10346
 cdk_factory/cdk.json,sha256=SKZKhJ2PBpFH78j-F8S3VDYW-lf76--Q2I3ON-ZIQfw,3106
 cdk_factory/cli.py,sha256=FGbCTS5dYCNsfp-etshzvFlGDCjC28r6rtzYbe7KoHI,6407
-cdk_factory/version.py,sha256=0EHw4xygmgkGSyfwNfEoMlQyN0uHxjHtlSFF79s6120,23
+cdk_factory/version.py,sha256=eFcwd1MYukWcWS9_p4d0HWJGW8jgPe27mOGuSygcjsY,23
 cdk_factory/builds/README.md,sha256=9BBWd7bXpyKdMU_g2UljhQwrC9i5O_Tvkb6oPvndoZk,90
 cdk_factory/commands/command_loader.py,sha256=QbLquuP_AdxtlxlDy-2IWCQ6D-7qa58aphnDPtp_uTs,3744
 cdk_factory/configurations/base_config.py,sha256=eJ3Pl3GWk1jVr_bYQaaWlw4_-ZiFGaiXllI_fOOX1i0,9323
@@ -31,7 +31,7 @@ cdk_factory/configurations/resources/cognito.py,sha256=udX2AJ1ITLhy4f1XiJQwrva6F
 cdk_factory/configurations/resources/docker.py,sha256=hUbuxkuhcQu9LnLX7I8_57eTmHefEAGVnOHO37MkqC4,2166
 cdk_factory/configurations/resources/dynamodb.py,sha256=HsZMOaRwfuNPwKIzokeeE3f5zAQLTB5hRb_GzYq2ibg,2903
 cdk_factory/configurations/resources/ecr.py,sha256=iJEtKqBT7vQU0LU4urIglraIR7cPZqp3HQBs_2An7kA,8303
-cdk_factory/configurations/resources/ecs_cluster.py,sha256=vVbaRs9AdMlYapwGh40jYm949gpmsc_MDeuMqiOjH9g,3445
+cdk_factory/configurations/resources/ecs_cluster.py,sha256=mQYJu7SUPDl5E4dMR6HCPFoWvFA3RGIb0iMNn-K7LX8,3635
 cdk_factory/configurations/resources/ecs_service.py,sha256=iwUVewUy9fQSLpkfRTNuIaWy7eQYWTHFiiD1jIYt9zU,5452
 cdk_factory/configurations/resources/exisiting.py,sha256=EVOLnkB-DGfTlmDgyQ5DD5k2zYfpFxqI3gugDR7mifI,478
 cdk_factory/configurations/resources/lambda_edge.py,sha256=MjmiwDkys4aoRvDQhH3MT6BgeShzJXNWL7761HJrLtQ,3404
@@ -86,7 +86,8 @@ cdk_factory/stack_library/acm/__init__.py,sha256=4FNRLykblcKZvq_wieYwvv9N_jgrZnJ
 cdk_factory/stack_library/acm/acm_stack.py,sha256=QJ3GkT17PmWoGkfO5Um02hvrfyJ9HbiPMnclwDP7IbA,5846
 cdk_factory/stack_library/api_gateway/api_gateway_stack.py,sha256=_wbPBsgh7FHq9cnL44CiuffBj3XCO5ErQx_yclxFsVY,39669
 cdk_factory/stack_library/auto_scaling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cdk_factory/stack_library/auto_scaling/auto_scaling_stack_standardized.py,sha256=Den7t4AAEn1slQPRHVq_DdzJSp1NRJgvObJEB8diQ8g,21959
+cdk_factory/stack_library/auto_scaling/auto_scaling_old.py,sha256=WvEwIao4KPOLa8e3zaQjxlTydCIK0GfgjZn4-CNyuF0,30135
+cdk_factory/stack_library/auto_scaling/auto_scaling_stack_standardized.py,sha256=y208T0Qxbkhc7RRgWtQWmuN01Rt-ABxvcW20LoOYevI,22089
 cdk_factory/stack_library/aws_lambdas/lambda_stack.py,sha256=SFbBPvvCopbyiuYtq-O5sQkFCf94Wzua6aDUXiFDSB4,26161
 cdk_factory/stack_library/buckets/README.md,sha256=XkK3UNVtRLE7NtUvbhCOBBYUYi8hlrrSaI1s3GJVrqI,78
 cdk_factory/stack_library/buckets/bucket_stack.py,sha256=SLoZqSffAqmeBBEVUQg54D_8Ad5UKdkjEAmKAVgAqQo,1778
@@ -98,7 +99,7 @@ cdk_factory/stack_library/dynamodb/dynamodb_stack.py,sha256=3_8lQP91GnBY77-61mtn
 cdk_factory/stack_library/ecr/README.md,sha256=xw2wPx9WN03Y4BBwqvbi9lAFGNyaD1FUNpqxVJX14Oo,179
 cdk_factory/stack_library/ecr/ecr_stack.py,sha256=KLbd5WN5-ZiojsS5wJ4PX-tIL0cCylCSvXjO6sVrgWY,2102
 cdk_factory/stack_library/ecs/__init__.py,sha256=ebM8vVboNBplK0ua6bMSpNjewcFFkdvJ5wvVYEL1ONQ,302
-cdk_factory/stack_library/ecs/ecs_cluster_stack_standardized.py,sha256=QT_pNQYS28nQ3vQ-kvICOCRvkGeLRrOXuUMDKqJ-C64,11379
+cdk_factory/stack_library/ecs/ecs_cluster_stack_standardized.py,sha256=-NK1U9vCFad8CcW6dOTguQgr0IBL_bhtg5cxyU2MR6U,12832
 cdk_factory/stack_library/ecs/ecs_service_stack.py,sha256=3en447kWBOqd0d_i2C8mRRBscO2GqN9-B2l_PW7kZuM,27409
 cdk_factory/stack_library/lambda_edge/__init__.py,sha256=ByBJ_CWdc4UtTmFBZH-6pzBMNkjkdtE65AmnB0Fs6lM,156
 cdk_factory/stack_library/lambda_edge/lambda_edge_stack.py,sha256=ft5AxHy8__F90ZYDaoJwTjACGIfrn2Sd9Zr2CdHO7GE,16398
@@ -136,8 +137,8 @@ cdk_factory/utilities/os_execute.py,sha256=5Op0LY_8Y-pUm04y1k8MTpNrmQvcLmQHPQITE
 cdk_factory/utils/api_gateway_utilities.py,sha256=If7Xu5s_UxmuV-kL3JkXxPLBdSVUKoLtohm0IUFoiV8,4378
 cdk_factory/validation/config_validator.py,sha256=Pb0TkLiPFzUplBOgMorhRCVm08vEzZhRU5xXCDTa5CA,17602
 cdk_factory/workload/workload_factory.py,sha256=yDI3cRhVI5ELNDcJPLpk9UY54Uind1xQoV3spzT4z7E,6068
-cdk_factory-0.18.0.dist-info/METADATA,sha256=Ck5iFO4mcy-raXGcEbs-RTfDx-RWqbLBtrNDRcogK_E,2451
-cdk_factory-0.18.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cdk_factory-0.18.0.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
-cdk_factory-0.18.0.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
-cdk_factory-0.18.0.dist-info/RECORD,,
+cdk_factory-0.18.4.dist-info/METADATA,sha256=ugv0E7xmz7lqhLPyUTOHkFFpLn3F65OwhAcvnzPuIu8,2451
+cdk_factory-0.18.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cdk_factory-0.18.4.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
+cdk_factory-0.18.4.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
+cdk_factory-0.18.4.dist-info/RECORD,,