cdk-factory 0.16.15__py3-none-any.whl → 0.20.0__py3-none-any.whl

cdk_factory/stack_library/rds/rds_stack.py

@@ -18,7 +18,8 @@ from cdk_factory.configurations.deployment import DeploymentConfig
 from cdk_factory.configurations.stack import StackConfig
 from cdk_factory.configurations.resources.rds import RdsConfig
 from cdk_factory.interfaces.istack import IStack
-from cdk_factory.interfaces.enhanced_ssm_parameter_mixin import EnhancedSsmParameterMixin
+from cdk_factory.interfaces.vpc_provider_mixin import VPCProviderMixin
+from cdk_factory.interfaces.standardized_ssm_mixin import StandardizedSsmMixin
 from cdk_factory.stack.stack_module_registry import register_stack
 from cdk_factory.workload.workload_factory import WorkloadConfig
 
@@ -27,7 +28,7 @@ logger = Logger(service="RdsStack")
 
 @register_stack("rds_library_module")
 @register_stack("rds_stack")
-class RdsStack(IStack, EnhancedSsmParameterMixin):
+class RdsStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
     """
     Reusable stack for AWS RDS.
     Supports creating RDS instances with customizable configurations.
@@ -68,8 +69,18 @@ class RdsStack(IStack, EnhancedSsmParameterMixin):
         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_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_ssm_imports()
 
         # Get VPC and security groups
         self.security_groups = self._get_security_groups()
@@ -86,63 +97,18 @@ class RdsStack(IStack, EnhancedSsmParameterMixin):
         # 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"""
-        if self._vpc:
+        """Get the VPC for the RDS instance using centralized VPC provider mixin."""
+        if hasattr(self, '_vpc') and 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"]
-            
-            # When using tokens, we can't provide subnet lists to from_vpc_attributes
-            # because CDK validates subnet count against AZ count at synthesis time
-            # We'll create a DB subnet group separately instead
-            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)
-        elif self.rds_config.vpc_id:
-            self._vpc = ec2.Vpc.from_lookup(self, "VPC", vpc_id=self.rds_config.vpc_id)
-        elif self.workload.vpc_id:
-            self._vpc = ec2.Vpc.from_lookup(self, "VPC", vpc_id=self.workload.vpc_id)
-        else:
-            raise ValueError(
-                "VPC is not defined in the configuration.  "
-                "You can provide it a the rds.vpc_id in the configuration "
-                "or a top level workload.vpc_id in the workload configuration."
-            )
+        # Resolve VPC using the centralized VPC provider mixin
+        self._vpc = self.resolve_vpc(
+            config=self.rds_config,
+            deployment=self.deployment,
+            workload=self.workload
+        )
         return self._vpc
 
     def _get_security_groups(self) -> List[ec2.ISecurityGroup]:
@@ -150,8 +116,9 @@ class RdsStack(IStack, EnhancedSsmParameterMixin):
         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
@@ -168,27 +135,60 @@ class RdsStack(IStack, EnhancedSsmParameterMixin):
         
         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
@@ -285,31 +285,7 @@ class RdsStack(IStack, EnhancedSsmParameterMixin):
 
     def _add_outputs(self, db_name: str) -> None:
         """Add CloudFormation outputs for the RDS instance"""
-        if self.db_instance:
-            # Database endpoint
-            cdk.CfnOutput(
-                self,
-                f"{db_name}-endpoint",
-                value=self.db_instance.db_instance_endpoint_address,
-                export_name=f"{self.deployment.build_resource_name(db_name)}-endpoint",
-            )
-
-            # Database port
-            cdk.CfnOutput(
-                self,
-                f"{db_name}-port",
-                value=self.db_instance.db_instance_endpoint_port,
-                export_name=f"{self.deployment.build_resource_name(db_name)}-port",
-            )
-
-            # Secret ARN (if available)
-            if hasattr(self.db_instance, "secret") and self.db_instance.secret:
-                cdk.CfnOutput(
-                    self,
-                    f"{db_name}-secret-arn",
-                    value=self.db_instance.secret.secret_arn,
-                    export_name=f"{self.deployment.build_resource_name(db_name)}-secret-arn",
-                )
+        return
 
     def _export_ssm_parameters(self, db_name: str) -> None:
         """Export RDS connection info and credentials to SSM Parameter Store"""

