pactown 0.1.4__py3-none-any.whl → 0.1.47__py3-none-any.whl

pactown/config.py

@@ -2,7 +2,8 @@
 
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Optional, Any
+from typing import Optional
+
 import yaml
 
 
@@ -14,7 +15,7 @@ class DependencyConfig:
     registry: str = "local"
     endpoint: Optional[str] = None
     env_var: Optional[str] = None
-    
+
     @classmethod
     def from_dict(cls, data: dict | str) -> "DependencyConfig":
         if isinstance(data, str):
@@ -38,13 +39,13 @@ class ServiceConfig:
     sandbox_path: Optional[str] = None
     auto_restart: bool = True
     timeout: int = 60
-    
+
     @classmethod
     def from_dict(cls, name: str, data: dict) -> "ServiceConfig":
         deps = []
         for dep in data.get("depends_on", []):
             deps.append(DependencyConfig.from_dict(dep))
-        
+
         return cls(
             name=name,
             readme=data.get("readme", f"{name}/README.md"),
@@ -78,32 +79,32 @@ class EcosystemConfig:
     base_port: int = 8000
     sandbox_root: str = "./.pactown-sandboxes"
     network: str = "pactown-net"
-    
+
     @classmethod
     def from_yaml(cls, path: Path) -> "EcosystemConfig":
         """Load ecosystem configuration from YAML file."""
         with open(path) as f:
             data = yaml.safe_load(f)
         return cls.from_dict(data, base_path=path.parent)
-    
+
     @classmethod
     def from_dict(cls, data: dict, base_path: Optional[Path] = None) -> "EcosystemConfig":
         """Create configuration from dictionary."""
         services = {}
         base_port = data.get("base_port", 8000)
-        
+
         for i, (name, svc_data) in enumerate(data.get("services", {}).items()):
             if svc_data.get("port") is None:
                 svc_data["port"] = base_port + i
             services[name] = ServiceConfig.from_dict(name, svc_data)
-        
+
         registry_data = data.get("registry", {})
         registry = RegistryConfig(
             url=registry_data.get("url", "http://localhost:8800"),
             auth_token=registry_data.get("auth_token"),
             namespace=registry_data.get("namespace", "default"),
         )
-        
+
         return cls(
             name=data.get("name", "unnamed-ecosystem"),
             version=data.get("version", "0.1.0"),
@@ -114,7 +115,7 @@ class EcosystemConfig:
             sandbox_root=data.get("sandbox_root", "./.pactown-sandboxes"),
             network=data.get("network", "pactown-net"),
         )
-    
+
     def to_dict(self) -> dict:
         """Convert configuration to dictionary."""
         return {
@@ -143,7 +144,7 @@ class EcosystemConfig:
                 for name, svc in self.services.items()
             },
         }
-    
+
     def to_yaml(self, path: Path) -> None:
         """Save configuration to YAML file."""
         with open(path, "w") as f:

pactown/deploy/__init__.py

@@ -1,10 +1,18 @@
-"""Deployment backends for pactown - Docker, Podman, Kubernetes, etc."""
+"""Deployment backends for pactown - Docker, Podman, Kubernetes, Quadlet, etc."""
 
 from .base import DeploymentBackend, DeploymentConfig, DeploymentResult
+from .compose import ComposeGenerator
 from .docker import DockerBackend
-from .podman import PodmanBackend
 from .kubernetes import KubernetesBackend
-from .compose import ComposeGenerator
+from .podman import PodmanBackend
+from .quadlet import (
+    QuadletBackend,
+    QuadletConfig,
+    QuadletTemplates,
+    QuadletUnit,
+    generate_markdown_service_quadlet,
+    generate_traefik_quadlet,
+)
 
 __all__ = [
     "DeploymentBackend",
@@ -14,4 +22,10 @@ __all__ = [
     "PodmanBackend",
     "KubernetesBackend",
     "ComposeGenerator",
+    "QuadletBackend",
+    "QuadletConfig",
+    "QuadletTemplates",
+    "QuadletUnit",
+    "generate_traefik_quadlet",
+    "generate_markdown_service_quadlet",
 ]

pactown/deploy/base.py

@@ -6,7 +6,7 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
-from typing import Optional, Any
+from typing import Any, Optional
 
 
 class RuntimeType(Enum):
@@ -28,44 +28,44 @@ class DeploymentMode(Enum):
 @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."""
@@ -80,7 +80,7 @@ class DeploymentConfig:
             health_check_interval="10s",
             health_check_retries=5,
         )
-    
+
     @classmethod
     def for_development(cls) -> "DeploymentConfig":
         """Create development configuration."""
@@ -107,21 +107,21 @@ class DeploymentResult:
 
 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,
@@ -132,7 +132,7 @@ class DeploymentBackend(ABC):
     ) -> DeploymentResult:
         """Build a container image."""
         pass
-    
+
     @abstractmethod
     def push_image(
         self,
@@ -141,7 +141,7 @@ class DeploymentBackend(ABC):
     ) -> DeploymentResult:
         """Push image to registry."""
         pass
-    
+
     @abstractmethod
     def deploy(
         self,
@@ -153,22 +153,22 @@ class DeploymentBackend(ABC):
     ) -> 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,
@@ -179,11 +179,11 @@ class DeploymentBackend(ABC):
         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,
@@ -192,13 +192,13 @@ class DeploymentBackend(ABC):
         """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}",
