cdk-factory 0.19.13__py3-none-any.whl → 0.20.5__py3-none-any.whl

cdk_factory/stack_library/route53/route53_stack.py

@@ -27,6 +27,7 @@ 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
 
+
 logger = Logger(service="Route53Stack")
 
 
@@ -48,7 +49,8 @@ class Route53Stack(IStack, StandardizedSsmMixin):
         self.hosted_zone = None
         self.certificate = None
         self.records = {}
-        self._distribution_cache = {}  # Cache for reusing distributions
+        self._local_cache = {}  # Cache for reusing distributions
+        self._missing_configurations = []
 
     def build(self, stack_config: StackConfig, deployment: DeploymentConfig, workload: WorkloadConfig) -> None:
         """Build the Route53 stack"""
@@ -119,7 +121,7 @@ class Route53Stack(IStack, StandardizedSsmMixin):
         return certificate
 
     def _create_dns_records(self) -> None:
-        self._create_dns_records_old()
+        # self._create_dns_records_old()
         self._create_dns_records_new()
 
     
@@ -128,7 +130,7 @@ class Route53Stack(IStack, StandardizedSsmMixin):
         # 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:
+        if cache_key not in self._local_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(
@@ -136,104 +138,108 @@ class Route53Stack(IStack, StandardizedSsmMixin):
                 domain_name=distribution_domain,
                 distribution_id=distribution_id
             )
-            self._distribution_cache[cache_key] = distribution
+            self._local_cache[cache_key] = distribution
             logger.info(f"Created CloudFront distribution construct for {distribution_domain}")
         
-        return self._distribution_cache[cache_key]
+        return self._local_cache[cache_key]
+    
+    def _get_or_create_alb_target(self, record_name: str, target_value: str, load_balancer_zone_id: str, security_group_id: str, load_balancer_dns_name: str) -> targets.LoadBalancerTarget:
+        """Get or create a CloudFront distribution, reusing if already created"""
+        # Create a unique cache key from distribution domain and ID
+        cache_key = f"{record_name}-alb"
+        
+        if cache_key not in self._local_cache:
+            # Create the distribution construct with a unique ID
+            target = targets.LoadBalancerTarget(
+                elbv2.ApplicationLoadBalancer.from_application_load_balancer_attributes(
+                    self, f"ALB-{record_name}",
+                    load_balancer_arn=target_value,
+                    load_balancer_canonical_hosted_zone_id=load_balancer_zone_id,
+                    security_group_id=security_group_id,
+                    load_balancer_dns_name=load_balancer_dns_name,
+                    
+                )
+            )
+            self._local_cache[cache_key] = target
+            logger.info(f"Created ALB target construct for ALB-{record_name}")
+        
+        return self._local_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", "")
+            t = record.get("type")
+            record_name = self._get_resolved_value(config=record, key="name", record_type=t)
+            record_type = self._get_resolved_value(config=record, key="type", record_type=t)
+            
             
-            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)
+                target_type = self._get_resolved_value(config=alias_config, key="target_type", record_type=record_type)
+                target_value = self._get_resolved_value(config=alias_config, key="target_value", record_type=record_type)
+                
+                
                 
-                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
+                    distribution_id = self._get_resolved_value(config=alias_config, key="distribution_id", record_type=record_type)
+                    
                     
                     # 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
-                            )
-                        )
-                    )
+                elif target_type == "loadbalancer" or target_type == "alb" or target_type == "elbv2":
+                    # ALB alias target using imported load balancer attributes
+
+                    security_group_id=self._get_resolved_value(config=alias_config, key="security_group_id", record_type=record_type)                
+                    load_balancer_dns_name = self._get_resolved_value(config=alias_config, key="load_balancer_dns_name", record_type=record_type)                
+                    load_balancer_zone_id = self._get_resolved_value(config=alias_config, key="load_balancer_zone_id", record_type=record_type)
+                    
+                    
+                    
+                    target = self._get_or_create_alb_target(record_name, target_value, load_balancer_zone_id, security_group_id, load_balancer_dns_name)
+                            
+                    alias_target = route53.RecordTarget.from_alias(target)
+                
                 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,
