Paul Payne
08c6f3fa83
- Introduced category tools support in the `castle create` command. - Added detailed guides for creating components in CLAUDE.md. - Implemented new API endpoints for listing and retrieving tool details. - Updated component and tool models to include additional metadata. - Improved error handling and response structures in service actions. - Enhanced documentation for component registry and web APIs.
131 lines
4.2 KiB
Python
131 lines
4.2 KiB
Python
"""Service management — start/stop/restart systemd-managed components."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import time
|
|
|
|
from fastapi import APIRouter, HTTPException, status
|
|
from starlette.responses import JSONResponse
|
|
|
|
from castle_cli.config import load_config
|
|
|
|
from dashboard_api.config import settings
|
|
from dashboard_api.health import check_all_health
|
|
from dashboard_api.models import HealthStatus
|
|
from dashboard_api.stream import broadcast
|
|
|
|
router = APIRouter(prefix="/services", tags=["services"])
|
|
|
|
UNIT_PREFIX = "castle-"
|
|
SELF_NAME = "dashboard-api"
|
|
|
|
|
|
async def _systemctl(action: str, unit: str) -> tuple[bool, str]:
|
|
"""Run a systemctl --user command. Returns (success, output)."""
|
|
proc = await asyncio.create_subprocess_exec(
|
|
"systemctl", "--user", action, unit,
|
|
stdout=asyncio.subprocess.PIPE,
|
|
stderr=asyncio.subprocess.PIPE,
|
|
)
|
|
stdout, stderr = await proc.communicate()
|
|
output = (stdout or stderr or b"").decode().strip()
|
|
return proc.returncode == 0, output
|
|
|
|
|
|
async def _get_unit_status(unit: str) -> str:
|
|
"""Get the active status of a systemd unit."""
|
|
proc = await asyncio.create_subprocess_exec(
|
|
"systemctl", "--user", "is-active", unit,
|
|
stdout=asyncio.subprocess.PIPE,
|
|
stderr=asyncio.subprocess.PIPE,
|
|
)
|
|
stdout, _ = await proc.communicate()
|
|
return (stdout or b"").decode().strip()
|
|
|
|
|
|
def _validate_managed(name: str) -> None:
|
|
"""Raise 404 if the component isn't systemd-managed."""
|
|
config = load_config(settings.castle_root)
|
|
if name not in config.managed:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND,
|
|
detail=f"'{name}' is not a managed service",
|
|
)
|
|
|
|
|
|
async def _broadcast_health_with_override(
|
|
override_name: str, override_status: str
|
|
) -> None:
|
|
"""Run health checks but override one component's status from systemd."""
|
|
config = load_config(settings.castle_root)
|
|
statuses = await check_all_health(config)
|
|
|
|
# Replace the overridden component's status with the systemd truth
|
|
result = []
|
|
for s in statuses:
|
|
if s.id == override_name:
|
|
result.append(HealthStatus(
|
|
id=override_name,
|
|
status="down" if override_status != "active" else "up",
|
|
latency_ms=None,
|
|
))
|
|
else:
|
|
result.append(s)
|
|
|
|
await broadcast("health", {
|
|
"statuses": [s.model_dump() for s in result],
|
|
"timestamp": time.time(),
|
|
})
|
|
|
|
|
|
async def _deferred_systemctl(action: str, unit: str, delay: float = 0.5) -> None:
|
|
"""Run a systemctl action after a delay, allowing the HTTP response to flush."""
|
|
await asyncio.sleep(delay)
|
|
await _systemctl(action, unit)
|
|
|
|
|
|
async def _do_action(name: str, action: str) -> JSONResponse:
|
|
"""Execute a systemctl action and broadcast updated health."""
|
|
_validate_managed(name)
|
|
unit = f"{UNIT_PREFIX}{name}.service"
|
|
|
|
# Self-restart: defer the systemctl call so the response can be sent first
|
|
if name == SELF_NAME and action in ("restart", "stop"):
|
|
asyncio.create_task(_deferred_systemctl(action, unit))
|
|
return JSONResponse(
|
|
status_code=202,
|
|
content={"component": name, "action": action, "status": "accepted"},
|
|
)
|
|
|
|
ok, output = await _systemctl(action, unit)
|
|
unit_status = await _get_unit_status(unit)
|
|
|
|
if not ok:
|
|
raise HTTPException(status_code=500, detail=output or f"Failed to {action}")
|
|
|
|
# Broadcast immediately with systemd status as the source of truth
|
|
await _broadcast_health_with_override(name, unit_status)
|
|
|
|
return JSONResponse(
|
|
content={"component": name, "action": action, "status": unit_status},
|
|
)
|
|
|
|
|
|
@router.post("/{name}/start")
|
|
async def start_service(name: str) -> JSONResponse:
|
|
"""Start a systemd-managed service."""
|
|
return await _do_action(name, "start")
|
|
|
|
|
|
@router.post("/{name}/stop")
|
|
async def stop_service(name: str) -> JSONResponse:
|
|
"""Stop a systemd-managed service."""
|
|
return await _do_action(name, "stop")
|
|
|
|
|
|
@router.post("/{name}/restart")
|
|
async def restart_service(name: str) -> JSONResponse:
|
|
"""Restart a systemd-managed service."""
|
|
return await _do_action(name, "restart")
|