@@ -209,7 +209,7 @@ class DeploymentBackend(ABC):
             "RUN useradd -m -u 1000 appuser",
             "",
         ]
-        
+
         if has_requirements:
             lines.extend([
                 "# Install dependencies",
@@ -217,7 +217,7 @@ class DeploymentBackend(ABC):
                 "RUN pip install --no-cache-dir -r requirements.txt",
                 "",
             ])
-        
+
         lines.extend([
             "# Copy application",
             "COPY . .",
@@ -227,14 +227,16 @@ class DeploymentBackend(ABC):
             "",
             "# Health check",
             'HEALTHCHECK --interval=30s --timeout=10s --retries=3 \\',
-            '    CMD curl -f http://localhost:${PORT:-8000}/health || exit 1',
+            '    CMD python -c "import os,urllib.request; ' +
+            "port=os.environ.get('MARKPACT_PORT') or os.environ.get('PORT','8000'); " +
+            "urllib.request.urlopen('http://localhost:%s/health' % port, timeout=5)\"",
             "",
             "# 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
@@ -246,7 +248,7 @@ RUN useradd -m -u 1000 appuser
 
 # Install dependencies
 COPY package*.json ./
-RUN npm ci --only=production
+RUN if [ -f package-lock.json ]; then npm ci --only=production; else npm install --only=production; fi
 
 # Copy application
 COPY . .
@@ -256,7 +258,7 @@ USER appuser
 
 # Health check
 HEALTHCHECK --interval=30s --timeout=10s --retries=3 \\
-    CMD curl -f http://localhost:${PORT:-3000}/health || exit 1
+    CMD node -e "require('http').get('http://localhost:'+(process.env.MARKPACT_PORT||3000)+'/health',res=>process.exit(res.statusCode===200?0:1)).on('error',()=>process.exit(1));"
 
 # Default command
 CMD ["node", "server.js"]

pactown/deploy/compose.py

@@ -2,10 +2,11 @@
 
 from __future__ import annotations
 
-import yaml
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional
-from dataclasses import dataclass
+
+import yaml
 
 from ..config import EcosystemConfig, ServiceConfig
 from .base import DeploymentConfig, DeploymentMode
@@ -30,13 +31,13 @@ class ComposeService:
 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,
@@ -46,7 +47,7 @@ class ComposeGenerator:
         self.ecosystem = ecosystem
         self.deploy_config = deploy_config
         self.base_path = Path(base_path)
-    
+
     def generate(
         self,
         output_path: Optional[Path] = None,
@@ -54,11 +55,11 @@ class ComposeGenerator:
     ) -> 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
         """
@@ -72,39 +73,39 @@ class ComposeGenerator:
                 },
             },
         }
-        
+
         # 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
+        self.base_path / service.readme
         sandbox_path = self.base_path / self.ecosystem.sandbox_root / name
-        
+
         svc = {
             "build": {
                 "context": str(sandbox_path),
@@ -115,16 +116,16 @@ class ComposeGenerator:
             "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)
@@ -132,19 +133,19 @@ class ComposeGenerator:
                 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"
-                    }
-        
+                    dep_svc = self.ecosystem.services[dep.name]
+                    condition = "service_healthy" if dep_svc.health_check else "service_started"
+                    svc["depends_on"][dep.name] = {"condition": condition}
+
         # Health check
         if service.health_check:
             svc["healthcheck"] = {
@@ -154,7 +155,7 @@ class ComposeGenerator:
                 "retries": self.deploy_config.health_check_retries,
                 "start_period": "10s",
             }
-        
+
         # Production settings
         if self.deploy_config.mode == DeploymentMode.PRODUCTION:
             svc["deploy"] = {
@@ -175,28 +176,28 @@ class ComposeGenerator:
                     "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 {
@@ -217,7 +218,7 @@ class ComposeGenerator:
                 "retries": 3,
             },
         }
-    
+
     def generate_override(
         self,
         output_path: Optional[Path] = None,
@@ -225,7 +226,7 @@ class ComposeGenerator:
     ) -> dict:
         """
         Generate docker-compose.override.yaml for development.
-        
+
         This file is automatically merged with docker-compose.yaml
         and provides development-specific settings.
         """
@@ -233,37 +234,37 @@ class ComposeGenerator:
             "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,
@@ -273,10 +274,10 @@ class ComposeGenerator:
         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",
@@ -298,12 +299,12 @@ class ComposeGenerator:
                     },
                 },
             }
-        
+
         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
 
 
@@ -314,38 +315,38 @@ def generate_compose_from_config(
 ) -> 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(
@@ -355,5 +356,5 @@ def generate_compose_from_config(
         generator.generate_production(
             output_path=output_dir / "docker-compose.prod.yaml"
         )
-    
+
     return compose