cdk-factory 0.18.5__py3-none-any.whl → 0.18.6__py3-none-any.whl

cdk_factory/interfaces/standardized_ssm_mixin.py

@@ -531,6 +531,44 @@ class StandardizedSsmMixin:
         return self._ssm_exported_values.copy()
     
     
+    def get_subnet_ids(self, config) -> List[str]:
+        """
+        Helper function to parse subnet IDs from SSM imports.
+        
+        This common pattern handles:
+        1. Comma-separated subnet ID strings from SSM
+        2. List of subnet IDs from SSM
+        3. Fallback to config attributes
+        
+        Args:
+            config: Configuration object that might have subnet_ids attribute
+            
+        Returns:
+            List of subnet IDs (empty list if not found or invalid format)
+        """
+        # Use the standardized SSM imports
+        ssm_imports = self.get_all_ssm_imports()
+        if "subnet_ids" in ssm_imports:
+            subnet_ids = ssm_imports["subnet_ids"]
+            
+            # Handle comma-separated string or list
+            if isinstance(subnet_ids, str):
+                # Split comma-separated string
+                parsed_ids = [sid.strip() for sid in subnet_ids.split(',') if sid.strip()]
+                return parsed_ids
+            elif isinstance(subnet_ids, list):
+                return subnet_ids
+            else:
+                logger.warning(f"Unexpected subnet_ids type: {type(subnet_ids)}")
+                return []
+        
+        # Fallback: Check config attributes
+        elif hasattr(config, 'subnet_ids') and config.subnet_ids:
+            return config.subnet_ids
+        
+        else:
+            logger.warning("No subnet IDs found, using default behavior")
+            return []
 
 class ValidationResult:
     """Result of configuration validation."""
@@ -614,38 +652,4 @@ class SsmStandardValidator:
         return errors
     
         
-    def parse_subnet_ids_from_ssm(self, subnet_ids_key: str = "subnet_ids") -> List[str]:
-        """
-        Helper function to parse subnet IDs from SSM imports.
-        
-        This common pattern handles:
-        1. Comma-separated subnet ID strings from SSM
-        2. List of subnet IDs from SSM
-        3. CDK Token resolution for deployment-time values
-        
-        Args:
-            subnet_ids_key: The key used for subnet IDs in SSM imports (default: "subnet_ids")
-            
-        Returns:
-            List of subnet IDs (empty list if not found or invalid format)
-        """
-        ssm_imports = self.get_all_ssm_imports()
-        
-        if subnet_ids_key not in ssm_imports:
-            logger.warning(f"No subnet IDs found in SSM imports with key: {subnet_ids_key}")
-            return []
-        
-        subnet_ids = ssm_imports[subnet_ids_key]
-        
-        # Handle comma-separated string or list
-        if isinstance(subnet_ids, str):
-            # Split comma-separated string
-            parsed_ids = [sid.strip() for sid in subnet_ids.split(',') if sid.strip()]
-            logger.info(f"Parsed {len(parsed_ids)} subnet IDs from comma-separated string")
-            return parsed_ids
-        elif isinstance(subnet_ids, list):
-            logger.info(f"Using {len(subnet_ids)} subnet IDs from list")
-            return subnet_ids
-        else:
-            logger.warning(f"Unexpected subnet_ids type: {type(subnet_ids)}")
-            return []
+    

cdk_factory/stack_library/auto_scaling/auto_scaling_stack_standardized.py

