pactown 0.1.4__py3-none-any.whl

pactown/network.py

@@ -0,0 +1,245 @@
+"""Network management for pactown - dynamic ports and service discovery."""
+
+from __future__ import annotations
+
+import socket
+import json
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+from threading import Lock
+
+
+@dataclass
+class ServiceEndpoint:
+    """Represents a running service's network endpoint."""
+    name: str
+    host: str
+    port: int
+    health_check: Optional[str] = None
+    
+    @property
+    def url(self) -> str:
+        return f"http://{self.host}:{self.port}"
+    
+    @property
+    def health_url(self) -> Optional[str]:
+        if self.health_check:
+            return f"{self.url}{self.health_check}"
+        return None
+
+
+class PortAllocator:
+    """Allocates free ports dynamically."""
+    
+    def __init__(self, start_port: int = 10000, end_port: int = 65000):
+        self.start_port = start_port
+        self.end_port = end_port
+        self._allocated: set[int] = set()
+        self._lock = Lock()
+    
+    def is_port_free(self, port: int) -> bool:
+        """Check if a port is available."""
+        if port in self._allocated:
+            return False
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                s.bind(('0.0.0.0', port))
+                return True
+        except OSError:
+            return False
+    
+    def allocate(self, preferred_port: Optional[int] = None) -> int:
+        """
+        Allocate a free port.
+        
+        If preferred_port is given and available, use it.
+        Otherwise, find the next available port.
+        """
+        with self._lock:
+            # Try preferred port first
+            if preferred_port and self.is_port_free(preferred_port):
+                self._allocated.add(preferred_port)
+                return preferred_port
+            
+            # Find next available port
+            for port in range(self.start_port, self.end_port):
+                if self.is_port_free(port):
+                    self._allocated.add(port)
+                    return port
+            
+            raise RuntimeError("No free ports available")
+    
+    def release(self, port: int) -> None:
+        """Release an allocated port."""
+        with self._lock:
+            self._allocated.discard(port)
+    
+    def release_all(self) -> None:
+        """Release all allocated ports."""
+        with self._lock:
+            self._allocated.clear()
+
+
+class ServiceRegistry:
+    """
+    Local service registry for name-based service discovery.
+    
+    Services register with their name and get assigned a port.
+    Other services can look up endpoints by name.
+    """
+    
+    def __init__(
+        self, 
+        storage_path: Optional[Path] = None,
+        host: str = "127.0.0.1",
+    ):
+        self.host = host
+        self.storage_path = storage_path or Path(".pactown-services.json")
+        self._services: dict[str, ServiceEndpoint] = {}
+        self._port_allocator = PortAllocator()
+        self._lock = Lock()
+        self._load()
+    
+    def _load(self) -> None:
+        """Load service registry from disk."""
+        if self.storage_path.exists():
+            try:
+                with open(self.storage_path) as f:
+                    data = json.load(f)
+                    for name, info in data.get("services", {}).items():
+                        self._services[name] = ServiceEndpoint(
+                            name=info["name"],
+                            host=info["host"],
+                            port=info["port"],
+                            health_check=info.get("health_check"),
+                        )
+            except (json.JSONDecodeError, KeyError):
+                pass
+    
+    def _save(self) -> None:
+        """Persist service registry to disk."""
+        data = {
+            "services": {
+                name: {
+                    "name": svc.name,
+                    "host": svc.host,
+                    "port": svc.port,
+                    "health_check": svc.health_check,
+                }
+                for name, svc in self._services.items()
+            }
+        }
+        with open(self.storage_path, "w") as f:
+            json.dump(data, f, indent=2)
+    
+    def register(
+        self,
+        name: str,
+        preferred_port: Optional[int] = None,
+        health_check: Optional[str] = None,
+    ) -> ServiceEndpoint:
+        """
+        Register a service and allocate a port.
+        
+        If preferred_port is available, use it. Otherwise, allocate dynamically.
+        """
+        with self._lock:
+            # Check if already registered
+            if name in self._services:
+                existing = self._services[name]
+                # Check if existing port is still free
+                if self._port_allocator.is_port_free(existing.port):
+                    return existing
+                # Port is taken, need to reallocate
+                self._port_allocator.release(existing.port)
+            
+            # Allocate port
+            port = self._port_allocator.allocate(preferred_port)
+            
+            endpoint = ServiceEndpoint(
+                name=name,
+                host=self.host,
+                port=port,
+                health_check=health_check,
+            )
+            
+            self._services[name] = endpoint
+            self._save()
+            
+            return endpoint
+    
+    def unregister(self, name: str) -> None:
+        """Unregister a service."""
+        with self._lock:
+            if name in self._services:
+                self._port_allocator.release(self._services[name].port)
+                del self._services[name]
+                self._save()
+    
+    def get(self, name: str) -> Optional[ServiceEndpoint]:
+        """Get service endpoint by name."""
+        return self._services.get(name)
+    
+    def get_url(self, name: str) -> Optional[str]:
+        """Get service URL by name."""
+        svc = self.get(name)
+        return svc.url if svc else None
+    
+    def list_services(self) -> list[ServiceEndpoint]:
+        """List all registered services."""
+        return list(self._services.values())
+    
+    def get_environment(self, service_name: str, dependencies: list[str]) -> dict[str, str]:
+        """
+        Get environment variables for a service.
+        
+        Injects URLs for all dependencies as environment variables.
+        """
+        env = {}
+        
+        # Add own endpoint info
+        if service_name in self._services:
+            svc = self._services[service_name]
+            env["MARKPACT_PORT"] = str(svc.port)
+            env["SERVICE_NAME"] = service_name
+            env["SERVICE_URL"] = svc.url
+        
+        # Add dependency URLs
+        for dep_name in dependencies:
+            if dep_name in self._services:
+                dep = self._services[dep_name]
+                # Multiple environment variable formats for flexibility
+                env_key = dep_name.upper().replace("-", "_").replace(".", "_")
+                env[f"{env_key}_URL"] = dep.url
+                env[f"{env_key}_HOST"] = dep.host
+                env[f"{env_key}_PORT"] = str(dep.port)
+        
+        return env
+    
+    def clear(self) -> None:
+        """Clear all registrations."""
+        with self._lock:
+            self._services.clear()
+            self._port_allocator.release_all()
+            if self.storage_path.exists():
+                self.storage_path.unlink()
+
+
+def find_free_port(start: int = 10000, end: int = 65000) -> int:
+    """Find a single free port."""
+    allocator = PortAllocator(start, end)
+    return allocator.allocate()
+
+
+def check_port(port: int) -> bool:
+    """Check if a specific port is available."""
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            s.bind(('0.0.0.0', port))
+            return True
+    except OSError:
+        return False

