cdk-factory 0.8.7__py3-none-any.whl → 0.9.0__py3-none-any.whl

cdk_factory/app.py

@@ -25,14 +25,52 @@ class CdkAppFactory:
         config_path: str | None = None,
         outdir: str | None = None,
         add_env_context: bool = True,
+        auto_detect_project_root: bool = True,
+        is_pipeline: bool = False,
     ) -> None:
 
         self.args = args or CommandlineArgs()
-        self.outdir = outdir or self.args.outdir
-        self.app: aws_cdk.App = aws_cdk.App()
         self.runtime_directory = runtime_directory or str(Path(__file__).parent)
         self.config_path: str | None = config_path
         self.add_env_context = add_env_context
+        self._is_pipeline = is_pipeline
+        
+        # Auto-detect outdir for CodeBuild compatibility
+        if outdir is None and self.args.outdir is None and auto_detect_project_root:
+            # Always detect project root first
+            project_root = self._detect_project_root()
+            
+            # Check if we're in CodeBuild or building a pipeline
+            in_codebuild = bool(os.getenv('CODEBUILD_SRC_DIR'))
+            
+            # Auto-detect if this is a pipeline deployment by checking config
+            is_pipeline_deployment = is_pipeline or self._check_if_pipeline_deployment(config_path)
+            
+            if in_codebuild or is_pipeline_deployment:
+                # For pipelines, calculate relative path from runtime_directory to project_root/cdk.out
+                # This ensures cdk.out is always at project root, even when app.py is in subdirectory
+                runtime_path = Path(self.runtime_directory).resolve()
+                project_path = Path(project_root).resolve()
+                cdk_out_path = project_path / 'cdk.out'
+                
+                try:
+                    # Calculate relative path from runtime directory to project_root/cdk.out
+                    relative_path = os.path.relpath(cdk_out_path, runtime_path)
+                    self.outdir = relative_path
+                    if in_codebuild:
+                        print(f"📦 CodeBuild detected: using relative path '{relative_path}'")
+                    else:
+                        print(f"📦 Pipeline deployment detected: using relative path '{relative_path}'")
+                except ValueError:
+                    # If paths are on different drives (Windows), fallback to absolute
+                    self.outdir = str(cdk_out_path)
+            else:
+                # For local dev, use absolute path at project root
+                self.outdir = os.path.join(project_root, 'cdk.out')
+        else:
+            self.outdir = outdir or self.args.outdir
+        
+        self.app: aws_cdk.App = aws_cdk.App(outdir=self.outdir)
 
     def synth(
         self,
@@ -84,6 +122,98 @@ class CdkAppFactory:
 
         return assembly
 
+    def _detect_project_root(self) -> str:
+        """
+        Detect project root directory for proper cdk.out placement
+
+        Priority:
+        1. CODEBUILD_SRC_DIR (CodeBuild environment)
+        2. Find project markers (pyproject.toml, package.json, .git, etc.)
+        3. Assume devops/cdk-iac structure (go up 2 levels)
+        4. Fallback to runtime_directory
+
+        Returns:
+            str: Absolute path to project root
+        """
+        # Priority 1: CodeBuild environment (most reliable)
+        codebuild_src = os.getenv("CODEBUILD_SRC_DIR")
+        if codebuild_src:
+            return str(Path(codebuild_src).resolve())
+
+        # Priority 2: Look for project root markers
+        # CodeBuild often gets zip without .git, so check multiple markers
+        current = Path(self.runtime_directory).resolve()
+
+        # Walk up the directory tree looking for root markers
+        for parent in [current] + list(current.parents):
+            # Check for common project root indicators
+            root_markers = [
+                ".git",  # Git repo (local dev)
+                "pyproject.toml",  # Python project root
+                "package.json",  # Node project root
+                "Cargo.toml",  # Rust project root
+                ".gitignore",  # Often at root
+                "README.md",  # Often at root
+                "requirements.txt",  # Python dependencies
+            ]
+
+            # If we find multiple markers at this level, it's likely the root
+            markers_found = sum(
+                1 for marker in root_markers if (parent / marker).exists()
+            )
+            if markers_found >= 2 and parent != current:
+                return str(parent)
+
+        # Priority 3: Assume devops/cdk-iac structure
+        # If runtime_directory ends with devops/cdk-iac, go up 2 levels
+        parts = current.parts
+        if len(parts) >= 2 and parts[-2:] == ("devops", "cdk-iac"):
+            return str(current.parent.parent)
+
+        # Also try just 'cdk-iac' or 'devops'
+        if len(parts) >= 1 and parts[-1] in (
+            "cdk-iac",
+            "devops",
+            "infrastructure",
+            "iac",
+        ):
+            # Go up until we're not in these directories
+            potential_root = current.parent
+            while potential_root.name in ("devops", "cdk-iac", "infrastructure", "iac"):
+                potential_root = potential_root.parent
+            return str(potential_root)
+
+        # Priority 4: Fallback to runtime_directory
+        return str(current)
+
+    def _check_if_pipeline_deployment(self, config_path: str | None) -> bool:
+        """
+        Check if the configuration includes pipeline deployments with CI/CD enabled.
+        Returns True if pipelines are detected, False otherwise.
+        """
+        if not config_path or not os.path.exists(config_path):
+            return False
+        
+        try:
+            import json
+            with open(config_path, 'r') as f:
+                config = json.load(f)
+            
+            # Check for workload.deployments with CI/CD enabled
+            workload = config.get('workload', {})
+            deployments = workload.get('deployments', [])
+            
+            for deployment in deployments:
+                devops = deployment.get('devops', {})
+                ci_cd = devops.get('ci_cd', {})
+                if ci_cd.get('enabled', False):
+                    return True
+            
+            return False
+        except:
+            # If we can't read/parse the config, assume not a pipeline
+            return False
+
 
 if __name__ == "__main__":
     # deploy_test()

cdk_factory/cli.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+"""
+CDK Factory CLI
+
+Provides convenience commands for initializing and managing cdk-factory projects.
+"""
+
+import argparse
+import os
+import shutil
+from pathlib import Path
+from typing import Optional
+
+
+class CdkFactoryCLI:
+    """CLI for cdk-factory project management"""
+    
+    def __init__(self):
+        self.package_root = Path(__file__).parent.resolve()
+        self.templates_dir = self.package_root / "templates"
+        
+        # Verify templates directory exists
+        if not self.templates_dir.exists():
+            raise RuntimeError(
+                f"Templates directory not found at {self.templates_dir}. "
+                "Please ensure cdk-factory is properly installed."
+            )
+    
+    def init_project(
+        self,
+        target_dir: str,
+        workload_name: Optional[str] = None,
+        environment: Optional[str] = None,
+    ) -> None:
+        """
+        Initialize a new cdk-factory project
+        
+        Args:
+            target_dir: Directory to initialize (e.g., devops/cdk-iac)
+            workload_name: Name of the workload (optional)
+            environment: Environment name (optional)
+        """
+        target_path = Path(target_dir).resolve()
+        
+        if not target_path.exists():
+            target_path.mkdir(parents=True, exist_ok=True)
+            print(f"✅ Created directory: {target_path}")
+        
+        # Copy app.py template
+        app_template = self.templates_dir / "app.py.template"
+        app_dest = target_path / "app.py"
+        
+        if app_dest.exists():
+            response = input(f"⚠️  {app_dest} already exists. Overwrite? (y/N): ")
+            if response.lower() != 'y':
+                print("Skipped app.py")
+            else:
+                shutil.copy(app_template, app_dest)
+                print(f"✅ Created {app_dest}")
+        else:
+            shutil.copy(app_template, app_dest)
+            print(f"✅ Created {app_dest}")
+        
+        # Copy cdk.json template
+        cdk_json_template = self.templates_dir / "cdk.json.template"
+        cdk_json_dest = target_path / "cdk.json"
+        
+        if cdk_json_dest.exists():
+            print(f"⚠️  {cdk_json_dest} already exists. Skipping.")
+        else:
+            shutil.copy(cdk_json_template, cdk_json_dest)
+            print(f"✅ Created {cdk_json_dest}")
+        
+        # Create minimal config.json
+        config_dest = target_path / "config.json"
+        if config_dest.exists():
+            print(f"⚠️  {config_dest} already exists. Skipping.")
+        else:
+            self._create_minimal_config(
+                config_dest,
+                workload_name=workload_name,
+                environment=environment
+            )
+            print(f"✅ Created {config_dest}")
+        
+        # Create .gitignore
+        gitignore_dest = target_path / ".gitignore"
+        if not gitignore_dest.exists():
+            gitignore_dest.write_text("cdk.out/\n*.swp\n.DS_Store\n__pycache__/\n")
+            print(f"✅ Created {gitignore_dest}")
+        
+        print("\n✨ Project initialized successfully!")
+        print(f"\nNext steps:")
+        print(f"1. cd {target_path}")
+        print(f"2. Edit config.json to configure your infrastructure")
+        print(f"3. Run: cdk synth")
+        print(f"4. Run: cdk deploy")
+    
+    def _create_minimal_config(
+        self,
+        path: Path,
+        workload_name: Optional[str] = None,
+        environment: Optional[str] = None
+    ) -> None:
+        """Create a minimal config.json template"""
+        config = {
+            "cdk": {
+                "parameters": [
+                    {
+                        "placeholder": "{{ENVIRONMENT}}",
+                        "env_var_name": "ENVIRONMENT",
+                        "cdk_parameter_name": "Environment"
+                    },
+                    {
+                        "placeholder": "{{WORKLOAD_NAME}}",
+                        "env_var_name": "WORKLOAD_NAME",
+                        "cdk_parameter_name": "WorkloadName"
+                    },
+                    {
+                        "placeholder": "{{AWS_ACCOUNT}}",
+                        "env_var_name": "AWS_ACCOUNT",
+                        "cdk_parameter_name": "AccountNumber"
+                    },
+                    {
+                        "placeholder": "{{AWS_REGION}}",
+                        "env_var_name": "AWS_REGION",
+                        "cdk_parameter_name": "AccountRegion"
+                    }
+                ]
+            },
+            "workload": {
+                "name": workload_name or "{{WORKLOAD_NAME}}",
+                "environment": environment or "{{ENVIRONMENT}}",
+                "deployments": []
+            }
+        }
+        
+        import json
+        path.write_text(json.dumps(config, indent=2))
+    
+    def list_templates(self) -> None:
+        """List available templates"""
+        print("Available templates:")
+        if self.templates_dir.exists():
+            for template in self.templates_dir.glob("*.template"):
+                print(f"  - {template.name}")
+        else:
+            print("  No templates found")
+
+
+def main():
+    """CLI entry point"""
+    parser = argparse.ArgumentParser(
+        description="CDK Factory CLI - Initialize and manage cdk-factory projects"
+    )
+    
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+    
+    # Init command
+    init_parser = subparsers.add_parser(
+        "init",
+        help="Initialize a new cdk-factory project"
+    )
+    init_parser.add_argument(
+        "directory",
+        help="Target directory (e.g., devops/cdk-iac)"
+    )
+    init_parser.add_argument(
+        "--workload-name",
+        help="Workload name"
+    )
+    init_parser.add_argument(
+        "--environment",
+        help="Environment (dev, prod, etc.)"
+    )
+    
+    # List templates command
+    subparsers.add_parser(
+        "list-templates",
+        help="List available templates"
+    )
+    
+    args = parser.parse_args()
+    
+    cli = CdkFactoryCLI()
+    
+    if args.command == "init":
+        cli.init_project(
+            args.directory,
+            workload_name=args.workload_name,
+            environment=args.environment
+        )
+    elif args.command == "list-templates":
+        cli.list_templates()
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

cdk_factory/configurations/resources/ecr.py

@@ -16,7 +16,7 @@ class ECRConfig(EnhancedBaseConfig):
     ) -> None:
         super().__init__(config, resource_type="ecr", resource_name=config.get("name", "ecr") if config else "ecr")
         self.__config = config