@@ -211,33 +211,12 @@ class AutoScalingStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
         Get subnet IDs using standardized SSM approach.
         """
         # Primary method: Use standardized SSM imports
-        ssm_imports = self._get_ssm_imports()
-        
-        if "subnet_ids" in ssm_imports:
-            subnet_ids = ssm_imports["subnet_ids"]
-            
-            # Handle comma-separated string or list
-            if isinstance(subnet_ids, str):
-                # Split comma-separated string
-                parsed_ids = [sid.strip() for sid in subnet_ids.split(',') if sid.strip()]
-                return parsed_ids
-            elif isinstance(subnet_ids, list):
-                return subnet_ids
-            else:
-                logger.warning(f"Unexpected subnet_ids type: {type(subnet_ids)}")
-                return []
-        
-        # Fallback: Use VPC provider mixin (backward compatibility)
-        elif hasattr(self, '_get_subnets_from_provider'):
-            return self._get_subnets_from_provider()
-        
-        # Final fallback: Direct configuration
-        elif hasattr(self.asg_config, 'subnet_ids') and self.asg_config.subnet_ids:
-            return self.asg_config.subnet_ids
+        # ssm_imports = self._get_ssm_imports()
+
+        subnet_ids = self.get_subnet_ids(self.asg_config)
         
-        else:
-            logger.warning("No subnet IDs found, using default behavior")
-            return []
+        return subnet_ids
+       
 
     def _create_instance_role(self, asg_name: str) -> iam.Role:
         """Create IAM role for EC2 instances"""

cdk_factory/stack_library/load_balancer/load_balancer_stack.py

@@ -156,16 +156,22 @@ class LoadBalancerStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
 
         # If subnets is None, check if we have SSM-imported subnet_ids as a token
         # We need to use Fn.Split to convert the comma-separated string to an array
-        if subnets is None and "subnet_ids" in self.ssm_imported_values:
-            subnet_ids_value = self.ssm_imported_values["subnet_ids"]
-            if cdk.Token.is_unresolved(subnet_ids_value):
-                logger.info("Using Fn.Split to convert comma-separated subnet IDs token to array")
-                # Use CloudFormation escape hatch to set Subnets property with Fn.Split
-                cfn_lb = load_balancer.node.default_child
-                cfn_lb.add_property_override(
-                    "Subnets",
-                    cdk.Fn.split(",", subnet_ids_value)
-                )
+        if subnets is None:
+            subnet_ids = self.get_subnet_ids(self.lb_config)
+            if subnet_ids:
+                # For CloudFormation token resolution, we still need Fn.split
+                # but we use the helper to determine if subnet IDs are available
+                ssm_imports = self.get_all_ssm_imports()
+                if "subnet_ids" in ssm_imports:
+                    subnet_ids_value = ssm_imports["subnet_ids"]
+                    if cdk.Token.is_unresolved(subnet_ids_value):
+                        logger.info("Using Fn.Split to convert comma-separated subnet IDs token to array")
+                        # Use CloudFormation escape hatch to set Subnets property with Fn.Split
+                        cfn_lb = load_balancer.node.default_child
+                        cfn_lb.add_property_override(
+                            "Subnets",
+                            cdk.Fn.split(",", subnet_ids_value)
+                        )
 
         # Add tags
         for key, value in self.lb_config.tags.items():
@@ -261,9 +267,16 @@ class LoadBalancerStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
         """Get subnets for the Load Balancer"""
         subnets = []
         
-        # Check SSM imported values first
-        if "subnet_ids" in self.ssm_imported_values:
-            subnet_ids_value = self.ssm_imported_values["subnet_ids"]
+        # Use the standardized helper function to get subnet IDs
+        subnet_ids = self.get_subnet_ids(self.lb_config)
+        
+        if not subnet_ids:
+            return None
+        
+        # Check if we have unresolved tokens from SSM
+        ssm_imports = self.get_all_ssm_imports()
+        if "subnet_ids" in ssm_imports:
+            subnet_ids_value = ssm_imports["subnet_ids"]
             
             # Check if this is a CDK token (unresolved SSM parameter)
             if cdk.Token.is_unresolved(subnet_ids_value):
@@ -272,19 +285,8 @@ class LoadBalancerStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
                 # The ALB construct will handle the token-based subnet IDs
                 logger.info("Subnet IDs are unresolved tokens, will use vpc_subnets with token resolution")
                 return None
-            elif isinstance(subnet_ids_value, str):
-                # If it's a resolved string, split it
-                subnet_ids = [s.strip() for s in subnet_ids_value.split(',')]
-            elif isinstance(subnet_ids_value, list):
-                subnet_ids = subnet_ids_value
-            else:
-                subnet_ids = [subnet_ids_value]
-        else:
-            subnet_ids = self.lb_config.subnets
-        
-        if not subnet_ids:
-            return None
             
+        # Convert subnet IDs to subnet objects
         for idx, subnet_id in enumerate(subnet_ids):
             subnets.append(
                 ec2.Subnet.from_subnet_id(self, f"Subnet-{idx}", subnet_id)

cdk_factory/stack_library/rds/rds_stack.py

@@ -69,8 +69,18 @@ class RdsStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
         self.rds_config = RdsConfig(stack_config.dictionary.get("rds", {}), deployment)
         db_name = deployment.build_resource_name(self.rds_config.name)
 
-        # Process SSM imports first
-        self._process_ssm_imports()
+        # Setup standardized SSM integration
+        self.setup_standardized_ssm_integration(
+            scope=self,
+            config=self.rds_config,
+            resource_type="rds",
+            resource_name=self.rds_config.name,
+            deployment=deployment,
+            workload=workload
+        )
+        
+        # Process SSM imports
+        self.process_standardized_ssm_imports()
 
         # Get VPC and security groups
         self.security_groups = self._get_security_groups()
@@ -87,40 +97,13 @@ class RdsStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
         # Export to SSM Parameter Store
         self._export_ssm_parameters(db_name)
 
-    def _process_ssm_imports(self) -> None:
-        """Process SSM imports from configuration"""
-        ssm_imports = self.rds_config.ssm_imports
-        
-        if not ssm_imports:
-            logger.debug("No SSM imports configured for RDS")
-            return
-        
-        logger.info(f"Processing {len(ssm_imports)} SSM imports for RDS")
-        
-        for param_key, param_path in ssm_imports.items():
-            try:
-                if not param_path.startswith('/'):
-                    param_path = f"/{param_path}"
-                
-                construct_id = f"ssm-import-{param_key}-{hash(param_path) % 10000}"
-                param = ssm.StringParameter.from_string_parameter_name(
-                    self, construct_id, param_path
-                )
-                
-                self.ssm_imported_values[param_key] = param.string_value
-                logger.info(f"Imported SSM parameter: {param_key} from {param_path}")
-                
-            except Exception as e:
-                logger.error(f"Failed to import SSM parameter {param_key} from {param_path}: {e}")
-                raise
-
     @property
     def vpc(self) -> ec2.IVpc:
         """Get the VPC for the RDS instance using centralized VPC provider mixin."""
-        if self._vpc:
+        if hasattr(self, '_vpc') and self._vpc:
             return self._vpc
         
-        # Use the centralized VPC resolution from VPCProviderMixin
+        # Resolve VPC using the centralized VPC provider mixin
         self._vpc = self.resolve_vpc(
             config=self.rds_config,
             deployment=self.deployment,
@@ -133,8 +116,9 @@ class RdsStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
         security_groups = []
         
         # Check SSM imports first for security group ID
-        if "security_group_rds_id" in self.ssm_imported_values:
-            sg_id = self.ssm_imported_values["security_group_rds_id"]
+        ssm_imports = self.get_all_ssm_imports()
+        if "security_group_rds_id" in ssm_imports:
+            sg_id = ssm_imports["security_group_rds_id"]
             security_groups.append(
                 ec2.SecurityGroup.from_security_group_id(
                     self, "RDSSecurityGroup", sg_id
@@ -151,27 +135,60 @@ class RdsStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
         
         return security_groups
 
+    def _get_subnet_selection(self) -> ec2.SubnetSelection:
+        """
+        Get subnet selection based on available subnet types in the VPC.
+        
+        RDS instances require private subnets for security, but we'll fall back
+        to available subnets if the preferred types aren't available.
+        """
+        vpc = self.vpc
+        
+        # Check for isolated subnets first (most secure for RDS)
+        if vpc.isolated_subnets:
+            logger.info("Using isolated subnets for RDS instance")
+            return ec2.SubnetSelection(subnet_type=ec2.SubnetType.PRIVATE_ISOLATED)
+        
+        # Check for private subnets next
+        elif vpc.private_subnets:
+            logger.info("Using private subnets for RDS instance")
+            return ec2.SubnetSelection(subnet_type=ec2.SubnetType.PRIVATE_WITH_EGRESS)
+        
+        # Fall back to public subnets (not recommended for production)
+        elif vpc.public_subnets:
+            logger.warning("Using public subnets for RDS instance - not recommended for production")
+            return ec2.SubnetSelection(subnet_type=ec2.SubnetType.PUBLIC)
+        
+        else:
+            raise ValueError("No subnets available in VPC for RDS instance")
+
     def _create_db_instance(self, db_name: str) -> rds.DatabaseInstance:
         """Create a new RDS instance"""
         # Configure subnet group
         # If we have subnet IDs from SSM, create a DB subnet group explicitly
         db_subnet_group = None
-        if "subnet_ids" in self.ssm_imported_values:
-            subnet_ids_str = self.ssm_imported_values["subnet_ids"]
-            # Split the comma-separated token into a list
-            subnet_ids_list = cdk.Fn.split(",", subnet_ids_str)
-            
-            # Create DB subnet group with the token-based subnet list
-            db_subnet_group = rds.CfnDBSubnetGroup(
-                self,
-                "DBSubnetGroup",
-                db_subnet_group_description=f"Subnet group for {db_name}",
-                subnet_ids=subnet_ids_list,
-                db_subnet_group_name=f"{db_name}-subnet-group"
-            )
+        subnet_ids = self.get_subnet_ids(self.rds_config)
+        
+        if subnet_ids:
+            # For CloudFormation token resolution, we need to get the raw SSM value
+            # Use the standardized SSM imports
+            ssm_imports = self.get_all_ssm_imports()
+            if "subnet_ids" in ssm_imports:
+                subnet_ids_str = ssm_imports["subnet_ids"]
+                # Split the comma-separated token into a list for CloudFormation
+                subnet_ids_list = cdk.Fn.split(",", subnet_ids_str)
+                
+                # Create DB subnet group with the token-based subnet list
+                db_subnet_group = rds.CfnDBSubnetGroup(
+                    self,
+                    "DBSubnetGroup",
+                    db_subnet_group_description=f"Subnet group for {db_name}",
+                    subnet_ids=subnet_ids_list,
+                    db_subnet_group_name=f"{db_name}-subnet-group"
+                )
         
         # Configure subnet selection for VPC (when not using SSM imports)
-        subnets = None if db_subnet_group else ec2.SubnetSelection(subnet_type=ec2.SubnetType.PRIVATE_ISOLATED)
+        subnets = None if db_subnet_group else self._get_subnet_selection()
 
         # Configure engine
         engine_version = None

cdk_factory/version.py

@@ -1 +1 @@
-__version__ = "0.18.5"
+__version__ = "0.18.6"

{cdk_factory-0.18.5.dist-info → cdk_factory-0.18.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdk_factory
-Version: 0.18.5
+Version: 0.18.6
 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.5.dist-info → cdk_factory-0.18.6.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=iPUl2pWX4a0MJCvP-avqrH4JfPv3yJGwmx8dAy0QJ40,23
+cdk_factory/version.py,sha256=uKA6-JXiIkK71mAwJK5D762_yrliPWqnH0bkkAczVnU,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
@@ -66,7 +66,7 @@ cdk_factory/constructs/sqs/policies/sqs_policies.py,sha256=4p0G8G-fqNKSr68I55fvq
 cdk_factory/interfaces/istack.py,sha256=3xqGw5kNTt_KeLHdMxI7rIR0YORqcWQOqsacmDlTAv0,1167
 cdk_factory/interfaces/live_ssm_resolver.py,sha256=3FIr9a02SXqZmbFs3RT0WxczWEQR_CF7QSt7kWbDrVE,8163
 cdk_factory/interfaces/networked_stack_mixin.py,sha256=69pJp4IE1n_tdHh2UZQ08O6ZW-v5P4uJJ_fleNaj6Nw,2897
-cdk_factory/interfaces/standardized_ssm_mixin.py,sha256=OVDzKjGWifT7jQuTdeQhEQM_FYkHlt3kcpMLF-fYHkg,24247
+cdk_factory/interfaces/standardized_ssm_mixin.py,sha256=O9d0LQY3r9hP4onE8g1448BNnR899L3hDqIFO1rWWMI,24238
 cdk_factory/interfaces/vpc_provider_mixin.py,sha256=Kj0mmZd54NINprixJLs8zL-WWiSd0AQBtGdwNg8cz14,8207
 cdk_factory/lambdas/health_handler.py,sha256=dd40ykKMxWCFEIyp2ZdQvAGNjw_ylI9CSm1N24Hp2ME,196
 cdk_factory/lambdas/edge/ip_gate/handler.py,sha256=gUevgX462mqGYddtQIyJ1-Jk3oXhFmbmd46jlqjai9E,10657
@@ -86,8 +86,7 @@ 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_old.py,sha256=WvEwIao4KPOLa8e3zaQjxlTydCIK0GfgjZn4-CNyuF0,30135
-cdk_factory/stack_library/auto_scaling/auto_scaling_stack_standardized.py,sha256=qF_-cs9gAYGCjlO4C0UE79526jpqhoz6SpEIN3h1t48,22720
+cdk_factory/stack_library/auto_scaling/auto_scaling_stack_standardized.py,sha256=X167Tj43TEIcacI9ZuOFWqyN3XlVcm_difLx0qE1Kvk,21743
 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
@@ -104,11 +103,11 @@ cdk_factory/stack_library/ecs/ecs_service_stack.py,sha256=3en447kWBOqd0d_i2C8mRR
 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
 cdk_factory/stack_library/load_balancer/__init__.py,sha256=wZpKw2OecLJGdF5mPayCYAEhu2H3c2gJFFIxwXftGDU,52
-cdk_factory/stack_library/load_balancer/load_balancer_stack.py,sha256=OB1p5ewupyQTQEYlgJqKV1elSjqfVL6K4oqVfjADvnM,30034
+cdk_factory/stack_library/load_balancer/load_balancer_stack.py,sha256=6PXrgg1laK2W5B2iKxVKJPWoZ4SjpAd35nmVyylAiqk,30202
 cdk_factory/stack_library/monitoring/__init__.py,sha256=k1G_KDx47Aw0UugaL99PN_TKlyLK4nkJVApCaAK7GJg,153
 cdk_factory/stack_library/monitoring/monitoring_stack.py,sha256=N_1YvEXE7fboH_S3kv_dSKZsufxMuPdFMjGzlNFpuSo,19283
 cdk_factory/stack_library/rds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cdk_factory/stack_library/rds/rds_stack.py,sha256=YwRLvqfIEDE5uwocnr7HpmniIfEF5OXOQ-gUhN3NlTw,14652
+cdk_factory/stack_library/rds/rds_stack.py,sha256=lgPtTHdHCRsUBkdTrCQ_-fdZB6Ymrnlei5LSRDHs808,15403
 cdk_factory/stack_library/route53/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cdk_factory/stack_library/route53/route53_stack.py,sha256=mPUJta6maUNlkXup7xKsqq7gefsRI1w_ulInE29wJs4,8387
 cdk_factory/stack_library/rum/__init__.py,sha256=gUrWQdzd4rZ2J0YzAQC8PsEGAS7QgyYjB2ZCUKWasy4,90
@@ -137,8 +136,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.5.dist-info/METADATA,sha256=hRJbftyqnC8GtrySAlYFoXmf5AWDQcRXqx9gJQUtYy8,2451
-cdk_factory-0.18.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cdk_factory-0.18.5.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
-cdk_factory-0.18.5.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
-cdk_factory-0.18.5.dist-info/RECORD,,
+cdk_factory-0.18.6.dist-info/METADATA,sha256=RirvlHJ4ioZ9NvqGjc8TpS80qGxPg2iJlgDUuwTlbVU,2451
+cdk_factory-0.18.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cdk_factory-0.18.6.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
+cdk_factory-0.18.6.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
+cdk_factory-0.18.6.dist-info/RECORD,,

cdk_factory/stack_library/auto_scaling/auto_scaling_old.py

@@ -1,721 +0,0 @@
-"""
-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",
-        )