cdk-factory 0.15.4__tar.gz → 0.15.7__tar.gz

{cdk_factory-0.15.4 → cdk_factory-0.15.7}/PKG-INFO

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

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

{cdk_factory-0.15.4 → cdk_factory-0.15.7}/src/cdk_factory/configurations/resources/ecs_service.py

@@ -129,8 +129,11 @@ class EcsServiceConfig:
         return self._config.get("ssm_exports", {})
 
     @property
-    def ssm_imports(self) -> Dict[str, str]:
+    def ssm_imports(self) -> Dict[str, Any]:
         """SSM parameter imports"""
+        # Check both nested and flat structures for backwards compatibility
+        if "ssm" in self._config and "imports" in self._config["ssm"]:
+            return self._config["ssm"]["imports"]
         return self._config.get("ssm_imports", {})
 
     @property

{cdk_factory-0.15.4 → cdk_factory-0.15.7}/src/cdk_factory/configurations/resources/load_balancer.py

@@ -143,3 +143,11 @@ class LoadBalancerConfig(EnhancedBaseConfig):
         return self.__config.get("ip_whitelist", {}).get(
             "block_response", default_response
         )
+
+    @property
+    def ssm_imports(self) -> Dict[str, Any]:
+        """SSM parameter imports for the Load Balancer"""
+        # Check both nested and flat structures for backwards compatibility
+        if "ssm" in self.__config and "imports" in self.__config["ssm"]:
+            return self.__config["ssm"]["imports"]
+        return self.__config.get("ssm_imports", {})

{cdk_factory-0.15.4 → cdk_factory-0.15.7}/src/cdk_factory/configurations/resources/rds.py

@@ -134,4 +134,7 @@ class RdsConfig(EnhancedBaseConfig):
     @property
     def ssm_imports(self) -> Dict[str, str]:
         """SSM parameter imports for the RDS instance"""
+        # Check both nested and flat structures for backwards compatibility
+        if "ssm" in self.__config and "imports" in self.__config["ssm"]:
+            return self.__config["ssm"]["imports"]
         return self.__config.get("ssm_imports", {})

{cdk_factory-0.15.4 → cdk_factory-0.15.7}/src/cdk_factory/configurations/resources/security_group_full_stack.py

@@ -65,4 +65,7 @@ class SecurityGroupFullStackConfig:
     @property
     def ssm_imports(self) -> Dict[str, str]:
         """SSM parameter imports for the Security Group"""
+        # Check both nested and flat structures for backwards compatibility
+        if "ssm" in self.__config and "imports" in self.__config["ssm"]:
+            return self.__config["ssm"]["imports"]
         return self.__config.get("ssm_imports", {})

{cdk_factory-0.15.4 → cdk_factory-0.15.7}/src/cdk_factory/lambdas/edge/ip_gate/handler.py

@@ -15,7 +15,7 @@ from functools import lru_cache
 ssm = None
 
 @lru_cache(maxsize=128)
-def get_ssm_parameter(parameter_name: str, region: str = 'us-east-1') -> str:
+def get_ssm_parameter(parameter_name: str, region: str = 'us-east-1', default: str = None) -> str:
     """
     Fetch SSM parameter with caching.
     Lambda@Edge cannot use environment variables, so we fetch from SSM.
@@ -25,9 +25,10 @@ def get_ssm_parameter(parameter_name: str, region: str = 'us-east-1') -> str:
     Args:
         parameter_name: Name of the SSM parameter
         region: AWS region (default us-east-1)
+        default: Default value to return if parameter not found (optional)
     
     Returns:
-        Parameter value, or empty string if value is 'NONE'
+        Parameter value, default value if parameter not found, or empty string if value is 'NONE'
     """
     global ssm
     if ssm is None:
@@ -43,8 +44,17 @@ def get_ssm_parameter(parameter_name: str, region: str = 'us-east-1') -> str:
             return ''
         
         return value
+    except ssm.exceptions.ParameterNotFound:
+        if default is not None:
+            print(f"SSM parameter {parameter_name} not found, using default: {default}")
+            return default
+        print(f"SSM parameter {parameter_name} not found and no default provided")
+        raise
     except Exception as e:
         print(f"Error fetching SSM parameter {parameter_name}: {str(e)}")
+        if default is not None:
+            print(f"Returning default value due to error: {default}")
+            return default
         raise
 
 
@@ -180,8 +190,8 @@ def lambda_handler(event, context):
         
         # IP not allowed - either redirect or proxy maintenance page
         # Check response mode from SSM (default: redirect for backward compatibility)
