129 lines
4.0 KiB
Python
129 lines
4.0 KiB
Python
from __future__ import annotations
|
|
|
|
import json
|
|
import subprocess
|
|
from datetime import datetime, timezone
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
|
|
def utc_now() -> str:
|
|
return datetime.now(timezone.utc).isoformat(timespec="seconds")
|
|
|
|
|
|
def _load_json(path: Path, default: dict[str, Any]) -> dict[str, Any]:
|
|
if not path.exists():
|
|
return default
|
|
try:
|
|
data = json.loads(path.read_text(encoding="utf-8"))
|
|
except json.JSONDecodeError:
|
|
return default
|
|
return data if isinstance(data, dict) else default
|
|
|
|
|
|
def _save_json(path: Path, payload: dict[str, Any]) -> None:
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
path.write_text(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True), encoding="utf-8")
|
|
|
|
|
|
def load_applied_model_config(path: Path) -> dict[str, Any]:
|
|
return _load_json(path, {"version": 0, "value": {}, "updated_at": None, "applied_at": None})
|
|
|
|
|
|
def save_applied_model_config(path: Path, payload: dict[str, Any]) -> None:
|
|
_save_json(path, payload)
|
|
|
|
|
|
def public_model_config_summary(config: dict[str, Any]) -> dict[str, Any]:
|
|
value = dict(config.get("value") or {})
|
|
value["api_key"] = ""
|
|
value["api_key_set"] = bool(value.get("api_key_set") or (config.get("value") or {}).get("api_key"))
|
|
return {
|
|
"version": int(config.get("version") or 0),
|
|
"updated_at": config.get("updated_at"),
|
|
"applied_at": config.get("applied_at"),
|
|
"value": value,
|
|
}
|
|
|
|
|
|
class RuntimeRestartManager:
|
|
def __init__(self, path: Path, command: str = ""):
|
|
self.path = path
|
|
self.command = command.strip()
|
|
self.process: subprocess.Popen | None = None
|
|
self.state = _load_json(
|
|
path,
|
|
{
|
|
"generation": 0,
|
|
"last_restart_at": None,
|
|
"reason": "",
|
|
"model_config_version": 0,
|
|
"mode": "placeholder",
|
|
},
|
|
)
|
|
|
|
@property
|
|
def generation(self) -> int:
|
|
try:
|
|
return int(self.state.get("generation") or 0)
|
|
except (TypeError, ValueError):
|
|
return 0
|
|
|
|
def _start_process(self) -> int | None:
|
|
if not self.command:
|
|
return None
|
|
if self.process and self.process.poll() is None:
|
|
return self.process.pid
|
|
self.process = subprocess.Popen(
|
|
self.command,
|
|
cwd=str(self.path.parent.parent),
|
|
shell=True,
|
|
stdout=subprocess.DEVNULL,
|
|
stderr=subprocess.DEVNULL,
|
|
)
|
|
return self.process.pid
|
|
|
|
def stop(self) -> None:
|
|
if not self.process or self.process.poll() is not None:
|
|
return
|
|
self.process.terminate()
|
|
try:
|
|
self.process.wait(timeout=5)
|
|
except subprocess.TimeoutExpired:
|
|
self.process.kill()
|
|
self.process.wait(timeout=5)
|
|
|
|
def ensure_started(self, version: int) -> dict[str, Any] | None:
|
|
if not self.command:
|
|
return None
|
|
pid = self._start_process()
|
|
now = utc_now()
|
|
self.state = {
|
|
"generation": self.generation,
|
|
"last_restart_at": self.state.get("last_restart_at"),
|
|
"reason": self.state.get("reason") or "startup",
|
|
"model_config_version": version,
|
|
"mode": "subprocess",
|
|
"pid": pid,
|
|
"command_configured": True,
|
|
"checked_at": now,
|
|
}
|
|
_save_json(self.path, self.state)
|
|
return self.state
|
|
|
|
def restart_for_model_config(self, version: int) -> dict[str, Any]:
|
|
now = utc_now()
|
|
self.stop()
|
|
pid = self._start_process()
|
|
self.state = {
|
|
"generation": self.generation + 1,
|
|
"last_restart_at": now,
|
|
"reason": f"model_config_v{version}",
|
|
"model_config_version": version,
|
|
"mode": "subprocess" if self.command else "placeholder",
|
|
"pid": pid,
|
|
"command_configured": bool(self.command),
|
|
}
|
|
_save_json(self.path, self.state)
|
|
return self.state
|