Spaces:
Running
Running
| """Read-only in-container release acceptance. Never claims or submits work.""" | |
| import asyncio | |
| import json | |
| import os | |
| import time | |
| from pathlib import Path | |
| import aiohttp | |
| from helpers import plugins, subagents | |
| from plugins.argus_supervisor.helpers import service | |
| from plugins.argus_supervisor.helpers.argus_bridge import ArgusBridge | |
| from plugins.argus_supervisor.helpers.foreman_bridge import ForemanBridge | |
| from plugins.argus_supervisor.helpers.models import SupervisorError | |
| def public_tcp_ports(): | |
| ports = set() | |
| for path in ("/proc/net/tcp", "/proc/net/tcp6"): | |
| if not Path(path).exists(): | |
| continue | |
| for line in Path(path).read_text().splitlines()[1:]: | |
| fields = line.split() | |
| address, port = fields[1].split(":") | |
| if fields[3] != "0A": | |
| continue | |
| if address in {"0100007F", "00000000000000000000000001000000"}: | |
| continue | |
| ports.add(int(port, 16)) | |
| return sorted(ports) | |
| async def checks(): | |
| root = Path(os.getenv("ARGUS_SUPERVISOR_STATE_ROOT", "/a0/usr/argus-supervisor")) | |
| report = { | |
| "uid_1000": os.getuid() == 1000, | |
| "profile_discoverable": "argus-supervisor" | |
| in subagents.get_available_agents_dict(None), | |
| "plugin_loaded": "argus_supervisor" in plugins.get_enabled_plugins(None), | |
| "public_tcp_ports": public_tcp_ports(), | |
| "token_present": bool(os.getenv("OPENTRAINING_A2A_TOKEN")), | |
| } | |
| report["only_existing_public_port"] = set(report["public_tcp_ports"]) == {7860} | |
| for name, bridge in ( | |
| ("argus", ArgusBridge(root / "argus-home")), | |
| ("foreman", ForemanBridge(root / "foreman-home")), | |
| ): | |
| try: | |
| report[name + "_runtime"] = await bridge.verify() | |
| except SupervisorError as error: | |
| report[name + "_runtime"] = {"error": str(error)} | |
| expected = os.getenv("ARGUS_EXPECTED_SOURCE_SHA", "") | |
| try: | |
| sha = json.loads(Path("/a0/openoperator-build.json").read_text())["source_sha"] | |
| except (OSError, ValueError, KeyError): | |
| sha = None | |
| try: | |
| async with ( | |
| aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=5)) as session, | |
| session.get( | |
| "http://127.0.0.1:7860/health", allow_redirects=False | |
| ) as response, | |
| ): | |
| data = json.loads(await response.content.read(16384)) | |
| report["health_sha"] = data.get("sha") if response.status == 200 else None | |
| except (aiohttp.ClientError, OSError, ValueError): | |
| report["health_sha"] = None | |
| report["health_sha_match"] = bool(expected and report["health_sha"] == expected) | |
| report["build_sha"] = sha | |
| report["expected_sha_match"] = bool(expected and sha == expected) | |
| try: | |
| supervisor = service.get() | |
| report["capabilities"] = await supervisor.discover() | |
| # A separate smoke process cannot inspect the serving process singleton. | |
| # Observe its durable heartbeat receipt instead of fabricating health. | |
| try: | |
| receipt = json.loads((root / "state/supervisor.json").read_text()) | |
| report["heartbeat_last_tick"] = receipt["last_tick"] | |
| report["heartbeat_healthy"] = time.time() - receipt["last_tick"] < 360 | |
| except (OSError, ValueError, KeyError): | |
| report["heartbeat_healthy"] = False | |
| except SupervisorError as error: | |
| report["supervisor_error"] = str(error) | |
| return report | |
| if __name__ == "__main__": | |
| result = asyncio.run(checks()) | |
| print(json.dumps(result, indent=2)) | |
| required = ( | |
| "uid_1000", | |
| "profile_discoverable", | |
| "plugin_loaded", | |
| "only_existing_public_port", | |
| "expected_sha_match", | |
| "health_sha_match", | |
| "heartbeat_healthy", | |
| ) | |
| good = all(result.get(key) is True for key in required) | |
| good = good and not any( | |
| result.get(key, {}).get("error") for key in ("argus_runtime", "foreman_runtime") | |
| ) | |
| good = good and bool(result.get("capabilities", {}).get("discover")) | |
| raise SystemExit(0 if good else 1) | |