cdk_factory/stack_library/route53/route53_stack.py

@@ -7,10 +7,15 @@ 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_route53 as route53
-from aws_cdk import aws_route53_targets as targets
-from aws_cdk import aws_certificatemanager as acm
-from aws_cdk import aws_elasticloadbalancingv2 as elbv2
+from aws_cdk import (
+    aws_route53 as route53,
+    aws_route53_targets as targets,
+    aws_certificatemanager as acm,
+    aws_elasticloadbalancingv2 as elbv2,
+    aws_cloudfront as cloudfront,
+    Duration,
+    CfnOutput,
+)
 from aws_lambda_powertools import Logger
 from constructs import Construct
 
@@ -18,7 +23,7 @@ from cdk_factory.configurations.deployment import DeploymentConfig
 from cdk_factory.configurations.stack import StackConfig
 from cdk_factory.configurations.resources.route53 import Route53Config
 from cdk_factory.interfaces.istack import IStack
-from cdk_factory.interfaces.enhanced_ssm_parameter_mixin import EnhancedSsmParameterMixin
+from cdk_factory.interfaces.standardized_ssm_mixin import StandardizedSsmMixin
 from cdk_factory.stack.stack_module_registry import register_stack
 from cdk_factory.workload.workload_factory import WorkloadConfig
 
@@ -27,7 +32,7 @@ logger = Logger(service="Route53Stack")
 
 @register_stack("route53_library_module")
 @register_stack("route53_stack")
