pactown 0.1.4__py3-none-any.whl

pactown/deploy/base.py

@@ -0,0 +1,263 @@
+"""Base classes for deployment backends."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Optional, Any
+
+
+class RuntimeType(Enum):
+    """Container runtime types."""
+    LOCAL = "local"          # Local process (development)
+    DOCKER = "docker"        # Docker
+    PODMAN = "podman"        # Podman (rootless containers)
+    KUBERNETES = "kubernetes"  # Kubernetes
+    COMPOSE = "compose"      # Docker Compose / Podman Compose
+
+
+class DeploymentMode(Enum):
+    """Deployment environment modes."""
+    DEVELOPMENT = "development"
+    STAGING = "staging"
+    PRODUCTION = "production"
+
+
+@dataclass
+class DeploymentConfig:
+    """Configuration for deployment."""
+    
+    # Runtime settings
+    runtime: RuntimeType = RuntimeType.LOCAL
+    mode: DeploymentMode = DeploymentMode.DEVELOPMENT
+    
+    # Container settings
+    registry: str = ""                    # Container registry URL
+    namespace: str = "default"            # K8s namespace or project name
+    image_prefix: str = "pactown"         # Image name prefix
+    
+    # Network settings
+    network_name: str = "pactown-net"     # Container network name
+    expose_ports: bool = True             # Expose ports to host
+    use_internal_dns: bool = True         # Use container DNS for service discovery
+    
+    # Security settings
+    rootless: bool = True                 # Use rootless containers (Podman)
+    read_only_fs: bool = False            # Read-only filesystem
+    no_new_privileges: bool = True        # No new privileges
+    drop_capabilities: list[str] = field(default_factory=lambda: ["ALL"])
+    add_capabilities: list[str] = field(default_factory=list)
+    
+    # Resource limits
+    memory_limit: str = "512m"            # Memory limit per service
+    cpu_limit: str = "0.5"                # CPU limit per service
+    
+    # Health check settings
+    health_check_interval: str = "30s"
+    health_check_timeout: str = "10s"
+    health_check_retries: int = 3
+    
+    # Persistence
+    volumes_path: Optional[Path] = None   # Path for persistent volumes
+    
+    # Labels and annotations
+    labels: dict[str, str] = field(default_factory=dict)
+    annotations: dict[str, str] = field(default_factory=dict)
+    
+    @classmethod
+    def for_production(cls) -> "DeploymentConfig":
+        """Create production-ready configuration."""
+        return cls(
+            mode=DeploymentMode.PRODUCTION,
+            rootless=True,
+            read_only_fs=True,
+            no_new_privileges=True,
+            drop_capabilities=["ALL"],
+            memory_limit="1g",
+            cpu_limit="1.0",
+            health_check_interval="10s",
+            health_check_retries=5,
+        )
+    
+    @classmethod
+    def for_development(cls) -> "DeploymentConfig":
+        """Create development configuration."""
+        return cls(
+            mode=DeploymentMode.DEVELOPMENT,
+            rootless=False,
+            read_only_fs=False,
+            expose_ports=True,
+        )
+
+
+@dataclass
+class DeploymentResult:
+    """Result of a deployment operation."""
+    success: bool
+    service_name: str
+    runtime: RuntimeType
+    container_id: Optional[str] = None
+    image_name: Optional[str] = None
+    endpoint: Optional[str] = None
+    error: Optional[str] = None
+    logs: Optional[str] = None
+
+
+class DeploymentBackend(ABC):
+    """Abstract base class for deployment backends."""
+    
+    def __init__(self, config: DeploymentConfig):
+        self.config = config
+    
+    @property
+    @abstractmethod
+    def runtime_type(self) -> RuntimeType:
+        """Return the runtime type."""
+        pass
+    
+    @abstractmethod
+    def is_available(self) -> bool:
+        """Check if the runtime is available."""
+        pass
+    
+    @abstractmethod
+    def build_image(
+        self,
+        service_name: str,
+        dockerfile_path: Path,
+        context_path: Path,
+        tag: Optional[str] = None,
+    ) -> DeploymentResult:
+        """Build a container image."""
+        pass
+    
+    @abstractmethod
+    def push_image(
+        self,
+        image_name: str,
+        registry: Optional[str] = None,
+    ) -> DeploymentResult:
+        """Push image to registry."""
+        pass
+    
+    @abstractmethod
+    def deploy(
+        self,
+        service_name: str,
+        image_name: str,
+        port: int,
+        env: dict[str, str],
+        health_check: Optional[str] = None,
+    ) -> DeploymentResult:
+        """Deploy a service."""
+        pass
+    
+    @abstractmethod
+    def stop(self, service_name: str) -> DeploymentResult:
+        """Stop a deployed service."""
+        pass
+    
+    @abstractmethod
+    def logs(self, service_name: str, tail: int = 100) -> str:
+        """Get logs from a service."""
+        pass
+    
+    @abstractmethod
+    def status(self, service_name: str) -> dict[str, Any]:
+        """Get status of a service."""
+        pass
+    
+    def generate_dockerfile(
+        self,
+        service_name: str,
+        sandbox_path: Path,
+        base_image: str = "python:3.12-slim",
+    ) -> Path:
+        """Generate Dockerfile for a service."""
+        dockerfile_content = self._create_dockerfile(
+            sandbox_path, base_image
+        )
+        
+        dockerfile_path = sandbox_path / "Dockerfile"
+        dockerfile_path.write_text(dockerfile_content)
+        return dockerfile_path
+    
+    def _create_dockerfile(
+        self,
+        sandbox_path: Path,
+        base_image: str,
+    ) -> str:
+        """Create Dockerfile content."""
+        # Check for requirements.txt
+        has_requirements = (sandbox_path / "requirements.txt").exists()
+        
+        # Check for package.json (Node.js)
+        has_package_json = (sandbox_path / "package.json").exists()
+        
+        if has_package_json:
+            return self._create_node_dockerfile(sandbox_path)
+        
+        # Default Python Dockerfile
+        lines = [
+            f"FROM {base_image}",
+            "",
+            "WORKDIR /app",
+            "",
+            "# Security: run as non-root user",
+            "RUN useradd -m -u 1000 appuser",
+            "",
+        ]
+        
+        if has_requirements:
+            lines.extend([
+                "# Install dependencies",
+                "COPY requirements.txt .",
+                "RUN pip install --no-cache-dir -r requirements.txt",
+                "",
+            ])
+        
+        lines.extend([
+            "# Copy application",
+            "COPY . .",
+            "",
+            "# Switch to non-root user",
+            "USER appuser",
+            "",
+            "# Health check",
+            'HEALTHCHECK --interval=30s --timeout=10s --retries=3 \\',
+            '    CMD curl -f http://localhost:${PORT:-8000}/health || exit 1',
+            "",
+            "# Default command",
+            'CMD ["python", "main.py"]',
+        ])
+        
+        return "\n".join(lines)
+    
+    def _create_node_dockerfile(self, sandbox_path: Path) -> str:
+        """Create Dockerfile for Node.js service."""
+        return """FROM node:20-slim
+
+WORKDIR /app
+
+# Security: run as non-root user
+RUN useradd -m -u 1000 appuser
+
+# Install dependencies
+COPY package*.json ./
+RUN npm ci --only=production
+
+# Copy application
+COPY . .
+
+# Switch to non-root user
+USER appuser
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --retries=3 \\
+    CMD curl -f http://localhost:${PORT:-3000}/health || exit 1
+
+# Default command
+CMD ["node", "server.js"]
+"""

pactown/deploy/compose.py

@@ -0,0 +1,359 @@
+"""Docker Compose / Podman Compose generator for multi-service deployment."""
+
+from __future__ import annotations
+
+import yaml
+from pathlib import Path
+from typing import Optional
+from dataclasses import dataclass
+
+from ..config import EcosystemConfig, ServiceConfig
+from .base import DeploymentConfig, DeploymentMode
+
+
+@dataclass
+class ComposeService:
+    """Represents a service in docker-compose.yaml."""
+    name: str
+    build_context: str
+    dockerfile: str
+    image: str
+    ports: list[str]
+    environment: dict[str, str]
+    depends_on: list[str]
+    health_check: Optional[dict] = None
+    deploy: Optional[dict] = None
+    networks: list[str] = None
+    volumes: list[str] = None
+
+
+class ComposeGenerator:
+    """
+    Generate Docker Compose / Podman Compose files for pactown ecosystems.
+    
+    Supports:
+    - Docker Compose v3.8+
+    - Podman Compose
+    - Docker Swarm mode
+    """
+    
+    def __init__(
+        self,
+        ecosystem: EcosystemConfig,
+        deploy_config: DeploymentConfig,
+        base_path: Path,
+    ):
+        self.ecosystem = ecosystem
+        self.deploy_config = deploy_config
+        self.base_path = Path(base_path)
+    
+    def generate(
+        self,
+        output_path: Optional[Path] = None,
+        include_registry: bool = False,
+    ) -> dict:
+        """
+        Generate docker-compose.yaml content.
+        
+        Args:
+            output_path: Optional path to write the file
+            include_registry: Include pactown registry service
+        
+        Returns:
+            Compose file as dict
+        """
+        compose = {
+            "version": "3.8",
+            "name": self.ecosystem.name,
+            "services": {},
+            "networks": {
+                self.deploy_config.network_name: {
+                    "driver": "bridge",
+                },
+            },
+        }
+        
+        # Add volumes section if needed
+        volumes = {}
+        
+        for name, service in self.ecosystem.services.items():
+            compose_service = self._create_service(name, service)
+            compose["services"][name] = compose_service
+            
+            # Check for volume mounts
+            if self.deploy_config.volumes_path:
+                volume_name = f"{name}-data"
+                volumes[volume_name] = {"driver": "local"}
+        
+        if volumes:
+            compose["volumes"] = volumes
+        
+        # Add registry service if requested
+        if include_registry:
+            compose["services"]["registry"] = self._create_registry_service()
+        
+        # Write to file if path provided
+        if output_path:
+            output_path = Path(output_path)
+            with open(output_path, "w") as f:
+                yaml.dump(compose, f, default_flow_style=False, sort_keys=False)
+        
+        return compose
+    
+    def _create_service(self, name: str, service: ServiceConfig) -> dict:
+        """Create compose service definition."""
+        readme_path = self.base_path / service.readme
+        sandbox_path = self.base_path / self.ecosystem.sandbox_root / name
+        
+        svc = {
+            "build": {
+                "context": str(sandbox_path),
+                "dockerfile": "Dockerfile",
+            },
+            "image": f"{self.deploy_config.image_prefix}/{name}:latest",
+            "container_name": f"{self.ecosystem.name}-{name}",
+            "restart": "unless-stopped",
+            "networks": [self.deploy_config.network_name],
+        }
+        
+        # Ports
+        if service.port and self.deploy_config.expose_ports:
+            svc["ports"] = [f"{service.port}:{service.port}"]
+        
+        # Environment
+        env = {"SERVICE_NAME": name}
+        if service.port:
+            env["MARKPACT_PORT"] = str(service.port)
+        
+        # Add dependency URLs
+        for dep in service.depends_on:
+            dep_service = self.ecosystem.services.get(dep.name)
+            if dep_service:
+                env_key = dep.name.upper().replace("-", "_")
+                # Use container DNS name
+                env[f"{env_key}_URL"] = f"http://{dep.name}:{dep_service.port}"
+        
+        env.update(service.env)
+        svc["environment"] = env
+        
+        # Dependencies
+        if service.depends_on:
+            svc["depends_on"] = {}
+            for dep in service.depends_on:
+                if dep.name in self.ecosystem.services:
+                    svc["depends_on"][dep.name] = {
+                        "condition": "service_healthy" if self.ecosystem.services[dep.name].health_check else "service_started"
+                    }
+        
+        # Health check
+        if service.health_check:
+            svc["healthcheck"] = {
+                "test": ["CMD", "curl", "-f", f"http://localhost:{service.port}{service.health_check}"],
+                "interval": self.deploy_config.health_check_interval,
+                "timeout": self.deploy_config.health_check_timeout,
+                "retries": self.deploy_config.health_check_retries,
+                "start_period": "10s",
+            }
+        
+        # Production settings
+        if self.deploy_config.mode == DeploymentMode.PRODUCTION:
+            svc["deploy"] = {
+                "resources": {
+                    "limits": {
+                        "memory": self.deploy_config.memory_limit,
+                        "cpus": self.deploy_config.cpu_limit,
+                    },
+                    "reservations": {
+                        "memory": "128M",
+                        "cpus": "0.1",
+                    },
+                },
+                "restart_policy": {
+                    "condition": "on-failure",
+                    "delay": "5s",
+                    "max_attempts": 3,
+                    "window": "120s",
+                },
+            }
+            
+            # Security options
+            svc["security_opt"] = ["no-new-privileges:true"]
+            
+            if self.deploy_config.read_only_fs:
+                svc["read_only"] = True
+                svc["tmpfs"] = ["/tmp"]
+            
+            svc["cap_drop"] = self.deploy_config.drop_capabilities
+            
+            if self.deploy_config.add_capabilities:
+                svc["cap_add"] = self.deploy_config.add_capabilities
+        
+        # Labels
+        svc["labels"] = {
+            "pactown.ecosystem": self.ecosystem.name,
+            "pactown.service": name,
+            **self.deploy_config.labels,
+        }
+        
+        return svc
+    
+    def _create_registry_service(self) -> dict:
+        """Create pactown registry service."""
+        return {
+            "image": "pactown/registry:latest",
+            "container_name": f"{self.ecosystem.name}-registry",
+            "restart": "unless-stopped",
+            "ports": ["8800:8800"],
+            "networks": [self.deploy_config.network_name],
+            "volumes": ["registry-data:/data"],
+            "environment": {
+                "REGISTRY_PORT": "8800",
+                "REGISTRY_DATA_DIR": "/data",
+            },
+            "healthcheck": {
+                "test": ["CMD", "curl", "-f", "http://localhost:8800/health"],
+                "interval": "30s",
+                "timeout": "10s",
+                "retries": 3,
+            },
+        }
+    
+    def generate_override(
+        self,
+        output_path: Optional[Path] = None,
+        dev_mode: bool = True,
+    ) -> dict:
+        """
+        Generate docker-compose.override.yaml for development.
+        
+        This file is automatically merged with docker-compose.yaml
+        and provides development-specific settings.
+        """
+        override = {
+            "version": "3.8",
+            "services": {},
+        }
+        
+        for name, service in self.ecosystem.services.items():
+            sandbox_path = self.base_path / self.ecosystem.sandbox_root / name
+            
+            svc = {}
+            
+            if dev_mode:
+                # Mount source code for hot reload
+                svc["volumes"] = [
+                    f"{sandbox_path}:/app:z",
+                ]
+                
+                # Enable debug mode
+                svc["environment"] = {
+                    "DEBUG": "true",
+                    "LOG_LEVEL": "debug",
+                }
+                
+                # Remove resource limits for development
+                svc["deploy"] = None
+            
+            if svc:
+                override["services"][name] = svc
+        
+        if output_path:
+            output_path = Path(output_path)
+            with open(output_path, "w") as f:
+                yaml.dump(override, f, default_flow_style=False, sort_keys=False)
+        
+        return override
+    
+    def generate_production(
+        self,
+        output_path: Optional[Path] = None,
+        replicas: int = 2,
+    ) -> dict:
+        """
+        Generate docker-compose.prod.yaml for production/swarm deployment.
+        """
+        compose = self.generate()
+        
+        for name in compose["services"]:
+            svc = compose["services"][name]
+            
+            # Add swarm-specific deploy config
+            svc["deploy"] = {
+                "mode": "replicated",
+                "replicas": replicas,
+                "update_config": {
+                    "parallelism": 1,
+                    "delay": "10s",
+                    "failure_action": "rollback",
+                    "order": "start-first",
+                },
+                "rollback_config": {
+                    "parallelism": 1,
+                    "delay": "10s",
+                },
+                "resources": {
+                    "limits": {
+                        "memory": self.deploy_config.memory_limit,
+                        "cpus": self.deploy_config.cpu_limit,
+                    },
+                },
+            }
+        
+        if output_path:
+            output_path = Path(output_path)
+            with open(output_path, "w") as f:
+                yaml.dump(compose, f, default_flow_style=False, sort_keys=False)
+        
+        return compose
+
+
+def generate_compose_from_config(
+    config_path: Path,
+    output_dir: Optional[Path] = None,
+    production: bool = False,
+) -> dict:
+    """
+    Convenience function to generate compose files from pactown config.
+    
+    Args:
+        config_path: Path to saas.pactown.yaml
+        output_dir: Directory to write compose files
+        production: Generate production configuration
+    
+    Returns:
+        Generated compose dict
+    """
+    from ..config import load_config
+    
+    config_path = Path(config_path)
+    ecosystem = load_config(config_path)
+    
+    deploy_config = (
+        DeploymentConfig.for_production() if production
+        else DeploymentConfig.for_development()
+    )
+    
+    generator = ComposeGenerator(
+        ecosystem=ecosystem,
+        deploy_config=deploy_config,
+        base_path=config_path.parent,
+    )
+    
+    output_dir = output_dir or config_path.parent
+    
+    # Generate main compose file
+    compose = generator.generate(
+        output_path=output_dir / "docker-compose.yaml"
+    )
+    
+    # Generate override for development
+    if not production:
+        generator.generate_override(
+            output_path=output_dir / "docker-compose.override.yaml"
+        )
+    else:
+        generator.generate_production(
+            output_path=output_dir / "docker-compose.prod.yaml"
+        )
+    
+    return compose