+                route_53_record = None
+                id = f"AliasRecord-{record_name}-{record_type}"
+                print(f"creating record {id}")
+                if record_type == "A":
+                    route_53_record = route53.ARecord(
+                        self,
+                        id,
+                        zone=self.hosted_zone,
                     record_name=record_name,
                     target=alias_target,
                     ttl=cdk.Duration.seconds(record.get("ttl", 300))
                 )
+                elif record_type == "AAAA":
+                    route_53_record = route53.AaaaRecord(
+                        self,
+                        id,
+                        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:
@@ -326,89 +332,47 @@ class Route53Stack(IStack, StandardizedSsmMixin):
                 else:
                     message = f"Unsupported record type: {record_type}"
                     logger.warning(message)
-                    missing_configurations.append(message)
+                    self._missing_configurations.append(message)
                     continue
             
             else:
                 message = f"Record missing 'alias' or 'values' configuration: {record}"
                 logger.warning(message)
-                missing_configurations.append(message)
+                self._missing_configurations.append(message)
                 continue
 
-        if missing_configurations and len(missing_configurations) > 0:
+        if self._missing_configurations and len(self._missing_configurations) > 0:
             # print all missing configurations
             print("Missing configurations:")
-            for message in missing_configurations:
+            for message in self._missing_configurations:
                 print(message)
             
-            messages = "\n".join(missing_configurations)
+            messages = "\n".join(self._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:
-            record_name = alias_record.get("name", "")
-            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)
+    def _get_resolved_value(self, *, config: dict, key: str, required: bool = True, record_type: str = ""   ) -> str:
+        
+        value = config.get(key, "")
+        x = str(value).replace("{", "").replace("}", "").replace(":", "")
+        unique_id = f"{key}-id-{record_type}-{x}"
 
-            if not record_name or not target_type or not target_value:
-                continue
-                
-            # Determine the alias target
-            alias_target = None
-            if target_type == "alb":
-                # Get the ALB from the workload if available
-                if hasattr(self.workload, "load_balancer"):
-                    alb = self.workload.load_balancer
-                    alias_target = route53.RecordTarget.from_alias(targets.LoadBalancerTarget(alb))
-                else:
-                    # Try to get ALB from target value
-                    alb = elbv2.ApplicationLoadBalancer.from_lookup(
-                        self,
-                        f"ALB-{record_name}",
-                        load_balancer_arn=target_value
-                    )
-                    alias_target = route53.RecordTarget.from_alias(targets.LoadBalancerTarget(alb))
-            elif target_type == "cloudfront":
-                # For CloudFront, we would need the distribution
-                # This is a simplified implementation
-                pass
-                
-            if alias_target:
-                record = route53.ARecord(
-                    self,
-                    f"AliasRecord-{record_name}",
-                    zone=self.hosted_zone,
-                    record_name=record_name,
-                    target=alias_target
-                )
-                self.records[record_name] = record
-                
-        # Create CNAME records
-        for cname_record in self.route53_config.cname_records:
-            record_name = cname_record.get("name", "")
-            target_domain = cname_record.get("target_domain", "")
-            ttl = cname_record.get("ttl", 300)
-            
-            if not record_name or not target_domain:
-                continue
-                
-            record = route53.CnameRecord(
-                self,
-                f"CnameRecord-{record_name}",
-                zone=self.hosted_zone,
-                record_name=record_name,
-                domain_name=target_domain,
-                ttl=cdk.Duration.seconds(ttl)
-            )
-            self.records[record_name] = record
+        if unique_id in self._local_cache:
+            return self._local_cache[unique_id]
+        
+        
+        
+        # Handle SSM parameter references in target_value                
+        value = self.resolve_ssm_value(self, value, unique_id=unique_id)
+
+        if required and not value:
+            self._missing_configurations.append(f"Missing required value for key: {key}")
+
+        self._local_cache[unique_id] = value
+
+
+        return value
+
+    
 
     def _add_outputs(self) -> None:
         """Add CloudFormation outputs for the Route53 resources"""

cdk_factory/version.py

@@ -1 +1 @@
-__version__ = "0.19.13"
+__version__ = "0.20.5"

{cdk_factory-0.19.13.dist-info → cdk_factory-0.20.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdk_factory
-Version: 0.19.13
+Version: 0.20.5
 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.19.13.dist-info → cdk_factory-0.20.5.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=qfLAZUWz8ZIxPUsFWlqQCfCwTNmUwrL2jNL4w6ZRFi0,24
+cdk_factory/version.py,sha256=KohmrV3SWmyEbdcyopRMCctCtbthoMrxKM29jQ5Xa58,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
@@ -86,7 +86,7 @@ cdk_factory/stack_library/acm/__init__.py,sha256=4FNRLykblcKZvq_wieYwvv9N_jgrZnJ
 cdk_factory/stack_library/acm/acm_stack.py,sha256=LW4QgzcMDvtSpqwfc4ykgpzDGvXe4udvWVE_DtBN4Zg,5414
 cdk_factory/stack_library/api_gateway/api_gateway_stack.py,sha256=PvLdGvcopGpLP0FwpfUcfXNiTIfYLTXqrG-TniE38yc,39643
 cdk_factory/stack_library/auto_scaling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py,sha256=G8OOgTAfsTDVArvuDfzuNpuGHzqz8kREHnnkMtjulAQ,25334
+cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py,sha256=gjDxYWC4QZEZ4UOhGjgziggP7391dEMEe3vaslHSZ0c,25884
 cdk_factory/stack_library/aws_lambdas/lambda_stack.py,sha256=SFbBPvvCopbyiuYtq-O5sQkFCf94Wzua6aDUXiFDSB4,26161
 cdk_factory/stack_library/buckets/README.md,sha256=XkK3UNVtRLE7NtUvbhCOBBYUYi8hlrrSaI1s3GJVrqI,78
 cdk_factory/stack_library/buckets/bucket_stack.py,sha256=SLoZqSffAqmeBBEVUQg54D_8Ad5UKdkjEAmKAVgAqQo,1778
@@ -98,18 +98,25 @@ cdk_factory/stack_library/dynamodb/dynamodb_stack.py,sha256=-_Ij1zXIxUuZIWgdevam
 cdk_factory/stack_library/ecr/README.md,sha256=xw2wPx9WN03Y4BBwqvbi9lAFGNyaD1FUNpqxVJX14Oo,179
 cdk_factory/stack_library/ecr/ecr_stack.py,sha256=KLbd5WN5-ZiojsS5wJ4PX-tIL0cCylCSvXjO6sVrgWY,2102
 cdk_factory/stack_library/ecs/__init__.py,sha256=o5vGDtD_h-gVXb3-Ysr8xUNpEcMsnmMVgZv2Pupcdow,219
-cdk_factory/stack_library/ecs/ecs_cluster_stack.py,sha256=sAPTLU5CAwMoLTW_pNy_cd0OtVkfDR7IxxsSq5AE0yo,12091
-cdk_factory/stack_library/ecs/ecs_service_stack.py,sha256=KB4YCIsMm5JIGM9Bm-bKcr3eX5xXFgnoA7jST_ekK44,28209
+cdk_factory/stack_library/ecs/ecs_cluster_stack.py,sha256=j0Cc7CyTK8MQDGCeZzo7XYrj1AM1hQBLH9DGXs7k-hQ,12165
+cdk_factory/stack_library/ecs/ecs_service_stack.py,sha256=fm3Q2oeMN5JULatYFrQDfyTs58k283weQjPEuhpz1Sc,28297
 cdk_factory/stack_library/lambda_edge/__init__.py,sha256=ByBJ_CWdc4UtTmFBZH-6pzBMNkjkdtE65AmnB0Fs6lM,156
-cdk_factory/stack_library/lambda_edge/lambda_edge_stack.py,sha256=eHh_k4mbNp1prEnNvKqfK82lLNrMZS-7HAaUYzFEoOU,21040
+cdk_factory/stack_library/lambda_edge/lambda_edge_log_retention_stack.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cdk_factory/stack_library/lambda_edge/lambda_edge_stack.py,sha256=QxuyJ1mR8018HRqDXERkmsFMuEHd5YsVIACmXitYZDY,23344
+cdk_factory/stack_library/lambda_edge/functions/README.md,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cdk_factory/stack_library/lambda_edge/functions/log_retention_manager/__init__.py,sha256=0JJIk47ubXY4QddDJ6hyyDMXBGYd0IzQyd3-SPqVikU,964
+cdk_factory/stack_library/lambda_edge/functions/log_retention_manager/app.py,sha256=i77H3f0KATiNhnPo0Ca8-B5OWPtDRT8def4HHiCp8Zw,858
+cdk_factory/stack_library/lambda_edge/functions/log_retention_manager/edge_log_retention.py,sha256=a-i0N_44RehzHA_hSx0Z9NFLfy4T-RZKA1sMS-CcYAw,3744
+cdk_factory/stack_library/lambda_edge/functions/log_retention_manager/requirements.txt,sha256=nJ0ZsOr7cuZEKNQd6e3EPStDJI7Y5Jnshi-FoydLE7o,46
+cdk_factory/stack_library/lambda_edge/functions/log_retention_manager/test.py,sha256=CwjyMIjQ5kbeYicMUnAIK3eflBYbobEaM1noq-7Ck1Q,567
 cdk_factory/stack_library/load_balancer/__init__.py,sha256=wZpKw2OecLJGdF5mPayCYAEhu2H3c2gJFFIxwXftGDU,52
-cdk_factory/stack_library/load_balancer/load_balancer_stack.py,sha256=ApW5q3SAvSJtiK0RInNljmubqXqKZU5QBAaUoeIW-pM,28287
+cdk_factory/stack_library/load_balancer/load_balancer_stack.py,sha256=iR-l5ujLS4zUReI-deWs8sDIUbmFYoWKt9kEZri1z2A,28441
 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=VToW-uFKAfilyhN4T8-TXaFW8f_VuXEIuUoBHvDN0Ns,14398
 cdk_factory/stack_library/route53/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cdk_factory/stack_library/route53/route53_stack.py,sha256=taREOw-s7i1NZcdR-za1lKkj-Cj8UPmr4BO5txS18fI,18348
+cdk_factory/stack_library/route53/route53_stack.py,sha256=PaYpVVYC_jZ-pbsmK0vW_OVleJ4En0L2O_a92jlWi18,16601
 cdk_factory/stack_library/rum/__init__.py,sha256=gUrWQdzd4rZ2J0YzAQC8PsEGAS7QgyYjB2ZCUKWasy4,90
 cdk_factory/stack_library/rum/rum_stack.py,sha256=c67m0Jbyx8hx9TTx9TBBhZMDqtSK7QCqKx_Ec1t8LgY,14067
 cdk_factory/stack_library/security_group/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -136,8 +143,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.19.13.dist-info/METADATA,sha256=Rw6GGM7Hl5-md3ntKrGRfX2u1ppfZRfIextBHMW-FsE,2452
-cdk_factory-0.19.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cdk_factory-0.19.13.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
-cdk_factory-0.19.13.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
-cdk_factory-0.19.13.dist-info/RECORD,,
+cdk_factory-0.20.5.dist-info/METADATA,sha256=a19HKUiZr8FOVgDbMbQj6mmhVd4QL1ESVrexE5yL7BY,2451
+cdk_factory-0.20.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cdk_factory-0.20.5.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
+cdk_factory-0.20.5.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
+cdk_factory-0.20.5.dist-info/RECORD,,