-        response_mode_param = f"/{function_name}/response-mode"
-        response_mode = get_ssm_parameter(response_mode_param, default='redirect')
+        response_mode_param = f"/{env}/{function_name}/response-mode"
+        response_mode = get_ssm_parameter(response_mode_param, 'us-east-1', default='redirect')
         
         if response_mode == 'proxy':
             # Proxy mode: Fetch and return maintenance content (keeps URL the same)

{cdk_factory-0.15.4 → cdk_factory-0.15.7}/src/cdk_factory/stack_library/ecs/ecs_service_stack.py

@@ -49,6 +49,8 @@ class EcsServiceStack(IStack, EnhancedSsmParameterMixin):
         self.service: Optional[ecs.FargateService] = None
         self.task_definition: Optional[ecs.FargateTaskDefinition] = None
         self._vpc: Optional[ec2.IVpc] = None
+        # SSM imported values
+        self.ssm_imported_values: Dict[str, Any] = {}
 
     def build(
         self,
@@ -77,6 +79,9 @@ class EcsServiceStack(IStack, EnhancedSsmParameterMixin):
         
         service_name = deployment.build_resource_name(self.ecs_config.name)
         
+        # Process SSM imports first
+        self._process_ssm_imports()
+        
         # Load VPC
         self._load_vpc()
         
@@ -98,16 +103,79 @@ class EcsServiceStack(IStack, EnhancedSsmParameterMixin):
 
     def _load_vpc(self) -> None:
         """Load VPC from configuration"""
-        vpc_id = self.ecs_config.vpc_id or self.workload.vpc_id
+        # Check SSM imported values first
+        if "vpc_id" in self.ssm_imported_values:
+            vpc_id = self.ssm_imported_values["vpc_id"]
+            
+            # Build VPC attributes
+            vpc_attrs = {
+                "vpc_id": vpc_id,
+                "availability_zones": ["us-east-1a", "us-east-1b"]
+            }
+            
+            # Use from_vpc_attributes() for SSM tokens
+            self._vpc = ec2.Vpc.from_vpc_attributes(self, "VPC", **vpc_attrs)
+        else:
+            vpc_id = self.ecs_config.vpc_id or self.workload.vpc_id
+            
+            if not vpc_id:
+                raise ValueError("VPC ID is required for ECS service")
+            
+            self._vpc = ec2.Vpc.from_lookup(
+                self,
+                "VPC",
+                vpc_id=vpc_id
+            )
+
+    def _process_ssm_imports(self) -> None:
+        """
+        Process SSM imports from configuration.
+        Follows the same pattern as RDS, Load Balancer, and Security Group stacks.
+        """
+        from aws_cdk import aws_ssm as ssm
         
-        if not vpc_id:
-            raise ValueError("VPC ID is required for ECS service")
+        ssm_imports = self.ecs_config.ssm_imports
         
-        self._vpc = ec2.Vpc.from_lookup(
-            self,
-            "VPC",
-            vpc_id=vpc_id
-        )
+        if not ssm_imports:
+            logger.debug("No SSM imports configured for ECS Service")
+            return
+        
+        logger.info(f"Processing {len(ssm_imports)} SSM imports for ECS Service")
+        
+        for param_key, param_value in ssm_imports.items():
+            try:
+                # Handle list values (like security_group_ids)
+                if isinstance(param_value, list):
+                    imported_list = []
+                    for idx, param_path in enumerate(param_value):
+                        if not param_path.startswith('/'):
+                            param_path = f"/{param_path}"
+                        
+                        construct_id = f"ssm-import-{param_key}-{idx}-{hash(param_path) % 10000}"
+                        param = ssm.StringParameter.from_string_parameter_name(
+                            self, construct_id, param_path
+                        )
+                        imported_list.append(param.string_value)
+                    
+                    self.ssm_imported_values[param_key] = imported_list
+                    logger.info(f"Imported SSM parameter list: {param_key} with {len(imported_list)} items")
+                else:
+                    # Handle string values
+                    param_path = param_value
+                    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}: {e}")
+                raise
 
     def _create_or_load_cluster(self) -> None:
         """Create a new ECS cluster or load an existing one"""

{cdk_factory-0.15.4 → cdk_factory-0.15.7}/src/cdk_factory/stack_library/load_balancer/load_balancer_stack.py

@@ -48,6 +48,8 @@ class LoadBalancerStack(IStack, EnhancedSsmParameterMixin):
         self._vpc = None
         self._hosted_zone = None
         self._record_names = None
+        # SSM imported values
+        self.ssm_imported_values: Dict[str, str] = {}
 
     def build(
         self,
@@ -74,6 +76,9 @@ class LoadBalancerStack(IStack, EnhancedSsmParameterMixin):
         )
         lb_name = deployment.build_resource_name(self.lb_config.name)
 
