pactown 0.1.4__py3-none-any.whl

pactown/registry/server.py

@@ -0,0 +1,207 @@
+"""FastAPI server for pactown registry."""
+
+import hashlib
+from pathlib import Path
+from typing import Optional
+
+import click
+import uvicorn
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+from .models import Artifact, ArtifactVersion, RegistryStorage
+
+
+class PublishRequest(BaseModel):
+    name: str
+    version: str
+    readme_content: str
+    namespace: str = "default"
+    description: str = ""
+    tags: list[str] = []
+    metadata: dict = {}
+
+
+class PublishResponse(BaseModel):
+    success: bool
+    artifact: str
+    version: str
+    checksum: str
+
+
+class ArtifactInfo(BaseModel):
+    name: str
+    namespace: str
+    description: str
+    latest_version: Optional[str]
+    versions: list[str]
+    tags: list[str]
+
+
+class VersionInfo(BaseModel):
+    version: str
+    readme_content: str
+    checksum: str
+    published_at: str
+    metadata: dict
+
+
+def create_app(storage_path: str = "./.pactown-registry") -> FastAPI:
+    """Create the registry FastAPI application."""
+    
+    app = FastAPI(
+        title="Pactown Registry",
+        description="Local artifact registry for markpact modules",
+        version="0.1.0",
+    )
+    
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    
+    storage = RegistryStorage(Path(storage_path))
+    
+    @app.get("/health")
+    def health():
+        return {"status": "ok", "service": "pactown-registry"}
+    
+    @app.get("/v1/artifacts", response_model=list[ArtifactInfo])
+    def list_artifacts(
+        namespace: Optional[str] = Query(None, description="Filter by namespace"),
+        search: Optional[str] = Query(None, description="Search query"),
+    ):
+        if search:
+            artifacts = storage.search(search)
+        else:
+            artifacts = storage.list(namespace)
+        
+        return [
+            ArtifactInfo(
+                name=a.name,
+                namespace=a.namespace,
+                description=a.description,
+                latest_version=a.latest_version,
+                versions=list(a.versions.keys()),
+                tags=a.tags,
+            )
+            for a in artifacts
+        ]
+    
+    @app.get("/v1/artifacts/{namespace}/{name}", response_model=ArtifactInfo)
+    def get_artifact(namespace: str, name: str):
+        artifact = storage.get(namespace, name)
+        if not artifact:
+            raise HTTPException(status_code=404, detail="Artifact not found")
+        
+        return ArtifactInfo(
+            name=artifact.name,
+            namespace=artifact.namespace,
+            description=artifact.description,
+            latest_version=artifact.latest_version,
+            versions=list(artifact.versions.keys()),
+            tags=artifact.tags,
+        )
+    
+    @app.get("/v1/artifacts/{namespace}/{name}/{version}", response_model=VersionInfo)
+    def get_version(namespace: str, name: str, version: str):
+        artifact = storage.get(namespace, name)
+        if not artifact:
+            raise HTTPException(status_code=404, detail="Artifact not found")
+        
+        ver = artifact.get_version(version)
+        if not ver:
+            raise HTTPException(status_code=404, detail="Version not found")
+        
+        return VersionInfo(
+            version=ver.version,
+            readme_content=ver.readme_content,
+            checksum=ver.checksum,
+            published_at=ver.published_at.isoformat(),
+            metadata=ver.metadata,
+        )
+    
+    @app.get("/v1/artifacts/{namespace}/{name}/{version}/readme")
+    def get_readme(namespace: str, name: str, version: str):
+        artifact = storage.get(namespace, name)
+        if not artifact:
+            raise HTTPException(status_code=404, detail="Artifact not found")
+        
+        ver = artifact.get_version(version)
+        if not ver:
+            raise HTTPException(status_code=404, detail="Version not found")
+        
+        return {"content": ver.readme_content}
+    
+    @app.post("/v1/publish", response_model=PublishResponse)
+    def publish(req: PublishRequest):
+        checksum = hashlib.sha256(req.readme_content.encode()).hexdigest()
+        
+        artifact = storage.get(req.namespace, req.name)
+        if not artifact:
+            artifact = Artifact(
+                name=req.name,
+                namespace=req.namespace,
+                description=req.description,
+                tags=req.tags,
+            )
+        
+        version = ArtifactVersion(
+            version=req.version,
+            readme_content=req.readme_content,
+            checksum=checksum,
+            metadata=req.metadata,
+        )
+        
+        artifact.add_version(version)
+        if req.description:
+            artifact.description = req.description
+        if req.tags:
+            artifact.tags = list(set(artifact.tags + req.tags))
+        
+        storage.save_artifact(artifact)
+        
+        return PublishResponse(
+            success=True,
+            artifact=artifact.full_name,
+            version=req.version,
+            checksum=checksum,
+        )
+    
+    @app.delete("/v1/artifacts/{namespace}/{name}")
+    def delete_artifact(namespace: str, name: str):
+        if storage.delete(namespace, name):
+            return {"success": True, "message": f"Deleted {namespace}/{name}"}
+        raise HTTPException(status_code=404, detail="Artifact not found")
+    
+    @app.get("/v1/namespaces")
+    def list_namespaces():
+        namespaces = set(a.namespace for a in storage.list())
+        return {"namespaces": sorted(namespaces)}
+    
+    return app
+
+
+@click.command()
+@click.option("--host", default="0.0.0.0", help="Host to bind to")
+@click.option("--port", default=8800, help="Port to bind to")
+@click.option("--storage", default="./.pactown-registry", help="Storage path")
+@click.option("--reload", is_flag=True, help="Enable auto-reload")
+def main(host: str, port: int, storage: str, reload: bool):
+    """Start the pactown registry server."""
+    app = create_app(storage)
+    uvicorn.run(
+        "pactown.registry.server:create_app",
+        host=host,
+        port=port,
+        reload=reload,
+        factory=True,
+    )
+
+
+if __name__ == "__main__":
+    main()

