radix-edge 2.0.0__tar.gz

radix_edge-2.0.0/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: radix-edge
+Version: 2.0.0
+Summary: Radix Edge Agent — GPU orchestration with information-theoretic scheduling
+Requires-Python: >=3.10
+Requires-Dist: fastapi>=0.109.0
+Requires-Dist: uvicorn[standard]>=0.27.0
+Requires-Dist: pydantic>=2.5.0
+Requires-Dist: pydantic-settings>=2.1.0
+Requires-Dist: prometheus-client>=0.19.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: docker>=6.0.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: mesh
+Requires-Dist: zeroconf>=0.131.0; extra == "mesh"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
+Requires-Dist: respx>=0.21.0; extra == "dev"
+Requires-Dist: ruff>=0.3.0; extra == "dev"

radix_edge-2.0.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "radix-edge"
+version = "2.0.0"
+description = "Radix Edge Agent — GPU orchestration with information-theoretic scheduling"
+requires-python = ">=3.10"
+dependencies = [
+    "fastapi>=0.109.0",
+    "uvicorn[standard]>=0.27.0",
+    "pydantic>=2.5.0",
+    "pydantic-settings>=2.1.0",
+    "prometheus-client>=0.19.0",
+    "numpy>=1.24.0",
+    "scipy>=1.10.0",
+    "docker>=6.0.0",
+    "httpx>=0.25.0",
+    "typer>=0.9.0",
+    "rich>=13.0.0",
+]
+
+[project.optional-dependencies]
+mesh = ["zeroconf>=0.131.0"]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "pytest-cov>=5.0.0",
+    "respx>=0.21.0",
+    "ruff>=0.3.0",
+]
+
+[project.scripts]
+radix-edge = "radix_edge.cli.main:app"
+
+[tool.setuptools.packages.find]
+include = ["radix_edge*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+markers = ["gpu: GPU integration tests (require --run-gpu flag or RADIX_GPU_TESTS=1)"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py311"

radix_edge-2.0.0/radix_edge/__init__.py

@@ -0,0 +1,3 @@
+"""Radix Edge Agent — GPU orchestration with information-theoretic scheduling."""
+
+__version__ = "2.0.0"

radix_edge-2.0.0/radix_edge/__main__.py

@@ -0,0 +1,20 @@
+"""Entry point for running the edge agent server."""
+
+import uvicorn
+
+from radix_edge.config import get_config
+
+
+def main():
+    config = get_config()
+    uvicorn.run(
+        "radix_edge.api.app:create_app",
+        factory=True,
+        host=config.host,
+        port=config.port,
+        log_level=config.log_level.lower(),
+    )
+
+
+if __name__ == "__main__":
+    main()

radix_edge-2.0.0/radix_edge/api/app.py

@@ -0,0 +1,205 @@
+"""FastAPI application factory for the Radix Edge Agent."""
+
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+
+from fastapi import Depends, FastAPI
+
+from radix_edge.config import get_config
+from radix_edge.db import init_db, close_db
+from radix_edge.api.routes_health import router as health_router
+from radix_edge.api.routes_gpus import router as gpus_router
+from radix_edge.api.routes_jobs import router as jobs_router
+from radix_edge.api.routes_admin import router as admin_router
+
+logger = logging.getLogger("radix_edge")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan — startup and shutdown."""
+    config = get_config()
+    logging.basicConfig(
+        level=getattr(logging, config.log_level.upper(), logging.INFO),
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    )
+
+    logger.info("Radix Edge Agent starting")
+    logger.info("Database: %s", config.db_path)
+
+    # Initialize database
+    init_db()
+    logger.info("Database initialized (12 tables)")
+
+    # Reconcile state after restart
+    from radix_edge.recovery import reconcile_on_startup
+    recovery_summary = reconcile_on_startup()
+    logger.info("Recovery: %s", recovery_summary)
+
+    # Start GPU observer background task
+    from radix_edge.observer.gpu_observer import observer_loop
+    observer_task = asyncio.create_task(observer_loop())
+    logger.info("GPU observer started")
+
+    # Start scheduler background task
+    from radix_edge.scheduler.scheduler import scheduling_loop
+    scheduler_task = asyncio.create_task(scheduling_loop())
+    logger.info("Scheduler started")
+
+    # Start FEP controller and brain auto-tuner
+    from radix_edge.meta.fep_controller import fep_loop
+    from radix_edge.meta.brain_autotuner import autotuner_loop
+    fep_task = asyncio.create_task(fep_loop())
+    autotuner_task = asyncio.create_task(autotuner_loop())
+    logger.info("FEP controller and brain auto-tuner started")
+
+    # Start upstream control plane communication (if configured)
+    upstream_tasks = []
+    upstream_client = None
+    if config.upstream_enabled and config.api_base and config.cluster_id:
+        from radix_edge.upstream.token_manager import resolve_token
+        from radix_edge.upstream.client import UpstreamClient
+        from radix_edge.upstream.heartbeat import heartbeat_loop
+        from radix_edge.upstream.job_sync import job_sync_loop
+
+        cluster_token = await resolve_token(
+            api_base=config.api_base,
+            cluster_id=config.cluster_id,
+            tenant_id=config.tenant_id,
+            cluster_token=config.cluster_token,
+            one_time_token=config.one_time_token,
+            token_file=config.token_file,
+        )
+
+        upstream_client = UpstreamClient(
+            api_base=config.api_base,
+            cluster_id=config.cluster_id,
+            tenant_id=config.tenant_id,
+            cluster_token=cluster_token,
+        )
+
+        upstream_tasks.append(asyncio.create_task(heartbeat_loop(upstream_client)))
+        upstream_tasks.append(asyncio.create_task(job_sync_loop(upstream_client)))
+        logger.info("Upstream control plane connected (cluster=%s)", config.cluster_id)
+    else:
+        logger.info("Upstream control plane disabled")
+
+    # Start mesh networking (if configured)
+    mesh_tasks = []
+    mesh_peer_clients: dict = {}
+    mesh_discovery_inst = None
+    if config.mesh_enabled and config.mesh_key:
+        import uuid
+        from radix_edge.mesh.peer_registry import PeerRegistry
+        from radix_edge.mesh.coordinator import MeshCoordinator
+        from radix_edge.mesh.discovery import MeshDiscovery, ManualPeerList, ZEROCONF_AVAILABLE
+        from radix_edge.mesh.sync import (
+            mesh_heartbeat_loop,
+            mesh_discovery_loop,
+            election_monitor_loop,
+            coordinator_loop,
+        )
+
+        # Generate or load node_id
+        node_id = config.mesh_node_id
+        if not node_id:
+            with get_db() as db_conn:
+                row = db_conn.execute("SELECT value FROM config WHERE key = 'mesh_node_id'").fetchone()
+                if row:
+                    node_id = row["value"]
+                else:
+                    node_id = f"node-{uuid.uuid4().hex[:12]}"
+                    db_conn.execute(
+                        "INSERT INTO config (key, value) VALUES ('mesh_node_id', ?)",
+                        (node_id,),
+                    )
+
+        # Create mesh objects
+        mesh_registry = PeerRegistry(stale_threshold=config.mesh_stale_threshold)
+        mesh_coordinator = MeshCoordinator(node_id, mesh_registry)
+
+        # Discovery: prefer mDNS, fall back to manual
+        if ZEROCONF_AVAILABLE and not config.mesh_peers:
+            mesh_discovery_inst = MeshDiscovery(
+                node_id=node_id,
+                port=config.port,
+                mesh_key=config.mesh_key,
+            )
+            await mesh_discovery_inst.start()
+        else:
+            mesh_discovery_inst = ManualPeerList(config.mesh_peers)
+
+        # Store in app.state for route access
+        app.state.mesh_registry = mesh_registry
+        app.state.mesh_coordinator = mesh_coordinator
+        app.state.mesh_key = config.mesh_key
+        app.state.mesh_node_id = node_id
+
+        # Include mesh router
+        from radix_edge.mesh.routes_mesh import router as mesh_router
+        app.include_router(mesh_router)
+
+        # Start background tasks
+        mesh_tasks.append(asyncio.create_task(
+            mesh_heartbeat_loop(config, mesh_registry, mesh_peer_clients, node_id, mesh_coordinator)
+        ))
+        mesh_tasks.append(asyncio.create_task(
+            mesh_discovery_loop(config, mesh_discovery_inst, mesh_registry, mesh_peer_clients, config.mesh_key)
+        ))
+        mesh_tasks.append(asyncio.create_task(
+            election_monitor_loop(config, mesh_coordinator, mesh_registry, mesh_peer_clients)
+        ))
+        mesh_tasks.append(asyncio.create_task(
+            coordinator_loop(config, mesh_coordinator, mesh_peer_clients)
+        ))
+
+        # Run initial election
+        mesh_coordinator.elect()
+        logger.info("Mesh networking started (node=%s, peers=%d)", node_id, mesh_registry.peer_count)
+    else:
+        logger.info("Mesh networking disabled")
+
+    logger.info("Radix Edge Agent ready on %s:%d", config.host, config.port)
+
+    yield
+
+    # Shutdown
+    logger.info("Radix Edge Agent shutting down")
+    for task in (observer_task, scheduler_task, fep_task, autotuner_task, *upstream_tasks, *mesh_tasks):
+        task.cancel()
+        try:
+            await task
+        except asyncio.CancelledError:
+            pass
+    if upstream_client:
+        await upstream_client.close()
+    # Close mesh resources
+    for pc in mesh_peer_clients.values():
+        await pc.close()
+    if mesh_discovery_inst and hasattr(mesh_discovery_inst, "stop"):
+        await mesh_discovery_inst.stop()
+    close_db()
+    logger.info("Radix Edge Agent stopped")
+
+
+def create_app() -> FastAPI:
+    """Create and configure the FastAPI application."""
+    from radix_edge.api.auth import require_auth
+
+    app = FastAPI(
+        title="Radix Edge Agent",
+        description="GPU orchestration with information-theoretic scheduling",
+        version="0.1.0",
+        lifespan=lifespan,
+    )
+
+    # Health endpoints — no auth required
+    app.include_router(health_router)
+
+    # All other endpoints — require Bearer token
+    app.include_router(gpus_router, dependencies=[Depends(require_auth)])
+    app.include_router(jobs_router, dependencies=[Depends(require_auth)])
+    app.include_router(admin_router, dependencies=[Depends(require_auth)])
+
+    return app

radix_edge-2.0.0/radix_edge/api/auth.py

@@ -0,0 +1,50 @@
+"""Bearer token authentication for the edge agent API."""
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from fastapi import Depends, HTTPException, Request, status
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+
+from radix_edge.config import get_config
+
+logger = logging.getLogger("radix_edge.auth")
+
+_bearer_scheme = HTTPBearer(auto_error=False)
+
+
+async def require_auth(
+    request: Request,
+    credentials: Optional[HTTPAuthorizationCredentials] = Depends(_bearer_scheme),
+) -> str:
+    """Validate Bearer token. Returns the token string on success.
+
+    Raises 401 if:
+    - No auth token is configured (agent misconfigured)
+    - No Authorization header provided
+    - Token doesn't match configured value
+    """
+    config = get_config()
+
+    if not config.auth_token:
+        # No token configured — allow unauthenticated local access
+        logger.debug("No auth token configured; allowing local access")
+        return "local"
+
+    if credentials is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Missing authorization header",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    if credentials.credentials != config.auth_token:
+        logger.warning("Invalid auth token from %s", request.client.host if request.client else "unknown")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid authentication token",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    return credentials.credentials

radix_edge-2.0.0/radix_edge/api/routes_admin.py

@@ -0,0 +1,82 @@
+"""Admin API endpoints for configuration and quota management."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from fastapi import APIRouter
+from pydantic import BaseModel, Field
+
+from radix_edge.db import get_db
+from radix_edge.enforcer.admission import get_user_quota, set_user_quota
+from radix_edge.enforcer.fairness import get_user_usage, get_all_user_usage
+from radix_edge.models import BrainParams
+
+router = APIRouter(prefix="/v1/config", tags=["admin"])
+
+
+# --- Quota management ---
+
+class QuotaUpdateRequest(BaseModel):
+    max_concurrent_gpu_jobs: Optional[int] = Field(None, ge=1, le=100)
+    max_gpus_total: Optional[int] = Field(None, ge=1, le=256)
+    fair_share_weight: Optional[float] = Field(None, ge=0.01, le=100.0)
+
+
+@router.get("/quotas/{user_id}")
+async def get_quota(user_id: str):
+    """Get quota settings for a user."""
+    return get_user_quota(user_id)
+
+
+@router.put("/quotas/{user_id}")
+async def update_quota(user_id: str, req: QuotaUpdateRequest):
+    """Update quota settings for a user."""
+    set_user_quota(
+        user_id,
+        max_concurrent=req.max_concurrent_gpu_jobs,
+        max_gpus=req.max_gpus_total,
+        fair_share_weight=req.fair_share_weight,
+    )
+    return get_user_quota(user_id)
+
+
+@router.get("/users")
+async def list_users():
+    """List all users with quotas and usage."""
+    with get_db() as db:
+        quotas = db.execute("SELECT * FROM user_quotas ORDER BY user_id").fetchall()
+        usage = get_all_user_usage(hours=24, db_conn=db)
+        usage_map = {u["user_id"]: u for u in usage}
+
+        result = []
+        for q in quotas:
+            u = usage_map.get(q["user_id"], {"gpu_seconds": 0, "job_count": 0})
+            result.append({
+                "user_id": q["user_id"],
+                "max_concurrent_gpu_jobs": q["max_concurrent_gpu_jobs"],
+                "max_gpus_total": q["max_gpus_total"],
+                "fair_share_weight": q["fair_share_weight"],
+                "gpu_seconds_24h": u["gpu_seconds"],
+                "job_count_24h": u["job_count"],
+            })
+
+        return {"users": result}
+
+
+# --- Brain params ---
+
+@router.get("/brain")
+async def get_brain_params():
+    """Get current brain scheduling weights."""
+    with get_db() as db:
+        row = db.execute("SELECT * FROM brain_params WHERE key = 'current'").fetchone()
+        if not row:
+            return {}
+        return BrainParams.from_row(row).to_dict()
+
+
+@router.get("/usage/{user_id}")
+async def get_usage(user_id: str, hours: int = 24):
+    """Get resource usage for a user."""
+    return get_user_usage(user_id, hours=hours)

radix_edge-2.0.0/radix_edge/api/routes_gpus.py

@@ -0,0 +1,28 @@
+"""GPU state API endpoints."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException
+
+from radix_edge.db import get_db
+from radix_edge.models import GPU
+
+router = APIRouter(prefix="/v1/gpus", tags=["gpus"])
+
+
+@router.get("")
+async def list_gpus():
+    """List all detected GPUs with live state."""
+    with get_db() as db:
+        rows = db.execute("SELECT * FROM gpus ORDER BY gpu_index").fetchall()
+        return {"gpus": [GPU.from_row(r).to_dict() for r in rows]}
+
+
+@router.get("/{gpu_index}")
+async def get_gpu(gpu_index: int):
+    """Get a single GPU's state."""
+    with get_db() as db:
+        row = db.execute("SELECT * FROM gpus WHERE gpu_index = ?", (gpu_index,)).fetchone()
+        if not row:
+            raise HTTPException(status_code=404, detail=f"GPU {gpu_index} not found")
+        return GPU.from_row(row).to_dict()

radix_edge-2.0.0/radix_edge/api/routes_health.py

@@ -0,0 +1,121 @@
+"""Health, readiness, and metrics endpoints."""
+
+from fastapi import APIRouter
+from fastapi.responses import PlainTextResponse
+
+from prometheus_client import (
+    CollectorRegistry, Gauge, Counter, generate_latest,
+)
+
+from radix_edge.db import get_db
+
+router = APIRouter()
+
+# --- Prometheus metrics ---
+
+registry = CollectorRegistry()
+
+# GPU metrics
+gpu_utilization = Gauge("radix_gpu_utilization_pct", "GPU utilization %", ["gpu_index"], registry=registry)
+gpu_memory_used = Gauge("radix_gpu_memory_used_mb", "GPU memory used (MB)", ["gpu_index"], registry=registry)
+gpu_temperature = Gauge("radix_gpu_temperature_celsius", "GPU temperature (C)", ["gpu_index"], registry=registry)
+gpu_power_draw = Gauge("radix_gpu_power_draw_watts", "GPU power draw (W)", ["gpu_index"], registry=registry)
+
+# Job metrics
+jobs_total = Gauge("radix_jobs_total", "Total jobs by status", ["status"], registry=registry)
+job_queue_depth = Gauge("radix_job_queue_depth", "Number of queued jobs", registry=registry)
+
+# Scheduler metrics
+scheduler_decisions = Counter("radix_scheduler_decisions_total", "Scheduler decisions made", registry=registry)
+scheduler_exploration_ratio = Gauge("radix_scheduler_exploration_ratio", "Current exploration ratio", registry=registry)
+
+# FEP metrics
+fep_free_energy = Gauge("radix_fep_free_energy", "Current variational free energy", registry=registry)
+fep_latent_state = Gauge("radix_fep_latent_state_prob", "Latent state probability", ["state"], registry=registry)
+
+# Brain weights
+brain_weight = Gauge("radix_brain_weight", "Brain scheduling weight", ["dimension"], registry=registry)
+
+
+def _update_metrics():
+    """Update all Prometheus metrics from current database state."""
+    try:
+        with get_db() as db:
+            # GPU metrics
+            gpu_rows = db.execute("SELECT * FROM gpus").fetchall()
+            for g in gpu_rows:
+                idx = str(g["gpu_index"])
+                gpu_utilization.labels(gpu_index=idx).set(g["utilization_pct"])
+                gpu_memory_used.labels(gpu_index=idx).set(g["memory_used_mb"])
+                gpu_temperature.labels(gpu_index=idx).set(g["temperature_c"])
+                gpu_power_draw.labels(gpu_index=idx).set(g["power_draw_w"])
+
+            # Job metrics
+            status_counts = db.execute(
+                "SELECT status, COUNT(*) as c FROM jobs GROUP BY status"
+            ).fetchall()
+            for r in status_counts:
+                jobs_total.labels(status=r["status"]).set(r["c"])
+
+            queued = db.execute("SELECT COUNT(*) as c FROM jobs WHERE status = 'queued'").fetchone()
+            job_queue_depth.set(queued["c"])
+
+            # Brain weights
+            brain = db.execute("SELECT * FROM brain_params WHERE key = 'current'").fetchone()
+            if brain:
+                brain_weight.labels(dimension="queue_depth").set(brain["w_queue_depth"])
+                brain_weight.labels(dimension="gpu_saturation").set(brain["w_gpu_saturation"])
+                brain_weight.labels(dimension="node_pressure").set(brain["w_node_pressure"])
+
+            # FEP latest decision
+            fep = db.execute(
+                "SELECT * FROM fep_decisions ORDER BY decided_at DESC LIMIT 1"
+            ).fetchone()
+            if fep:
+                fep_free_energy.set(fep["free_energy"])
+                import json
+                probs = json.loads(fep["state_probs"]) if fep["state_probs"] else {}
+                for state, prob in probs.items():
+                    fep_latent_state.labels(state=state).set(prob)
+
+    except Exception:
+        pass  # Metrics endpoint should never fail
+
+    # Scheduler model metrics
+    try:
+        from radix_edge.scheduler.scheduler import get_model
+        model = get_model()
+        metrics = model.get_metrics()
+        # Counter can only go up, so use a gauge for current total
+        scheduler_exploration_ratio.set(metrics.get("exploration_ratio", 0))
+    except Exception:
+        pass
+
+
+# --- Endpoints ---
+
+@router.get("/healthz")
+async def health_check():
+    """Liveness probe."""
+    return {"status": "healthy"}
+
+
+@router.get("/readyz")
+async def readiness_check():
+    """Readiness probe — verifies database is accessible."""
+    try:
+        with get_db() as db:
+            db.execute("SELECT 1")
+        return {"status": "ready"}
+    except Exception as e:
+        return {"status": "not_ready", "error": str(e)}, 503
+
+
+@router.get("/metrics")
+async def metrics():
+    """Prometheus metrics endpoint."""
+    _update_metrics()
+    return PlainTextResponse(
+        generate_latest(registry).decode("utf-8"),
+        media_type="text/plain; version=0.0.4; charset=utf-8",
+    )