| """World model: builds runtime state from a task spec, derives metrics deterministically. |
| |
| Everything the agent observes is derived from state. There are no scripted metric |
| curves: fix the state and the metrics follow. Randomness is seeded and stable |
| across processes (no builtin hash()). |
| """ |
| from __future__ import annotations |
|
|
| import copy |
| import hashlib |
| import json |
|
|
|
|
| def stable_hash(*parts) -> int: |
| h = hashlib.sha256("|".join(str(p) for p in parts).encode("utf-8")).digest() |
| return int.from_bytes(h[:8], "big") |
|
|
|
|
| def build_world(spec: dict) -> dict: |
| """Deep-copy the static spec into a mutable runtime world.""" |
| w = copy.deepcopy(spec) |
| w["t"] = 0.0 |
| w["restarts"] = {} |
| w["report"] = None |
| w["drained_hosts"] = [] |
| for name, svc in w["services"].items(): |
| svc["initial_replicas"] = svc["replicas"] |
| svc["initial_version"] = svc["deploys"][-1]["version"] |
| svc["initial_config"] = copy.deepcopy(svc["config"]) |
| return w |
|
|
|
|
| def current_version(w: dict, svc: str) -> str: |
| return w["services"][svc]["deploys"][-1]["version"] |
|
|
|
|
| def replicas_on_host(w: dict, svc: str, host: str) -> int: |
| hosts = w["services"][svc]["hosts"] |
| if not hosts: |
| return 0 |
| |
| total = w["services"][svc]["replicas"] |
| if host not in hosts: |
| return 0 |
| return total // len(hosts) + (1 if hosts.index(host) < total % len(hosts) else 0) |
|
|
|
|
| def frac_on_host(w: dict, svc: str, host: str) -> float: |
| total = w["services"][svc]["replicas"] |
| if total == 0: |
| return 0.0 |
| return replicas_on_host(w, svc, host) / total |
|
|
|
|
| def contributions(w: dict) -> list[tuple[str, dict]]: |
| """Yield (label, {svc: {error_pct, p99_ms, mem_pct}}) for every fault and decoy.""" |
| from . import faults as F |
|
|
| out = [] |
| for f in w["faults"]: |
| cls = F.FAULT_TYPES[f["type"]] |
| out.append((f["type"], cls.impact(w, f["params"]))) |
| for d in w["decoys"]: |
| cls = F.DECOY_ALIASES[d["type"]] |
| out.append(("decoy:" + d["type"], cls.impact(w, d["params"]))) |
| return out |
|
|
|
|
| def agg(w: dict, svc: str, key: str) -> float: |
| total = 0.0 |
| for _, contrib in contributions(w): |
| total += contrib.get(svc, {}).get(key, 0.0) |
| return total |
|
|
|
|
| def metrics(w: dict, svc: str) -> dict: |
| s = w["services"][svc] |
| seed = w["seed"] |
| err = s["base_error_pct"] + agg(w, svc, "error_pct") |
| err += (stable_hash(seed, svc, w["t"] // 5, "err") % 100) / 10000.0 |
| p99 = s["base_p99_ms"] + agg(w, svc, "p99_ms") |
| p99 += (stable_hash(seed, svc, w["t"] // 5, "p99") % 100) / 10.0 |
| per_replica = s["runbook"].get("rps_per_replica", 150) |
| cpu = 70.0 * s["rps"] / max(1, s["replicas"] * per_replica) |
| cpu = min(99.0, cpu) + (stable_hash(seed, svc, "cpu") % 50) / 10.0 |
| mem = 30.0 + agg(w, svc, "mem_pct") |
| mem = min(99.0, mem) |
| if s["kind"] == "external": |
| return {"status": s.get("status", "up")} |
| return { |
| "error_pct": round(err, 3), |
| "p99_ms": round(p99, 1), |
| "cpu_pct": round(cpu, 1), |
| "mem_pct": round(mem, 1), |
| "rps": s["rps"], |
| "slo_error_pct": s["slo_error_pct"], |
| "degraded": err > s["slo_error_pct"], |
| } |
|
|
|
|
| def per_host_metrics(w: dict, svc: str) -> dict: |
| out = {} |
| base = w["services"][svc]["base_error_pct"] |
| for h in w["services"][svc]["hosts"]: |
| if h in w["drained_hosts"] or not w["hosts"][h]["healthy"]: |
| e = 55.0 |
| else: |
| e = base + agg(w, svc, "error_pct") |
| out[h] = {"replicas": replicas_on_host(w, svc, h), "error_pct": round(e, 2)} |
| return out |
|
|
|
|
| def fmt_clock(w: dict, t: float | None = None) -> str: |
| t = w["t"] if t is None else t |
| total = int(round(t)) |
| hh, mm = 9 + (total // 60) % 24, total % 60 |
| return f"{hh:02d}:{mm:02d}" |
|
|
|
|
| def log(w: dict, svc: str, level: str, msg: str) -> None: |
| w["events"].append({"t": round(w["t"], 1), "svc": svc, "level": level, "msg": msg}) |
|
|
|
|
| def to_json(obj) -> str: |
| return json.dumps(obj, ensure_ascii=False, separators=(",", ":")) |
|
|
|
|
| def is_managed(w: dict, svc: str) -> bool: |
| s = w["services"].get(svc) |
| return bool(s and s["kind"] != "external") |
|
|