pactown/resolver.py

@@ -0,0 +1,160 @@
+"""Dependency resolver for pactown ecosystems."""
+
+from dataclasses import dataclass
+from typing import Optional
+from collections import deque
+
+from .config import EcosystemConfig, ServiceConfig
+
+
+@dataclass
+class ResolvedDependency:
+    """A resolved dependency with endpoint information."""
+    name: str
+    version: str
+    endpoint: str
+    env_var: str
+    service: Optional[ServiceConfig] = None
+
+
+class DependencyResolver:
+    """Resolves dependencies between services in an ecosystem."""
+    
+    def __init__(self, config: EcosystemConfig):
+        self.config = config
+        self._graph: dict[str, list[str]] = {}
+        self._build_graph()
+    
+    def _build_graph(self) -> None:
+        """Build dependency graph from configuration."""
+        for name, service in self.config.services.items():
+            self._graph[name] = []
+            for dep in service.depends_on:
+                if dep.name in self.config.services:
+                    self._graph[name].append(dep.name)
+    
+    def get_startup_order(self) -> list[str]:
+        """
+        Get services in topological order for startup.
+        Services with no dependencies start first.
+        """
+        # in_degree[X] = number of dependencies X has
+        in_degree = {name: len(deps) for name, deps in self._graph.items()}
+        
+        # Start with services that have no dependencies
+        queue = deque([name for name, degree in in_degree.items() if degree == 0])
+        order = []
+        
+        while queue:
+            current = queue.popleft()
+            order.append(current)
+            
+            # For each service that depends on current, decrease its in_degree
+            for name, deps in self._graph.items():
+                if current in deps:
+                    in_degree[name] -= 1
+                    if in_degree[name] == 0:
+                        queue.append(name)
+        
+        if len(order) != len(self._graph):
+            missing = set(self._graph.keys()) - set(order)
+            raise ValueError(f"Circular dependency detected involving: {missing}")
+        
+        return order
+    
+    def get_shutdown_order(self) -> list[str]:
+        """Get services in reverse order for shutdown."""
+        return list(reversed(self.get_startup_order()))
+    
+    def resolve_service_deps(self, service_name: str) -> list[ResolvedDependency]:
+        """Resolve all dependencies for a service."""
+        if service_name not in self.config.services:
+            raise ValueError(f"Unknown service: {service_name}")
+        
+        service = self.config.services[service_name]
+        resolved = []
+        
+        for dep in service.depends_on:
+            if dep.name in self.config.services:
+                dep_service = self.config.services[dep.name]
+                endpoint = dep.endpoint or f"http://localhost:{dep_service.port}"
+                env_var = dep.env_var or f"{dep.name.upper().replace('-', '_')}_URL"
+                
+                resolved.append(ResolvedDependency(
+                    name=dep.name,
+                    version=dep.version,
+                    endpoint=endpoint,
+                    env_var=env_var,
+                    service=dep_service,
+                ))
+            else:
+                endpoint = dep.endpoint or f"http://localhost:8800/v1/{dep.name}"
+                env_var = dep.env_var or f"{dep.name.upper().replace('-', '_')}_URL"
+                
+                resolved.append(ResolvedDependency(
+                    name=dep.name,
+                    version=dep.version,
+                    endpoint=endpoint,
+                    env_var=env_var,
+                ))
+        
+        return resolved
+    
+    def get_environment(self, service_name: str) -> dict[str, str]:
+        """Get environment variables for a service including dependency endpoints."""
+        if service_name not in self.config.services:
+            raise ValueError(f"Unknown service: {service_name}")
+        
+        service = self.config.services[service_name]
+        env = dict(service.env)
+        
+        for dep in self.resolve_service_deps(service_name):
+            env[dep.env_var] = dep.endpoint
+        
+        env["PACTOWN_SERVICE_NAME"] = service_name
+        env["PACTOWN_ECOSYSTEM"] = self.config.name
+        if service.port:
+            env["MARKPACT_PORT"] = str(service.port)
+        
+        return env
+    
+    def validate(self) -> list[str]:
+        """Validate the dependency graph and return any issues."""
+        issues = []
+        
+        try:
+            self.get_startup_order()
+        except ValueError as e:
+            issues.append(str(e))
+        
+        for name, service in self.config.services.items():
+            for dep in service.depends_on:
+                if dep.name not in self.config.services:
+                    if dep.registry == "local":
+                        issues.append(
+                            f"Service '{name}' depends on '{dep.name}' which is not "
+                            f"defined locally and no registry is configured"
+                        )
+        
+        return issues
+    
+    def print_graph(self) -> str:
+        """Return ASCII representation of dependency graph."""
+        lines = [f"Ecosystem: {self.config.name}", ""]
+        
+        try:
+            order = self.get_startup_order()
+        except ValueError:
+            order = list(self._graph.keys())
+        
+        for name in order:
+            service = self.config.services[name]
+            deps = [d.name for d in service.depends_on]
+            port = f":{service.port}" if service.port else ""
+            
+            if deps:
+                lines.append(f"  [{name}{port}] → {', '.join(deps)}")
+            else:
+                lines.append(f"  [{name}{port}] (no deps)")
+        
+        return "\n".join(lines)