-class Route53Stack(IStack, EnhancedSsmParameterMixin):
+class Route53Stack(IStack, StandardizedSsmMixin):
     """
     Reusable stack for AWS Route53.
     Supports creating hosted zones, DNS records, and certificate validation.
@@ -35,6 +40,7 @@ class Route53Stack(IStack, EnhancedSsmParameterMixin):
 
     def __init__(self, scope: Construct, id: str, **kwargs) -> None:
         super().__init__(scope, id, **kwargs)
+        
         self.route53_config = None
         self.stack_config = None
         self.deployment = None
@@ -42,6 +48,7 @@ class Route53Stack(IStack, EnhancedSsmParameterMixin):
         self.hosted_zone = None
         self.certificate = None
         self.records = {}
+        self._distribution_cache = {}  # Cache for reusing distributions
 
     def build(self, stack_config: StackConfig, deployment: DeploymentConfig, workload: WorkloadConfig) -> None:
         """Build the Route53 stack"""
@@ -112,6 +119,232 @@ class Route53Stack(IStack, EnhancedSsmParameterMixin):
         return certificate
 
     def _create_dns_records(self) -> None:
+        self._create_dns_records_old()
+        self._create_dns_records_new()
+
+    
+    def _get_or_create_cloudfront_distribution(self, distribution_domain: str, distribution_id: str) -> cloudfront.Distribution:
+        """Get or create a CloudFront distribution, reusing if already created"""
+        # Create a unique cache key from distribution domain and ID
+        cache_key = f"{distribution_domain}-{distribution_id}"
+        
+        if cache_key not in self._distribution_cache:
+            # Create the distribution construct with a unique ID
+            unique_id = f"CF-{distribution_domain.replace('.', '-').replace('*', 'wildcard')}-{hash(cache_key) % 10000}"
+            distribution = cloudfront.Distribution.from_distribution_attributes(
+                self, unique_id,
+                domain_name=distribution_domain,
+                distribution_id=distribution_id
+            )
+            self._distribution_cache[cache_key] = distribution
+            logger.info(f"Created CloudFront distribution construct for {distribution_domain}")
+        
+        return self._distribution_cache[cache_key]
+
+    def _create_dns_records_new(self) -> None:
+        """Create DNS records based on configuration - generic implementation"""
+        
+        missing_configurations = []
+
+        for record in self.route53_config.records:
+            record_name = record.get("name", "")
+            record_type = record.get("type", "")
+            
+            if not record_name or not record_type:
+                message = f"Record missing name or type: {record}"
+                logger.warning(message)
+                missing_configurations.append(message)
+                continue
+            
+            # Handle alias records
+            if "alias" in record:
+                alias_config = record["alias"]
+                target_type = alias_config.get("target_type", "")
+                target_value = alias_config.get("target_value", "")
+                hosted_zone_id = alias_config.get("hosted_zone_id", "")
+                
+                unique_id = f"{record_name}-{record_type}"
+                # Handle SSM parameter references in target_value                
+                target_value = self.resolve_ssm_value(self, target_value, unique_id=unique_id)
+                
+                if not target_type or not target_value:
+                    message = f"Alias record missing target_type or target_value: {record}"
+                    logger.warning(message)
+                    missing_configurations.append(message)
+                    continue
+                
+                # Create appropriate target based on type
+                alias_target = None
+                if target_type == "cloudfront":
+                    # CloudFront distribution target
+                    distribution_domain = target_value
+                    distribution_id = alias_config.get("distribution_id", "")
+                    if not distribution_id:
+                        message = f"Alias record missing distribution_id: {record}"
+                        logger.warning(message)
+                        missing_configurations.append(message)
+                        continue
+                    
+                    # Get or create the distribution (reuses if already created)
+                    distribution = self._get_or_create_cloudfront_distribution(distribution_domain, distribution_id)
+                    alias_target = route53.RecordTarget.from_alias(
+                        targets.CloudFrontTarget(distribution)
+                    )
+                elif target_type == "loadbalancer" or target_type == "alb":
+                    # Load Balancer target
+                    alias_target = route53.RecordTarget.from_alias(
+                        targets.LoadBalancerTarget(
+                            elbv2.ApplicationLoadBalancer.from_load_balancer_attributes(
+                                self, f"ALB-{record_name}",
+                                load_balancer_dns_name=target_value,
+                                load_balancer_canonical_hosted_zone_id=hosted_zone_id
+                            )
+                        )
+                    )
+                elif target_type == "elbv2":
+                    # Generic ELBv2 target
+                    alias_target = route53.RecordTarget.from_alias(
+                        targets.LoadBalancerTarget(
+                            elbv2.ApplicationLoadBalancer.from_load_balancer_attributes(
+                                self, f"ELB-{record_name}",
+                                load_balancer_dns_name=target_value,
+                                load_balancer_canonical_hosted_zone_id=hosted_zone_id
+                            )
+                        )
+                    )
+                else:
+                    message = f"Unsupported alias target type: {target_type}"
+                    logger.warning(message)
+                    missing_configurations.append(message)
+                    continue
+                
+                # Create the alias record
+                route53.ARecord(
+                    self,
+                    f"AliasRecord-{record_name}-{record_type}",
+                    zone=self.hosted_zone,
+                    record_name=record_name,
+                    target=alias_target,
+                    ttl=cdk.Duration.seconds(record.get("ttl", 300))
+                ) if record_type == "A" else route53.AaaaRecord(
+                    self,
+                    f"AliasRecord-{record_name}-{record_type}",
+                    zone=self.hosted_zone,
+                    record_name=record_name,
+                    target=alias_target,
+                    ttl=cdk.Duration.seconds(record.get("ttl", 300))
+                )
+                
+            # Handle standard records with values
+            elif "values" in record:
+                values = record["values"]
+                if not isinstance(values, list):
+                    values = [values]
+                
+                # Handle SSM parameter references in values
+                processed_values = []
+                for value in values:
+                    if "{{ssm:" in str(value) and "}}" in str(value):
+                        # Extract SSM parameter path from template like {{ssm:/path/to/parameter}}
+                        ssm_path = str(value).split("{{ssm:")[1].split("}}")[0]
+                        resolved_value = self.get_ssm_imported_value(ssm_path)
+                        processed_values.append(resolved_value)
+                    else:
+                        processed_values.append(value)
+                
+                values = processed_values
+                ttl = record.get("ttl", 300)
+                
+                # Create standard record based on type
+                if record_type == "A":
+                    route53.ARecord(
+                        self,
+                        f"Record-{record_name}",
+                        zone=self.hosted_zone,
+                        record_name=record_name,
+                        target=route53.RecordTarget.from_ip_addresses(*values),
+                        ttl=cdk.Duration.seconds(ttl)
+                    )
+                elif record_type == "AAAA":
+                    route53.AaaaRecord(
+                        self,
+                        f"Record-{record_name}",
+                        zone=self.hosted_zone,
+                        record_name=record_name,
+                        target=route53.RecordTarget.from_ip_addresses(*values),
+                        ttl=cdk.Duration.seconds(ttl)
+                    )
+                elif record_type == "CNAME":
+                    route53.CnameRecord(
+                        self,
+                        f"Record-{record_name}",
+                        zone=self.hosted_zone,
+                        record_name=record_name,
+                        domain_name=values[0],  # CNAME only supports single value
+                        ttl=cdk.Duration.seconds(ttl)
+                    )
+                elif record_type == "MX":
+                    # MX records need special handling for preference values
+                    mx_targets = []
+                    for value in values:
+                        if isinstance(value, str) and " " in value:
+                            preference, domain = value.split(" ", 1)
+                            mx_targets.append(route53.MxRecordValue(
+                                domain_name=domain.strip(),
+                                preference=int(preference.strip())
+                            ))
+                        else:
+                            logger.warning(f"Invalid MX record format: {value}")
+                    
+                    if mx_targets:
+                        route53.MxRecord(
+                            self,
+                            f"Record-{record_name}",
+                            zone=self.hosted_zone,
+                            record_name=record_name,
+                            values=mx_targets,
+                            ttl=cdk.Duration.seconds(ttl)
+                        )
+                elif record_type == "TXT":
+                    route53.TxtRecord(
+                        self,
+                        f"Record-{record_name}",
+                        zone=self.hosted_zone,
+                        record_name=record_name,
+                        values=values,
+                        ttl=cdk.Duration.seconds(ttl)
+                    )
+                elif record_type == "NS":
+                    route53.NsRecord(
+                        self,
+                        f"Record-{record_name}",
+                        zone=self.hosted_zone,
+                        record_name=record_name,
+                        values=values,
+                        ttl=cdk.Duration.seconds(ttl)
+                    )
+                else:
+                    message = f"Unsupported record type: {record_type}"
+                    logger.warning(message)
+                    missing_configurations.append(message)
+                    continue
+            
+            else:
+                message = f"Record missing 'alias' or 'values' configuration: {record}"
+                logger.warning(message)
+                missing_configurations.append(message)
+                continue
+
+        if missing_configurations and len(missing_configurations) > 0:
+            # print all missing configurations
+            print("Missing configurations:")
+            for message in missing_configurations:
+                print(message)
+            
+            messages = "\n".join(missing_configurations)
+            raise ValueError(f"Missing Configurations:\n{messages}")
+
+    def _create_dns_records_old(self) -> None:
         """Create DNS records based on configuration"""
         # Create alias records
         for alias_record in self.route53_config.aliases:
@@ -119,6 +352,12 @@ class Route53Stack(IStack, EnhancedSsmParameterMixin):
             target_type = alias_record.get("target_type", "")
             target_value = alias_record.get("target_value", "")
             
+            # target value needs to handle SSM parameters
+            if "{{ssm:" in target_value and "}}" in target_value:
+                # Extract SSM parameter path from template like {{ssm:/path/to/parameter}}
+                ssm_path = target_value.split("{{ssm:")[1].split("}}")[0]
+                target_value = self.get_ssm_imported_value(ssm_path)
+
             if not record_name or not target_type or not target_value:
                 continue
                 
@@ -174,37 +413,4 @@ class Route53Stack(IStack, EnhancedSsmParameterMixin):
     def _add_outputs(self) -> None:
         """Add CloudFormation outputs for the Route53 resources"""
         # Hosted Zone ID
-        if self.hosted_zone:
-            cdk.CfnOutput(
-                self,
-                "HostedZoneId",
-                value=self.hosted_zone.hosted_zone_id,
-                export_name=f"{self.deployment.build_resource_name('hosted-zone')}-id"
-            )
-            
-            # Hosted Zone Name Servers
-            if hasattr(self.hosted_zone, "name_servers") and self.hosted_zone.name_servers:
-                cdk.CfnOutput(
-                    self,
-                    "NameServers",
-                    value=",".join(self.hosted_zone.name_servers),
-                    export_name=f"{self.deployment.build_resource_name('hosted-zone')}-name-servers"
-                )
-        
-        # Certificate ARN
-        if self.certificate:
-            cdk.CfnOutput(
-                self,
-                "CertificateArn",
-                value=self.certificate.certificate_arn,
-                export_name=f"{self.deployment.build_resource_name('certificate')}-arn"
-            )
-            
-        # Record names
-        for name, record in self.records.items():
-            cdk.CfnOutput(
-                self,
-                f"Record-{name}",
-                value=name,
-                export_name=f"{self.deployment.build_resource_name('record')}-{name}"
-            )
+        return