-        self.__deployment = config
+        self.__deployment = deployment
         self.__ssm_prefix_template = config.get("ssm_prefix_template", None)
 
     @property
@@ -74,12 +74,13 @@ class ECRConfig(EnhancedBaseConfig):
         Clear out untagged images after x days.  This helps save costs.
         Untagged images will stay forever if you don't clean them out.
         """
+        days = None
         if self.__config and isinstance(self.__config, dict):
             days = self.__config.get("auto_delete_untagged_images_in_days")
             if days:
                 days = int(days)
 
-        return None
+        return days
 
     @property
     def use_existing(self) -> bool:
@@ -118,6 +119,50 @@ class ECRConfig(EnhancedBaseConfig):
         if not value:
             raise RuntimeError("Region is not defined")
         return value
+
+    @property
+    def cross_account_access(self) -> dict:
+        """
+        Cross-account access configuration.
+        
+        Example:
+        {
+            "enabled": true,
+            "accounts": ["123456789012", "987654321098"],
+            "services": [
+                {
+                    "name": "lambda",
+                    "actions": ["ecr:BatchGetImage", "ecr:GetDownloadUrlForLayer"],
+                    "condition": {
+                        "StringLike": {
+                            "aws:sourceArn": "arn:aws:lambda:*:*:function:*"
+                        }
+                    }
+                },
+                {
+                    "name": "ecs-tasks",
+                    "service_principal": "ecs-tasks.amazonaws.com",
+                    "actions": ["ecr:BatchGetImage", "ecr:GetDownloadUrlForLayer"]
+                },
+                {
+                    "name": "codebuild",
+                    "service_principal": "codebuild.amazonaws.com",
+                    "actions": ["ecr:BatchGetImage", "ecr:GetDownloadUrlForLayer", "ecr:BatchCheckLayerAvailability"]
+                }
+            ]
+        }
+        """
+        if self.__config and isinstance(self.__config, dict):
+            return self.__config.get("cross_account_access", {})
+        return {}
+
+    @property
+    def cross_account_enabled(self) -> bool:
+        """Whether cross-account access is explicitly enabled"""
+        access_config = self.cross_account_access
+        if access_config:
+            return str(access_config.get("enabled", "true")).lower() == "true"
+        return True  # Default to enabled for backward compatibility
         
     # SSM properties are now inherited from EnhancedBaseConfig
     # Keeping these for any direct access patterns in existing code

cdk_factory/configurations/resources/ecs_service.py

@@ -0,0 +1,144 @@
+"""
+ECS Service Configuration
+Maintainers: Eric Wilson
+MIT License. See Project Root for the license information.
+"""
+
+from typing import Dict, Any, List, Optional
+
+
+class EcsServiceConfig:
+    """ECS Service Configuration"""
+
+    def __init__(self, config: Dict[str, Any]) -> None:
+        self._config = config
+
+    @property
+    def name(self) -> str:
+        """Service name"""
+        return self._config.get("name", "")
+
+    @property
+    def cluster_name(self) -> Optional[str]:
+        """ECS Cluster name"""
+        return self._config.get("cluster_name")
+
+    @property
+    def task_definition(self) -> Dict[str, Any]:
+        """Task definition configuration"""
+        return self._config.get("task_definition", {})
+
+    @property
+    def container_definitions(self) -> List[Dict[str, Any]]:
+        """Container definitions"""
+        return self.task_definition.get("containers", [])
+
+    @property
+    def cpu(self) -> str:
+        """Task CPU units"""
+        return self.task_definition.get("cpu", "256")
+
+    @property
+    def memory(self) -> str:
+        """Task memory (MB)"""
+        return self.task_definition.get("memory", "512")
+
+    @property
+    def launch_type(self) -> str:
+        """Launch type: FARGATE or EC2"""
+        return self._config.get("launch_type", "FARGATE")
+
+    @property
+    def desired_count(self) -> int:
+        """Desired number of tasks"""
+        return self._config.get("desired_count", 2)
+
+    @property
+    def min_capacity(self) -> int:
+        """Minimum number of tasks"""
+        return self._config.get("min_capacity", 1)
+
+    @property
+    def max_capacity(self) -> int:
+        """Maximum number of tasks"""
+        return self._config.get("max_capacity", 4)
+
+    @property
+    def vpc_id(self) -> Optional[str]:
+        """VPC ID"""
+        return self._config.get("vpc_id")
+
+    @property
+    def subnet_group_name(self) -> Optional[str]:
+        """Subnet group name for service placement"""
+        return self._config.get("subnet_group_name")
+
+    @property
+    def security_group_ids(self) -> List[str]:
+        """Security group IDs"""
+        return self._config.get("security_group_ids", [])
+
+    @property
+    def assign_public_ip(self) -> bool:
+        """Whether to assign public IP addresses"""
+        return self._config.get("assign_public_ip", False)
+
+    @property
+    def target_group_arns(self) -> List[str]:
+        """Target group ARNs for load balancing"""
+        return self._config.get("target_group_arns", [])
+
+    @property
+    def container_port(self) -> int:
+        """Container port for load balancer"""
+        return self._config.get("container_port", 80)
+
+    @property
+    def health_check_grace_period(self) -> int:
+        """Health check grace period in seconds"""
+        return self._config.get("health_check_grace_period", 60)
+
+    @property
+    def enable_execute_command(self) -> bool:
+        """Enable ECS Exec for debugging"""
+        return self._config.get("enable_execute_command", False)
+
+    @property
+    def enable_auto_scaling(self) -> bool:
+        """Enable auto-scaling"""
+        return self._config.get("enable_auto_scaling", True)
+
+    @property
+    def auto_scaling_target_cpu(self) -> int:
+        """Target CPU utilization percentage for auto-scaling"""
+        return self._config.get("auto_scaling_target_cpu", 70)
+
+    @property
+    def auto_scaling_target_memory(self) -> int:
+        """Target memory utilization percentage for auto-scaling"""
+        return self._config.get("auto_scaling_target_memory", 80)
+
+    @property
+    def tags(self) -> Dict[str, str]:
+        """Resource tags"""
+        return self._config.get("tags", {})
+
+    @property
+    def ssm_exports(self) -> Dict[str, str]:
+        """SSM parameter exports"""
+        return self._config.get("ssm_exports", {})
+
+    @property
+    def ssm_imports(self) -> Dict[str, str]:
+        """SSM parameter imports"""
+        return self._config.get("ssm_imports", {})
+
+    @property
+    def deployment_type(self) -> str:
+        """Deployment type: production, maintenance, or blue-green"""
+        return self._config.get("deployment_type", "production")
+
+    @property
+    def is_maintenance_mode(self) -> bool:
+        """Whether this is a maintenance mode deployment"""
+        return self.deployment_type == "maintenance"