pactown/sandbox_manager.py

@@ -0,0 +1,328 @@
+"""Sandbox manager for pactown services."""
+
+import os
+import shutil
+import subprocess
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional, Any, Callable
+import signal
+import time
+from threading import Lock
+
+from markpact import Sandbox, parse_blocks, run_cmd, ensure_venv
+from markpact.runner import install_deps
+
+from .config import ServiceConfig
+
+
+@dataclass
+class ServiceProcess:
+    """Represents a running service process."""
+    name: str
+    pid: int
+    port: Optional[int]
+    sandbox_path: Path
+    process: Optional[subprocess.Popen] = None
+    started_at: float = field(default_factory=time.time)
+    
+    @property
+    def is_running(self) -> bool:
+        if self.process:
+            return self.process.poll() is None
+        try:
+            os.kill(self.pid, 0)
+            return True
+        except OSError:
+            return False
+
+
+class SandboxManager:
+    """Manages sandboxes for multiple services."""
+    
+    def __init__(self, sandbox_root: str | Path):
+        self.sandbox_root = Path(sandbox_root)
+        self.sandbox_root.mkdir(parents=True, exist_ok=True)
+        self._processes: dict[str, ServiceProcess] = {}
+    
+    def get_sandbox_path(self, service_name: str) -> Path:
+        """Get sandbox path for a service."""
+        return self.sandbox_root / service_name
+    
+    def create_sandbox(self, service: ServiceConfig, readme_path: Path) -> Sandbox:
+        """Create a sandbox for a service from its README."""
+        sandbox_path = self.get_sandbox_path(service.name)
+        
+        if sandbox_path.exists():
+            shutil.rmtree(sandbox_path)
+        sandbox_path.mkdir(parents=True)
+        
+        sandbox = Sandbox(sandbox_path)
+        
+        readme_content = readme_path.read_text()
+        blocks = parse_blocks(readme_content)
+        
+        deps = []
+        run_command = None
+        
+        for block in blocks:
+            if block.kind == "deps":
+                deps.extend(block.body.strip().split("\n"))
+            elif block.kind == "file":
+                file_path = block.get_path() or "main.py"
+                sandbox.write_file(file_path, block.body)
+            elif block.kind == "run":
+                run_command = block.body.strip()
+        
+        if deps:
+            ensure_venv(sandbox, verbose=False)
+            install_deps([d for d in deps if d.strip()], sandbox, verbose=False)
+        
+        return sandbox
+    
+    def start_service(
+        self,
+        service: ServiceConfig,
+        readme_path: Path,
+        env: dict[str, str],
+        verbose: bool = True,
+    ) -> ServiceProcess:
+        """Start a service in its sandbox."""
+        if service.name in self._processes:
+            existing = self._processes[service.name]
+            if existing.is_running:
+                raise RuntimeError(f"Service {service.name} is already running")
+        
+        sandbox = self.create_sandbox(service, readme_path)
+        
+        readme_content = readme_path.read_text()
+        blocks = parse_blocks(readme_content)
+        
+        run_command = None
+        for block in blocks:
+            if block.kind == "run":
+                run_command = block.body.strip()
+                break
+        
+        if not run_command:
+            raise ValueError(f"No run command found in {readme_path}")
+        
+        full_env = os.environ.copy()
+        full_env.update(env)
+        
+        if sandbox.has_venv:
+            venv_bin = str(sandbox.venv_bin)
+            full_env["PATH"] = f"{venv_bin}:{full_env.get('PATH', '')}"
+            full_env["VIRTUAL_ENV"] = str(sandbox.path / ".venv")
+        
+        if verbose:
+            print(f"Starting {service.name} on port {service.port}...")
+        
+        process = subprocess.Popen(
+            run_command,
+            shell=True,
+            cwd=str(sandbox.path),
+            env=full_env,
+            stdout=subprocess.PIPE if not verbose else None,
+            stderr=subprocess.PIPE if not verbose else None,
+            preexec_fn=os.setsid,
+        )
+        
+        svc_process = ServiceProcess(
+            name=service.name,
+            pid=process.pid,
+            port=service.port,
+            sandbox_path=sandbox.path,
+            process=process,
+        )
+        
+        self._processes[service.name] = svc_process
+        return svc_process
+    
+    def stop_service(self, service_name: str, timeout: int = 10) -> bool:
+        """Stop a running service."""
+        if service_name not in self._processes:
+            return False
+        
+        svc = self._processes[service_name]
+        
+        if not svc.is_running:
+            del self._processes[service_name]
+            return True
+        
+        try:
+            os.killpg(os.getpgid(svc.pid), signal.SIGTERM)
+        except ProcessLookupError:
+            del self._processes[service_name]
+            return True
+        
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            if not svc.is_running:
+                break
+            time.sleep(0.1)
+        
+        if svc.is_running:
+            try:
+                os.killpg(os.getpgid(svc.pid), signal.SIGKILL)
+            except ProcessLookupError:
+                pass
+        
+        del self._processes[service_name]
+        return True
+    
+    def stop_all(self, timeout: int = 10) -> None:
+        """Stop all running services."""
+        for name in list(self._processes.keys()):
+            self.stop_service(name, timeout)
+    
+    def get_status(self, service_name: str) -> Optional[dict]:
+        """Get status of a service."""
+        if service_name not in self._processes:
+            return None
+        
+        svc = self._processes[service_name]
+        return {
+            "name": svc.name,
+            "pid": svc.pid,
+            "port": svc.port,
+            "running": svc.is_running,
+            "uptime": time.time() - svc.started_at,
+            "sandbox": str(svc.sandbox_path),
+        }
+    
+    def get_all_status(self) -> list[dict]:
+        """Get status of all services."""
+        return [
+            self.get_status(name)
+            for name in self._processes
+            if self.get_status(name)
+        ]
+    
+    def clean_sandbox(self, service_name: str) -> None:
+        """Remove sandbox directory for a service."""
+        sandbox_path = self.get_sandbox_path(service_name)
+        if sandbox_path.exists():
+            shutil.rmtree(sandbox_path)
+    
+    def clean_all(self) -> None:
+        """Remove all sandbox directories."""
+        if self.sandbox_root.exists():
+            shutil.rmtree(self.sandbox_root)
+        self.sandbox_root.mkdir(parents=True)
+    
+    def create_sandboxes_parallel(
+        self,
+        services: list[tuple[ServiceConfig, Path]],
+        max_workers: int = 4,
+        on_complete: Optional[Callable[[str, bool, float], None]] = None,
+    ) -> dict[str, Sandbox]:
+        """
+        Create sandboxes for multiple services in parallel.
+        
+        Args:
+            services: List of (ServiceConfig, readme_path) tuples
+            max_workers: Maximum parallel workers
+            on_complete: Callback(name, success, duration)
+        
+        Returns:
+            Dict of {service_name: Sandbox}
+        """
+        results: dict[str, Sandbox] = {}
+        errors: dict[str, str] = {}
+        lock = Lock()
+        
+        def create_one(service: ServiceConfig, readme_path: Path) -> tuple[str, Sandbox]:
+            sandbox = self.create_sandbox(service, readme_path)
+            return service.name, sandbox
+        
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = {}
+            start_times = {}
+            
+            for service, readme_path in services:
+                start_times[service.name] = time.time()
+                future = executor.submit(create_one, service, readme_path)
+                futures[future] = service.name
+            
+            for future in as_completed(futures):
+                name = futures[future]
+                duration = time.time() - start_times[name]
+                
+                try:
+                    _, sandbox = future.result()
+                    with lock:
+                        results[name] = sandbox
+                    if on_complete:
+                        on_complete(name, True, duration)
+                except Exception as e:
+                    with lock:
+                        errors[name] = str(e)
+                    if on_complete:
+                        on_complete(name, False, duration)
+        
+        if errors:
+            error_msg = "; ".join(f"{k}: {v}" for k, v in errors.items())
+            raise RuntimeError(f"Failed to create sandboxes: {error_msg}")
+        
+        return results
+    
+    def start_services_parallel(
+        self,
+        services: list[tuple[ServiceConfig, Path, dict[str, str]]],
+        max_workers: int = 4,
+        on_complete: Optional[Callable[[str, bool, float], None]] = None,
+    ) -> dict[str, ServiceProcess]:
+        """
+        Start multiple services in parallel.
+        
+        Note: Should only be used for services with no inter-dependencies.
+        For dependent services, use the orchestrator's wave-based approach.
+        
+        Args:
+            services: List of (ServiceConfig, readme_path, env) tuples
+            max_workers: Maximum parallel workers
+            on_complete: Callback(name, success, duration)
+        
+        Returns:
+            Dict of {service_name: ServiceProcess}
+        """
+        results: dict[str, ServiceProcess] = {}
+        errors: dict[str, str] = {}
+        lock = Lock()
+        
+        def start_one(
+            service: ServiceConfig, 
+            readme_path: Path, 
+            env: dict[str, str]
+        ) -> tuple[str, ServiceProcess]:
+            proc = self.start_service(service, readme_path, env, verbose=False)
+            return service.name, proc
+        
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = {}
+            start_times = {}
+            
+            for service, readme_path, env in services:
+                start_times[service.name] = time.time()
+                future = executor.submit(start_one, service, readme_path, env)
+                futures[future] = service.name
+            
+            for future in as_completed(futures):
+                name = futures[future]
+                duration = time.time() - start_times[name]
+                
+                try:
+                    _, proc = future.result()
+                    with lock:
+                        results[name] = proc
+                    if on_complete:
+                        on_complete(name, True, duration)
+                except Exception as e:
+                    with lock:
+                        errors[name] = str(e)
+                    if on_complete:
+                        on_complete(name, False, duration)
+        
+        return results, errors