+        # Process SSM imports first
+        self._process_ssm_imports()
+
         self._prep_dns()
 
         # set up SSL certificate if configured
@@ -148,6 +153,18 @@ class LoadBalancerStack(IStack, EnhancedSsmParameterMixin):
         if self._vpc:
             return self._vpc
 
+        # Check SSM imported values first (tokens from SSM parameters)
+        if "vpc_id" in self.ssm_imported_values:
+            vpc_id = self.ssm_imported_values["vpc_id"]
+            
+            # Build VPC attributes
+            vpc_attrs = {
+                "vpc_id": vpc_id,
+                "availability_zones": ["us-east-1a", "us-east-1b"]
+            }
+            
+            # Use from_vpc_attributes() instead of from_lookup() because SSM imports return tokens
+            self._vpc = ec2.Vpc.from_vpc_attributes(self, "VPC", **vpc_attrs)
         elif self.lb_config.vpc_id:
             self._vpc = ec2.Vpc.from_lookup(self, "VPC", vpc_id=self.lb_config.vpc_id)
         elif self.workload.vpc_id:
@@ -162,13 +179,72 @@ class LoadBalancerStack(IStack, EnhancedSsmParameterMixin):
 
         return self._vpc
 
+    def _process_ssm_imports(self) -> None:
+        """
+        Process SSM imports from configuration.
+        Follows the same pattern as RDS and Security Group stacks.
+        """
+        from aws_cdk import aws_ssm as ssm
+        
+        ssm_imports = self.lb_config.ssm_imports
+        
+        if not ssm_imports:
+            logger.debug("No SSM imports configured for Load Balancer")
+            return
+        
+        logger.info(f"Processing {len(ssm_imports)} SSM imports for Load Balancer")
+        
+        for param_key, param_value in ssm_imports.items():
+            try:
+                # Handle list values (like security_groups)
+                if isinstance(param_value, list):
+                    imported_list = []
+                    for idx, param_path in enumerate(param_value):
+                        if not param_path.startswith('/'):
+                            param_path = f"/{param_path}"
+                        
+                        construct_id = f"ssm-import-{param_key}-{idx}-{hash(param_path) % 10000}"
+                        param = ssm.StringParameter.from_string_parameter_name(
+                            self, construct_id, param_path
+                        )
+                        imported_list.append(param.string_value)
+                    
+                    self.ssm_imported_values[param_key] = imported_list
+                    logger.info(f"Imported SSM parameter list: {param_key} with {len(imported_list)} items")
+                else:
+                    # Handle string values
+                    param_path = param_value
+                    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}: {e}")
+                raise
+
     def _get_security_groups(self) -> List[ec2.ISecurityGroup]:
         """Get security groups for the Load Balancer"""
         security_groups = []
-        for sg_id in self.lb_config.security_groups:
+        
+        # Check SSM imported values first
+        if "security_groups" in self.ssm_imported_values:
+            sg_ids = self.ssm_imported_values["security_groups"]
+            if not isinstance(sg_ids, list):
+                sg_ids = [sg_ids]
+        else:
+            sg_ids = self.lb_config.security_groups
+        
+        for idx, sg_id in enumerate(sg_ids):
             security_groups.append(
                 ec2.SecurityGroup.from_security_group_id(
-                    self, f"SecurityGroup-{sg_id}", sg_id
+                    self, f"SecurityGroup-{idx}", sg_id
                 )
             )
         return security_groups
@@ -176,9 +252,21 @@ class LoadBalancerStack(IStack, EnhancedSsmParameterMixin):
     def _get_subnets(self) -> List[ec2.ISubnet]:
         """Get subnets for the Load Balancer"""
         subnets = []
-        for subnet_id in self.lb_config.subnets:
+        
+        # Check SSM imported values first
+        if "subnet_ids" in self.ssm_imported_values:
+            subnet_ids = self.ssm_imported_values["subnet_ids"]
+            # SSM returns comma-separated string for StringList, need to split
+            if isinstance(subnet_ids, str):
+                subnet_ids = [s.strip() for s in subnet_ids.split(',')]
+            elif not isinstance(subnet_ids, list):
+                subnet_ids = [subnet_ids]
+        else:
+            subnet_ids = self.lb_config.subnets
+        
+        for idx, subnet_id in enumerate(subnet_ids):
             subnets.append(
-                ec2.Subnet.from_subnet_id(self, f"Subnet-{subnet_id}", subnet_id)
+                ec2.Subnet.from_subnet_id(self, f"Subnet-{idx}", subnet_id)
             )
         return subnets
 

cdk_factory-0.15.7/src/cdk_factory/version.py

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

cdk_factory-0.15.4/src/cdk_factory/version.py

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