pactown/orchestrator.py

@@ -0,0 +1,455 @@
+"""Orchestrator for managing pactown service ecosystems."""
+
+import asyncio
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional, Callable
+import httpx
+
+from rich.console import Console
+from rich.table import Table
+from rich.live import Live
+from rich.panel import Panel
+
+from .config import EcosystemConfig, load_config
+from .resolver import DependencyResolver
+from .sandbox_manager import SandboxManager, ServiceProcess
+from .network import ServiceRegistry, ServiceEndpoint
+
+
+console = Console()
+
+
+@dataclass
+class ServiceHealth:
+    """Health status of a service."""
+    name: str
+    healthy: bool
+    status_code: Optional[int] = None
+    response_time_ms: Optional[float] = None
+    error: Optional[str] = None
+
+
+class Orchestrator:
+    """Orchestrates the lifecycle of a pactown ecosystem."""
+    
+    def __init__(
+        self,
+        config: EcosystemConfig,
+        base_path: Optional[Path] = None,
+        verbose: bool = True,
+        dynamic_ports: bool = True,
+    ):
+        self.config = config
+        self.base_path = base_path or Path.cwd()
+        self.verbose = verbose
+        self.dynamic_ports = dynamic_ports
+        self.resolver = DependencyResolver(config)
+        self.sandbox_manager = SandboxManager(config.sandbox_root)
+        self._running: dict[str, ServiceProcess] = {}
+        
+        # Service registry for dynamic port allocation and discovery
+        registry_path = Path(config.sandbox_root) / ".pactown-services.json"
+        self.service_registry = ServiceRegistry(storage_path=registry_path)
+    
+    @classmethod
+    def from_file(
+        cls, 
+        config_path: str | Path, 
+        verbose: bool = True,
+        dynamic_ports: bool = True,
+    ) -> "Orchestrator":
+        """Create orchestrator from configuration file."""
+        config_path = Path(config_path)
+        config = load_config(config_path)
+        return cls(config, base_path=config_path.parent, verbose=verbose, dynamic_ports=dynamic_ports)
+    
+    def _get_readme_path(self, service_name: str) -> Path:
+        """Get the README path for a service."""
+        service = self.config.services[service_name]
+        readme_path = self.base_path / service.readme
+        if not readme_path.exists():
+            raise FileNotFoundError(f"README not found: {readme_path}")
+        return readme_path
+    
+    def validate(self) -> bool:
+        """Validate the ecosystem configuration."""
+        issues = self.resolver.validate()
+        
+        for name, service in self.config.services.items():
+            readme_path = self.base_path / service.readme
+            if not readme_path.exists():
+                issues.append(f"README not found for '{name}': {readme_path}")
+        
+        if issues:
+            console.print("[red]Validation failed:[/red]")
+            for issue in issues:
+                console.print(f"  • {issue}")
+            return False
+        
+        console.print("[green]✓ Ecosystem configuration is valid[/green]")
+        return True
+    
+    def start_service(self, service_name: str) -> ServiceProcess:
+        """Start a single service."""
+        if service_name not in self.config.services:
+            raise ValueError(f"Unknown service: {service_name}")
+        
+        service = self.config.services[service_name]
+        readme_path = self._get_readme_path(service_name)
+        
+        # Register service and get allocated port
+        if self.dynamic_ports:
+            endpoint = self.service_registry.register(
+                name=service_name,
+                preferred_port=service.port,
+                health_check=service.health_check,
+            )
+            actual_port = endpoint.port
+            
+            if self.verbose and actual_port != service.port:
+                console.print(f"  [yellow]Port {service.port} busy, using {actual_port}[/yellow]")
+        else:
+            actual_port = service.port
+        
+        # Get dependencies from config
+        dep_names = [d.name for d in service.depends_on]
+        
+        # Build environment with service discovery
+        env = self.service_registry.get_environment(service_name, dep_names)
+        
+        # Add any extra env from config
+        env.update(service.env)
+        env["PACTOWN_ECOSYSTEM"] = self.config.name
+        
+        # Override port in service config for this run
+        service_copy = service
+        if actual_port != service.port:
+            from dataclasses import replace
+            service_copy = replace(service, port=actual_port)
+        
+        process = self.sandbox_manager.start_service(
+            service_copy, readme_path, env, verbose=self.verbose
+        )
+        self._running[service_name] = process
+        return process
+    
+    def start_all(
+        self, 
+        wait_for_health: bool = True,
+        parallel: bool = True,
+        max_workers: int = 4,
+    ) -> dict[str, ServiceProcess]:
+        """
+        Start all services in dependency order.
+        
+        Args:
+            wait_for_health: Wait for health checks
+            parallel: Use parallel execution for independent services
+            max_workers: Max parallel workers
+        """
+        if parallel:
+            return self._start_all_parallel(wait_for_health, max_workers)
+        else:
+            return self._start_all_sequential(wait_for_health)
+    
+    def _start_all_sequential(self, wait_for_health: bool = True) -> dict[str, ServiceProcess]:
+        """Start all services sequentially in dependency order."""
+        order = self.resolver.get_startup_order()
+        
+        if self.verbose:
+            console.print(f"\n[bold]Starting ecosystem: {self.config.name}[/bold]")
+            console.print(f"Startup order: {' → '.join(order)}\n")
+        
+        for name in order:
+            try:
+                self.start_service(name)
+                
+                if wait_for_health:
+                    service = self.config.services[name]
+                    if service.health_check:
+                        self._wait_for_health(name, timeout=service.timeout)
+                    else:
+                        time.sleep(1)
+                
+            except Exception as e:
+                console.print(f"[red]Failed to start {name}: {e}[/red]")
+                self.stop_all()
+                raise
+        
+        if self.verbose:
+            self.print_status()
+        
+        return self._running
+    
+    def _start_all_parallel(
+        self, 
+        wait_for_health: bool = True,
+        max_workers: int = 4,
+    ) -> dict[str, ServiceProcess]:
+        """
+        Start services in parallel waves based on dependencies.
+        
+        Services with no unmet dependencies start together in parallel.
+        Once a wave completes, the next wave starts.
+        """
+        from concurrent.futures import ThreadPoolExecutor, as_completed
+        
+        if self.verbose:
+            console.print(f"\n[bold]Starting ecosystem: {self.config.name} (parallel)[/bold]")
+        
+        # Build dependency map
+        deps_map: dict[str, list[str]] = {}
+        for name, service in self.config.services.items():
+            deps_map[name] = [d.name for d in service.depends_on if d.name in self.config.services]
+        
+        started = set()
+        remaining = set(self.config.services.keys())
+        wave_num = 0
+        
+        while remaining:
+            # Find services ready to start (all deps satisfied)
+            ready = [
+                name for name in remaining
+                if all(d in started for d in deps_map.get(name, []))
+            ]
+            
+            if not ready:
+                raise ValueError(f"Cannot resolve dependencies for: {remaining}")
+            
+            wave_num += 1
+            if self.verbose:
+                console.print(f"\n[cyan]Wave {wave_num}:[/cyan] {', '.join(ready)}")
+            
+            # Start ready services in parallel
+            wave_results = {}
+            wave_errors = {}
+            
+            with ThreadPoolExecutor(max_workers=min(max_workers, len(ready))) as executor:
+                futures = {}
+                
+                for name in ready:
+                    future = executor.submit(self._start_service_with_health, name, wait_for_health)
+                    futures[future] = name
+                
+                for future in as_completed(futures):
+                    name = futures[future]
+                    try:
+                        proc = future.result()
+                        wave_results[name] = proc
+                        self._running[name] = proc
+                        started.add(name)
+                        remaining.remove(name)
+                    except Exception as e:
+                        wave_errors[name] = str(e)
+                        remaining.remove(name)
+            
+            # Report wave results
+            for name in wave_results:
+                if self.verbose:
+                    console.print(f"  [green]✓[/green] {name} started")
+            
+            for name, error in wave_errors.items():
+                console.print(f"  [red]✗[/red] {name}: {error}")
+            
+            # Stop on any failure
+            if wave_errors:
+                console.print(f"\n[red]Stopping due to errors...[/red]")
+                self.stop_all()
+                raise RuntimeError(f"Failed to start services: {wave_errors}")
+        
+        if self.verbose:
+            console.print()
+            self.print_status()
+        
+        return self._running
+    
+    def _start_service_with_health(self, service_name: str, wait_for_health: bool) -> ServiceProcess:
+        """Start a service and optionally wait for health check."""
+        proc = self.start_service(service_name)
+        
+        if wait_for_health:
+            service = self.config.services[service_name]
+            if service.health_check:
+                self._wait_for_health(service_name, timeout=service.timeout)
+            else:
+                time.sleep(0.5)
+        
+        return proc
+    
+    def stop_service(self, service_name: str) -> bool:
+        """Stop a single service."""
+        if service_name not in self._running:
+            return False
+        
+        if self.verbose:
+            console.print(f"Stopping {service_name}...")
+        
+        success = self.sandbox_manager.stop_service(service_name)
+        if success:
+            del self._running[service_name]
+        return success
+    
+    def stop_all(self) -> None:
+        """Stop all services in reverse dependency order."""
+        order = self.resolver.get_shutdown_order()
+        
+        if self.verbose:
+            console.print(f"\n[bold]Stopping ecosystem: {self.config.name}[/bold]")
+        
+        for name in order:
+            if name in self._running:
+                self.stop_service(name)
+            # Unregister from service registry
+            self.service_registry.unregister(name)
+        
+        self.sandbox_manager.stop_all()
+        self._running.clear()
+    
+    def restart_service(self, service_name: str) -> ServiceProcess:
+        """Restart a single service."""
+        self.stop_service(service_name)
+        time.sleep(0.5)
+        return self.start_service(service_name)
+    
+    def check_health(self, service_name: str) -> ServiceHealth:
+        """Check health of a service."""
+        if service_name not in self.config.services:
+            return ServiceHealth(name=service_name, healthy=False, error="Unknown service")
+        
+        service = self.config.services[service_name]
+        
+        if service_name not in self._running:
+            return ServiceHealth(name=service_name, healthy=False, error="Not running")
+        
+        if not self._running[service_name].is_running:
+            return ServiceHealth(name=service_name, healthy=False, error="Process died")
+        
+        if not service.health_check:
+            return ServiceHealth(name=service_name, healthy=True)
+        
+        # Get actual port from registry (may differ from config if dynamic)
+        endpoint = self.service_registry.get(service_name)
+        port = endpoint.port if endpoint else service.port
+        url = f"http://localhost:{port}{service.health_check}"
+        
+        try:
+            start = time.time()
+            response = httpx.get(url, timeout=5.0)
+            elapsed = (time.time() - start) * 1000
+            
+            return ServiceHealth(
+                name=service_name,
+                healthy=response.status_code < 400,
+                status_code=response.status_code,
+                response_time_ms=elapsed,
+            )
+        except Exception as e:
+            return ServiceHealth(
+                name=service_name,
+                healthy=False,
+                error=str(e),
+            )
+    
+    def _wait_for_health(self, service_name: str, timeout: int = 60) -> bool:
+        """Wait for a service to become healthy."""
+        service = self.config.services[service_name]
+        
+        if not service.health_check:
+            return True
+        
+        # Get actual port from registry
+        endpoint = self.service_registry.get(service_name)
+        port = endpoint.port if endpoint else service.port
+        url = f"http://localhost:{port}{service.health_check}"
+        deadline = time.time() + timeout
+        
+        while time.time() < deadline:
+            try:
+                response = httpx.get(url, timeout=2.0)
+                if response.status_code < 400:
+                    if self.verbose:
+                        console.print(f"  [green]✓[/green] {service_name} is healthy")
+                    return True
+            except Exception:
+                pass
+            time.sleep(0.5)
+        
+        console.print(f"  [yellow]⚠[/yellow] {service_name} health check timed out")
+        return False
+    
+    def print_status(self) -> None:
+        """Print status of all services."""
+        table = Table(title=f"Ecosystem: {self.config.name}")
+        table.add_column("Service", style="cyan")
+        table.add_column("Port", style="blue")
+        table.add_column("Status", style="green")
+        table.add_column("PID")
+        table.add_column("Health")
+        
+        for name, service in self.config.services.items():
+            # Get actual port from registry
+            endpoint = self.service_registry.get(name)
+            actual_port = endpoint.port if endpoint else service.port
+            
+            if name in self._running:
+                proc = self._running[name]
+                running = "🟢 Running" if proc.is_running else "🔴 Stopped"
+                pid = str(proc.pid)
+                
+                health = self.check_health(name)
+                if health.healthy:
+                    health_str = f"✓ {health.response_time_ms:.0f}ms" if health.response_time_ms else "✓"
+                else:
+                    health_str = health.error or "✗"
+            else:
+                running = "⚪ Not started"
+                pid = "-"
+                health_str = "-"
+                actual_port = service.port  # Use config port if not registered
+            
+            table.add_row(
+                name,
+                str(actual_port) if actual_port else "-",
+                running,
+                pid,
+                health_str,
+            )
+        
+        console.print(table)
+    
+    def print_graph(self) -> None:
+        """Print dependency graph."""
+        console.print(Panel(self.resolver.print_graph(), title="Dependency Graph"))
+    
+    def get_logs(self, service_name: str, lines: int = 100) -> Optional[str]:
+        """Get recent logs from a service (if available)."""
+        if service_name not in self._running:
+            return None
+        
+        proc = self._running[service_name]
+        if proc.process and proc.process.stdout:
+            return proc.process.stdout.read()
+        return None
+
+
+def run_ecosystem(config_path: str | Path, wait: bool = True) -> Orchestrator:
+    """Convenience function to start an ecosystem."""
+    orch = Orchestrator.from_file(config_path)
+    
+    if not orch.validate():
+        raise ValueError("Invalid ecosystem configuration")
+    
+    orch.start_all()
+    
+    if wait:
+        try:
+            console.print("\n[dim]Press Ctrl+C to stop all services[/dim]\n")
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            console.print("\n[yellow]Shutting down...[/yellow]")
+            orch.stop_all()
+    
+    return orch