The file owner check has its own test through a file-owner seam, for route.json on read and write and for route-receipts.jsonl on write. The directory, temp file and a new receipts file get their modes on the open descriptor, so a narrow umask cannot leave a route the next read refuses; an existing receipts file is never repaired. A failed temp write refuses and removes the temp file. A failure after the rename refuses as triage-route-unrecorded and names the new revision. The input zone check uses the stored cap's rule, so +05:00 refuses as an unknown zone. A changed cap keeps its since, as an organization's token limits do, so lowering the cap never drops tokens already counted (#1873, lane triage-route-store).
425 lines
23 KiB
JavaScript
425 lines
23 KiB
JavaScript
// #1873 triage-route-store: the owner-only file that holds Triage's model route and daily cap,
|
|
// <dataRoot>/triage/route.json (design report section 1, option C). Names only: no env value and
|
|
// no key. The directory is 0700 and the file 0600, both the running user's; a link, a non-file,
|
|
// a wrong mode or owner refuses. A write is compare-and-set on revision, atomic (temp file plus
|
|
// rename in the same directory), and appends one receipt line.
|
|
import { test } from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import { spawn } from "node:child_process";
|
|
import { chmodSync, existsSync, linkSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
|
|
import { join } from "node:path";
|
|
import {
|
|
CAP_FIELDS, ROUTE_FIELDS, ROUTE_VERSION, RouteStoreError, capFor, readRoute, routePaths, validRoute, writeRoute,
|
|
} from "../src/triage-route-store.mjs";
|
|
|
|
const MODULE = new URL("../src/triage-route-store.mjs", import.meta.url).pathname;
|
|
const NOW = "2026-11-18T12:00:00.000Z";
|
|
const LATER = "2026-11-18T13:00:00.000Z";
|
|
const at = (iso) => () => new Date(iso);
|
|
const INPUT = { model: "glm-5", harness: "claude-code", limit: 200000, timeZone: "America/Chicago", by: "owner" };
|
|
|
|
function root(t) {
|
|
const dir = mkdtempSync(join(process.env.TMPDIR, "trs-"));
|
|
t.after(() => rmSync(dir, { recursive: true, force: true }));
|
|
return dir;
|
|
}
|
|
const code = (c) => (e) => e instanceof RouteStoreError && e.code === c;
|
|
// Unreadable with a given reason, so each check is shown to refuse on its own.
|
|
const unreadableFor = (re) => (e) => code("triage-route-unreadable")(e) && re.test(e.message);
|
|
const receipts = (dataRoot) => readFileSync(routePaths(dataRoot).receipts, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
|
|
const good = () => ({
|
|
version: 1, revision: 1, model: "glm-5", harness: "claude-code",
|
|
cap: { limit: 200000, since: NOW, reset: "00:00", timeZone: "America/Chicago" }, updatedAt: NOW, updatedBy: "owner",
|
|
});
|
|
// Write a doc straight to route.json at the right modes, to test the loader alone.
|
|
function plant(dataRoot, doc) {
|
|
const { dir, file } = routePaths(dataRoot);
|
|
mkdirSync(dir, { recursive: true, mode: 0o700 });
|
|
chmodSync(dir, 0o700);
|
|
writeFileSync(file, typeof doc === "string" ? doc : JSON.stringify(doc), { mode: 0o600 });
|
|
chmodSync(file, 0o600);
|
|
}
|
|
|
|
test("paths, field names and the reset rule each live in one place", () => {
|
|
const p = routePaths("/d");
|
|
assert.deepEqual(p, { dir: "/d/triage", file: "/d/triage/route.json", receipts: "/d/triage/route-receipts.jsonl", lock: "/d/triage/route.lock" });
|
|
assert.deepEqual([...ROUTE_FIELDS].sort(), ["cap", "harness", "model", "revision", "updatedAt", "updatedBy", "version"]);
|
|
assert.deepEqual([...CAP_FIELDS].sort(), ["limit", "reset", "since", "timeZone"]);
|
|
assert.equal(ROUTE_VERSION, 1);
|
|
// A new cap starts its count now and resets at 00:00 in the owner's zone.
|
|
assert.deepEqual(capFor({ limit: 5, timeZone: "UTC", previous: null, now: NOW }), { limit: 5, since: NOW, reset: "00:00", timeZone: "UTC" });
|
|
// A later cap keeps its since, changed or not, as an organization's token limits do: lowering
|
|
// the cap never drops the tokens already counted.
|
|
const prev = { limit: 5, since: NOW, reset: "00:00", timeZone: "UTC" };
|
|
assert.equal(capFor({ limit: 5, timeZone: "UTC", previous: prev, now: LATER }).since, NOW);
|
|
assert.equal(capFor({ limit: 2, timeZone: "UTC", previous: prev, now: LATER }).since, NOW);
|
|
assert.equal(capFor({ limit: 5, timeZone: "Europe/Berlin", previous: prev, now: LATER }).since, NOW);
|
|
});
|
|
|
|
test("no file reads as not set; a write then reads back the same route", (t) => {
|
|
const d = root(t);
|
|
assert.equal(readRoute(d), null);
|
|
const written = writeRoute(d, INPUT, { now: at(NOW) });
|
|
assert.deepEqual(written, good());
|
|
assert.deepEqual(readRoute(d), good());
|
|
const { dir, file } = routePaths(d);
|
|
assert.equal(lstatSync(dir).mode & 0o777, 0o700);
|
|
assert.equal(lstatSync(file).mode & 0o777, 0o600);
|
|
// The store holds names only: nothing shaped like an env value or a key.
|
|
const text = readFileSync(file, "utf8");
|
|
assert.doesNotMatch(text, /ANTHROPIC|_KEY|TOKEN|mst-|msk-|env/i);
|
|
// A second write bumps the revision and keeps the cap's since when the cap is the same.
|
|
const second = writeRoute(d, { ...INPUT, model: "glm-5.3-flash", revision: 1 }, { now: at(LATER) });
|
|
assert.equal(second.revision, 2);
|
|
assert.equal(second.model, "glm-5.3-flash");
|
|
assert.equal(second.cap.since, NOW);
|
|
assert.equal(second.updatedAt, LATER);
|
|
assert.deepEqual(readRoute(d), second);
|
|
// No temp file or lock is left behind.
|
|
assert.deepEqual(readdirSync(dir).sort(), ["route-receipts.jsonl", "route.json"]);
|
|
});
|
|
|
|
test("each write appends one receipt line with the old and the new value", (t) => {
|
|
const d = root(t);
|
|
writeRoute(d, INPUT, { now: at(NOW) });
|
|
writeRoute(d, { ...INPUT, limit: 1000 }, { now: at(LATER) });
|
|
const lines = receipts(d);
|
|
assert.equal(lines.length, 2);
|
|
assert.deepEqual(lines[0], { at: NOW, by: "owner", revision: 1, from: null, to: { model: "glm-5", harness: "claude-code", cap: good().cap } });
|
|
assert.equal(lines[1].revision, 2);
|
|
assert.deepEqual(lines[1].from, { model: "glm-5", harness: "claude-code", cap: good().cap });
|
|
assert.equal(lines[1].to.cap.limit, 1000);
|
|
assert.equal(lines[1].to.cap.since, NOW);
|
|
assert.equal(lstatSync(routePaths(d).receipts).mode & 0o777, 0o600);
|
|
// A refused write appends nothing.
|
|
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(LATER) }), code("triage-route-stale"));
|
|
assert.equal(receipts(d).length, 2);
|
|
});
|
|
|
|
test("a stale revision refuses and leaves the file alone", (t) => {
|
|
const d = root(t);
|
|
writeRoute(d, INPUT, { now: at(NOW) });
|
|
writeRoute(d, { ...INPUT, limit: 7, revision: 1 }, { now: at(NOW) });
|
|
const before = readFileSync(routePaths(d).file, "utf8");
|
|
assert.throws(() => writeRoute(d, { ...INPUT, limit: 9, revision: 1 }, { now: at(LATER) }), code("triage-route-stale"));
|
|
assert.throws(() => writeRoute(d, { ...INPUT, limit: 9, revision: 3 }, { now: at(LATER) }), code("triage-route-stale"));
|
|
assert.equal(readFileSync(routePaths(d).file, "utf8"), before);
|
|
// Revision 0 means "only if there is no route yet".
|
|
assert.throws(() => writeRoute(d, { ...INPUT, revision: 0 }, { now: at(LATER) }), code("triage-route-stale"));
|
|
const e = root(t);
|
|
assert.equal(writeRoute(e, { ...INPUT, revision: 0 }, { now: at(NOW) }).revision, 1);
|
|
});
|
|
|
|
test("refused input shapes on a write", (t) => {
|
|
const d = root(t);
|
|
// Each input check refuses with its own message, so none rests only on the final shape check.
|
|
const bad = [
|
|
[{ ...INPUT, model: "" }, /model must be/], [{ ...INPUT, model: "Has Space" }, /model must be/],
|
|
[{ ...INPUT, model: "x".repeat(65) }, /model must be/], [{ ...INPUT, model: 5 }, /model must be/],
|
|
[{ ...INPUT, harness: "" }, /harness must be/], [{ ...INPUT, harness: "Claude" }, /harness must be/],
|
|
[{ ...INPUT, harness: "../pi" }, /harness must be/], [{ ...INPUT, harness: "x".repeat(33) }, /harness must be/],
|
|
[{ ...INPUT, limit: -1 }, /the cap must be/], [{ ...INPUT, limit: 1.5 }, /the cap must be/],
|
|
[{ ...INPUT, limit: "100" }, /the cap must be/], [{ ...INPUT, limit: 2 ** 53 }, /the cap must be/],
|
|
[{ ...INPUT, timeZone: undefined }, /a time zone is required/], [{ ...INPUT, timeZone: "" }, /time zone is unknown/],
|
|
[{ ...INPUT, timeZone: "Mars/Olympus_Mons" }, /time zone is unknown/], [{ ...INPUT, timeZone: "../etc" }, /time zone is unknown/],
|
|
[{ ...INPUT, timeZone: "+05:00" }, /time zone is unknown/],
|
|
[{ ...INPUT, by: "" }, /actor name/], [{ ...INPUT, by: "Owner Person" }, /actor name/],
|
|
[{ ...INPUT, revision: -1 }, /revision must be/], [{ ...INPUT, revision: "1" }, /revision must be/], [{ ...INPUT, revision: 1.5 }, /revision must be/],
|
|
[{ ...INPUT, env: { A: "b" } }, /unknown field env/], [{ ...INPUT, key: "mst-x" }, /unknown field key/],
|
|
[null, /not an object/], [[INPUT], /not an object/],
|
|
];
|
|
for (const [input, message] of bad) {
|
|
assert.throws(() => writeRoute(d, input, { now: at(NOW) }), (e) => code("triage-route-invalid")(e) && message.test(e.message), JSON.stringify(input));
|
|
}
|
|
// No time zone default: leaving it out refuses.
|
|
const { timeZone, ...noZone } = INPUT;
|
|
assert.throws(() => writeRoute(d, noZone, { now: at(NOW) }), (e) => code("triage-route-invalid")(e) && /a time zone is required/.test(e.message));
|
|
assert.equal(readRoute(d), null);
|
|
});
|
|
|
|
test("an unknown time zone refuses on write and on read", (t) => {
|
|
const d = root(t);
|
|
assert.throws(() => writeRoute(d, { ...INPUT, timeZone: "Atlantis/Lost" }, { now: at(NOW) }), code("triage-route-invalid"));
|
|
plant(d, { ...good(), cap: { ...good().cap, timeZone: "Atlantis/Lost" } });
|
|
assert.throws(() => readRoute(d), code("triage-route-unreadable"));
|
|
});
|
|
|
|
test("each refused stored shape reads as unreadable", (t) => {
|
|
const g = good();
|
|
const shapes = {
|
|
"not json": "{",
|
|
"an array": [g],
|
|
"null": null,
|
|
"unknown field": { ...g, env: {} },
|
|
"unknown cap field": { ...g, cap: { ...g.cap, perTurn: 5 } },
|
|
"missing version": (({ version, ...r }) => r)(g),
|
|
"missing revision": (({ revision, ...r }) => r)(g),
|
|
"missing model": (({ model, ...r }) => r)(g),
|
|
"missing harness": (({ harness, ...r }) => r)(g),
|
|
"missing cap": (({ cap, ...r }) => r)(g),
|
|
"missing updatedAt": (({ updatedAt, ...r }) => r)(g),
|
|
"missing updatedBy": (({ updatedBy, ...r }) => r)(g),
|
|
"missing cap.limit": { ...g, cap: (({ limit, ...r }) => r)(g.cap) },
|
|
"missing cap.since": { ...g, cap: (({ since, ...r }) => r)(g.cap) },
|
|
"missing cap.reset": { ...g, cap: (({ reset, ...r }) => r)(g.cap) },
|
|
"missing cap.timeZone": { ...g, cap: (({ timeZone, ...r }) => r)(g.cap) },
|
|
"version 2": { ...g, version: 2 },
|
|
"revision 0": { ...g, revision: 0 },
|
|
"revision text": { ...g, revision: "1" },
|
|
"bad model": { ...g, model: "A B" },
|
|
"bad harness": { ...g, harness: "A/B" },
|
|
"cap an array": { ...g, cap: [1] },
|
|
"negative limit": { ...g, cap: { ...g.cap, limit: -1 } },
|
|
"bad reset": { ...g, cap: { ...g.cap, reset: "24:00" } },
|
|
"bad since": { ...g, cap: { ...g.cap, since: "2026-11-18" } },
|
|
"bad updatedAt": { ...g, updatedAt: "yesterday" },
|
|
"bad updatedBy": { ...g, updatedBy: "A B" },
|
|
};
|
|
for (const [name, doc] of Object.entries(shapes)) {
|
|
const d = root(t);
|
|
plant(d, doc);
|
|
assert.throws(() => readRoute(d), code("triage-route-unreadable"), name);
|
|
if (typeof doc !== "string") assert.equal(validRoute(doc), false, name);
|
|
}
|
|
assert.equal(validRoute(g), true);
|
|
// A write over an unreadable file refuses too; it never replaces what it could not read.
|
|
const d = root(t);
|
|
plant(d, { ...g, env: {} });
|
|
assert.throws(() => writeRoute(d, INPUT, { now: at(NOW) }), code("triage-route-unreadable"));
|
|
});
|
|
|
|
test("an oversized file is refused before it is parsed", (t) => {
|
|
const d = root(t);
|
|
plant(d, JSON.stringify(good()) + " ".repeat(70000));
|
|
assert.throws(() => readRoute(d), code("triage-route-unreadable"));
|
|
});
|
|
|
|
test("a wrong mode on the directory or the file refuses", (t) => {
|
|
for (const mode of [0o755, 0o750, 0o711, 0o500]) {
|
|
const d = root(t);
|
|
plant(d, good());
|
|
chmodSync(routePaths(d).dir, mode);
|
|
assert.throws(() => readRoute(d), code("triage-route-unreadable"), `dir ${mode.toString(8)}`);
|
|
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(NOW) }), code("triage-route-unreadable"), `dir ${mode.toString(8)}`);
|
|
chmodSync(routePaths(d).dir, 0o700);
|
|
}
|
|
for (const mode of [0o644, 0o640, 0o604, 0o400, 0o700]) {
|
|
const d = root(t);
|
|
plant(d, good());
|
|
chmodSync(routePaths(d).file, mode);
|
|
assert.throws(() => readRoute(d), code("triage-route-unreadable"), `file ${mode.toString(8)}`);
|
|
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(NOW) }), code("triage-route-unreadable"), `file ${mode.toString(8)}`);
|
|
}
|
|
// A receipts file with the wrong mode refuses the write before the route changes.
|
|
const d = root(t);
|
|
writeRoute(d, INPUT, { now: at(NOW) });
|
|
chmodSync(routePaths(d).receipts, 0o644);
|
|
assert.throws(() => writeRoute(d, { ...INPUT, limit: 1, revision: 1 }, { now: at(LATER) }), code("triage-route-unreadable"));
|
|
assert.equal(readRoute(d).revision, 1);
|
|
});
|
|
|
|
test("a wrong owner refuses on the directory and the file", (t) => {
|
|
const d = root(t);
|
|
plant(d, good());
|
|
// Pretend to be another user: the store compares with the uid it is given.
|
|
const other = process.getuid() + 1;
|
|
// The files alone owned by someone else: route.json on read and write, the receipts on write.
|
|
assert.throws(() => readRoute(d, { fileUid: other }), unreadableFor(/route\.json is not owned by this user/));
|
|
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(NOW), fileUid: other }), unreadableFor(/route\.json is not owned by this user/));
|
|
const e = root(t);
|
|
writeRoute(e, INPUT, { now: at(NOW) });
|
|
unlinkSync(routePaths(e).file);
|
|
assert.throws(() => writeRoute(e, INPUT, { now: at(NOW), fileUid: other }), unreadableFor(/route-receipts\.jsonl is not owned by this user/));
|
|
assert.equal(existsSync(routePaths(e).file), false);
|
|
assert.throws(() => readRoute(d, { uid: other }), unreadableFor(/the triage directory is not owned by this user/));
|
|
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(NOW), uid: other }), unreadableFor(/the triage directory is not owned by this user/));
|
|
assert.equal(readRoute(d, { uid: process.getuid() }).revision, 1);
|
|
});
|
|
|
|
test("a link at the file, the directory or the receipts refuses; so does a non-file", (t) => {
|
|
// Symlink at route.json, to a valid route elsewhere.
|
|
let d = root(t);
|
|
plant(d, good());
|
|
const elsewhere = join(d, "elsewhere.json");
|
|
renameSync(routePaths(d).file, elsewhere);
|
|
symlinkSync(elsewhere, routePaths(d).file);
|
|
assert.throws(() => readRoute(d), code("triage-route-unreadable"));
|
|
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(NOW) }), code("triage-route-unreadable"));
|
|
// A hard link at route.json.
|
|
d = root(t);
|
|
plant(d, good());
|
|
linkSync(routePaths(d).file, join(d, "hard.json"));
|
|
assert.throws(() => readRoute(d), code("triage-route-unreadable"));
|
|
// Symlink at the triage directory, to a real 0700 directory holding a valid route.
|
|
d = root(t);
|
|
const real = join(d, "real");
|
|
mkdirSync(real, { mode: 0o700 });
|
|
writeFileSync(join(real, "route.json"), JSON.stringify(good()), { mode: 0o600 });
|
|
symlinkSync(real, routePaths(d).dir);
|
|
assert.throws(() => readRoute(d), unreadableFor(/the triage directory is a link/));
|
|
assert.throws(() => writeRoute(d, INPUT, { now: at(NOW) }), unreadableFor(/the triage directory is a link/));
|
|
// A directory where route.json should be.
|
|
d = root(t);
|
|
mkdirSync(routePaths(d).file, { recursive: true, mode: 0o700 });
|
|
chmodSync(routePaths(d).dir, 0o700);
|
|
assert.throws(() => readRoute(d), unreadableFor(/route\.json is not a regular file/));
|
|
// A file where the triage directory should be, at 0700 so only the directory check refuses it.
|
|
d = root(t);
|
|
writeFileSync(routePaths(d).dir, "x", { mode: 0o700 });
|
|
chmodSync(routePaths(d).dir, 0o700);
|
|
assert.throws(() => readRoute(d), unreadableFor(/the triage directory is not a directory/));
|
|
assert.throws(() => writeRoute(d, INPUT, { now: at(NOW) }), unreadableFor(/the triage directory is not a directory/));
|
|
// A symlink at the receipts file refuses the write and never follows it.
|
|
d = root(t);
|
|
writeRoute(d, INPUT, { now: at(NOW) });
|
|
const target = join(d, "target.jsonl");
|
|
writeFileSync(target, "", { mode: 0o600 });
|
|
unlinkSync(routePaths(d).receipts);
|
|
symlinkSync(target, routePaths(d).receipts);
|
|
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(LATER) }), code("triage-route-unreadable"));
|
|
assert.equal(readFileSync(target, "utf8"), "");
|
|
assert.equal(readRoute(d).revision, 1);
|
|
// A symlink at the lock path is not followed: the write refuses as busy.
|
|
d = root(t);
|
|
writeRoute(d, INPUT, { now: at(NOW) });
|
|
symlinkSync(join(d, "nowhere"), routePaths(d).lock);
|
|
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(LATER) }), code("triage-route-busy"));
|
|
assert.equal(existsSync(join(d, "nowhere")), false);
|
|
});
|
|
|
|
test("a write under a narrow umask still leaves 0700 and 0600, so the next read works", (t) => {
|
|
const d = root(t);
|
|
const old = process.umask(0o277);
|
|
let written;
|
|
try { written = writeRoute(d, INPUT, { now: at(NOW) }); } finally { process.umask(old); }
|
|
const { dir, file, receipts: r } = routePaths(d);
|
|
assert.equal(lstatSync(dir).mode & 0o777, 0o700);
|
|
assert.equal(lstatSync(file).mode & 0o777, 0o600);
|
|
assert.equal(lstatSync(r).mode & 0o777, 0o600);
|
|
assert.deepEqual(readRoute(d), written);
|
|
// An existing receipts file is never repaired: a wrong mode still refuses.
|
|
chmodSync(r, 0o644);
|
|
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(LATER) }), unreadableFor(/route-receipts\.jsonl mode is not 0600/));
|
|
});
|
|
|
|
test("a failed temp write refuses and leaves the route; a failed receipt after the rename says so", (t) => {
|
|
const d = root(t);
|
|
writeRoute(d, INPUT, { now: at(NOW) });
|
|
const before = readFileSync(routePaths(d).file, "utf8");
|
|
const fail = (stage) => (s) => { if (s === stage) throw Object.assign(new Error("no space"), { code: "ENOSPC" }); };
|
|
assert.throws(() => writeRoute(d, { ...INPUT, limit: 1, revision: 1 }, { now: at(LATER), hook: fail("write") }), unreadableFor(/route\.json cannot be written/));
|
|
assert.equal(readFileSync(routePaths(d).file, "utf8"), before);
|
|
assert.deepEqual(readdirSync(routePaths(d).dir).sort(), ["route-receipts.jsonl", "route.json"]);
|
|
assert.equal(receipts(d).length, 1);
|
|
// After the rename the route has changed; the refusal names the new revision and the missing line.
|
|
assert.throws(() => writeRoute(d, { ...INPUT, limit: 1, revision: 1 }, { now: at(LATER), hook: fail("after-rename") }),
|
|
(e) => code("triage-route-unrecorded")(e) && /changed to revision 2, but its receipt line was not written/.test(e.message));
|
|
assert.equal(readRoute(d).revision, 2);
|
|
assert.equal(receipts(d).length, 1);
|
|
assert.deepEqual(readdirSync(routePaths(d).dir).sort(), ["route-receipts.jsonl", "route.json"]);
|
|
});
|
|
|
|
test("the store makes its directory 0700 but never the data root", (t) => {
|
|
const d = root(t);
|
|
assert.throws(() => writeRoute(join(d, "missing"), INPUT, { now: at(NOW) }), code("triage-route-unreadable"));
|
|
assert.equal(existsSync(join(d, "missing")), false);
|
|
});
|
|
|
|
test("two writers in one process: the second, while the first holds the lock, refuses busy", (t) => {
|
|
const d = root(t);
|
|
writeRoute(d, INPUT, { now: at(NOW) });
|
|
let inner = null;
|
|
const won = writeRoute(d, { ...INPUT, limit: 1, revision: 1 }, {
|
|
now: at(LATER),
|
|
hook: (stage) => {
|
|
if (stage !== "before-rename") return;
|
|
try { writeRoute(d, { ...INPUT, limit: 2, revision: 1 }, { now: at(LATER) }); } catch (e) { inner = e; }
|
|
},
|
|
});
|
|
assert.equal(won.cap.limit, 1);
|
|
assert.ok(code("triage-route-busy")(inner), String(inner));
|
|
assert.equal(readRoute(d).cap.limit, 1);
|
|
assert.equal(receipts(d).length, 2);
|
|
});
|
|
|
|
// A child process that loads the store and writes once; prints {ok, code}. `wait` makes it hold
|
|
// at the given stage until the file `go` appears, so two children overlap for real.
|
|
const CHILD = `
|
|
import { writeRoute } from ${JSON.stringify(MODULE)};
|
|
import { existsSync, writeFileSync } from "node:fs";
|
|
const [dataRoot, limit, revision, wait, go, ready] = process.argv.slice(1);
|
|
try {
|
|
const r = writeRoute(dataRoot, { model: "glm-5", harness: "claude-code", limit: Number(limit), timeZone: "UTC", by: "owner", revision: Number(revision) }, {
|
|
hook: (stage) => {
|
|
if (stage === "crash") { if (wait === "crash") process.kill(process.pid, "SIGKILL"); return; }
|
|
if (stage !== wait) return;
|
|
writeFileSync(ready, "");
|
|
const end = Date.now() + 20000;
|
|
while (!existsSync(go) && Date.now() < end) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
|
|
},
|
|
});
|
|
console.log(JSON.stringify({ ok: true, limit: r.cap.limit }));
|
|
} catch (e) { console.log(JSON.stringify({ ok: false, code: e.code ?? String(e) })); }
|
|
`;
|
|
function child(args) {
|
|
return new Promise((resolve, reject) => {
|
|
const p = spawn(process.execPath, ["--input-type=module", "-e", CHILD, ...args], { stdio: ["ignore", "pipe", "pipe"] });
|
|
let out = "", err = "";
|
|
p.stdout.setEncoding("utf8").on("data", (c) => { out += c; });
|
|
p.stderr.setEncoding("utf8").on("data", (c) => { err += c; });
|
|
p.on("error", reject);
|
|
p.on("close", (status, signal) => resolve({ status, signal, out: out.trim(), err }));
|
|
});
|
|
}
|
|
async function until(path) {
|
|
const end = Date.now() + 20000;
|
|
while (!existsSync(path)) {
|
|
if (Date.now() > end) throw new Error(`timed out waiting for ${path}`);
|
|
await new Promise((r) => setTimeout(r, 20));
|
|
}
|
|
}
|
|
|
|
test("two writer processes racing on one revision: one wins, one refuses", async (t) => {
|
|
const d = root(t);
|
|
writeRoute(d, { ...INPUT, timeZone: "UTC" }, { now: at(NOW) });
|
|
const go = join(d, "go"), ready = join(d, "ready");
|
|
// The first holds just before its rename; the second starts then, with the same revision.
|
|
const first = child([d, "11", "1", "before-rename", go, ready]);
|
|
await until(ready);
|
|
const second = await child([d, "22", "1", "none", join(d, "unused"), join(d, "unused-ready")]);
|
|
writeFileSync(go, "");
|
|
const a = JSON.parse((await first).out), b = JSON.parse(second.out);
|
|
assert.deepEqual(a, { ok: true, limit: 11 });
|
|
assert.equal(b.ok, false);
|
|
assert.equal(b.code, "triage-route-busy");
|
|
assert.equal(readRoute(d).cap.limit, 11);
|
|
assert.equal(readRoute(d).revision, 2);
|
|
// After the winner, the loser's revision is stale.
|
|
const again = JSON.parse((await child([d, "22", "1", "none", join(d, "u2"), join(d, "u3")])).out);
|
|
assert.deepEqual(again, { ok: false, code: "triage-route-stale" });
|
|
// Started together with no pause, exactly one of two wins.
|
|
const both = await Promise.all([child([d, "33", "2", "none", join(d, "u4"), join(d, "u5")]), child([d, "44", "2", "none", join(d, "u6"), join(d, "u7")])]);
|
|
const results = both.map((r) => JSON.parse(r.out));
|
|
assert.equal(results.filter((r) => r.ok).length, 1, JSON.stringify(results));
|
|
assert.ok(results.filter((r) => !r.ok).every((r) => ["triage-route-busy", "triage-route-stale"].includes(r.code)), JSON.stringify(results));
|
|
assert.equal(readRoute(d).revision, 3);
|
|
assert.equal(receipts(d).length, 3);
|
|
});
|
|
|
|
test("a crash between the temp write and the rename leaves the old file", async (t) => {
|
|
const d = root(t);
|
|
const old = writeRoute(d, { ...INPUT, timeZone: "UTC" }, { now: at(NOW) });
|
|
const r = await child([d, "99", "1", "crash", join(d, "go"), join(d, "ready")]);
|
|
assert.equal(r.signal, "SIGKILL", r.err);
|
|
assert.deepEqual(readRoute(d), old);
|
|
assert.equal(receipts(d).length, 1);
|
|
// The temp file is still there, and the dead writer's lock refuses the next write, naming it.
|
|
const { dir, lock } = routePaths(d);
|
|
assert.ok(readdirSync(dir).some((n) => n.endsWith(".tmp")), readdirSync(dir).join(","));
|
|
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(LATER) }), (e) => code("triage-route-busy")(e) && /not running/.test(e.message) && /route\.lock/.test(e.message));
|
|
// The person removes the lock by hand; the next write works and the read ignores the temp file.
|
|
unlinkSync(lock);
|
|
assert.equal(writeRoute(d, { ...INPUT, revision: 1 }, { now: at(LATER) }).revision, 2);
|
|
assert.equal(readRoute(d).revision, 2);
|
|
});
|