311 lines
15 KiB
JavaScript
311 lines
15 KiB
JavaScript
import fs from "node:fs";
|
|
import path from "node:path";
|
|
import { spawnSync } from "node:child_process";
|
|
import { fileURLToPath } from "node:url";
|
|
import { recordFailure } from "./wbv2-failure-ledger.mjs";
|
|
|
|
const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
|
|
const controlRoot = "tests/golden/WBV2";
|
|
const checkpointPath = `${controlRoot}/continuous-scheduler.json`;
|
|
const lockPath = `${controlRoot}/continuous-scheduler.lock`;
|
|
const logPath = `${controlRoot}/continuous-scheduler.log`;
|
|
const abs = (file) => path.join(root, file);
|
|
|
|
const argValue = (name, fallback) => {
|
|
const index = process.argv.indexOf(name);
|
|
return index >= 0 ? process.argv[index + 1] : fallback;
|
|
};
|
|
const maxIterations = Number(argValue("--max-iterations", "0"));
|
|
const pollMs = Number(argValue("--poll-ms", "1000"));
|
|
const pushRetries = Number(argValue("--push-retries", "6"));
|
|
const commitEnabled = process.argv.includes("--commit");
|
|
const pushEnabled = process.argv.includes("--push");
|
|
const preflightOnly = process.argv.includes("--preflight-only");
|
|
if (!Number.isSafeInteger(maxIterations) || maxIterations < 0) throw new Error("--max-iterations must be a non-negative integer; 0 means unlimited");
|
|
if (!Number.isSafeInteger(pollMs) || pollMs < 0) throw new Error("--poll-ms must be a non-negative integer");
|
|
if (!Number.isSafeInteger(pushRetries) || pushRetries < 0) throw new Error("--push-retries must be a non-negative integer");
|
|
if (pushEnabled && !commitEnabled) throw new Error("--push requires --commit");
|
|
|
|
fs.mkdirSync(abs(controlRoot), { recursive: true });
|
|
let lockHandle;
|
|
const acquireLock = () => {
|
|
try {
|
|
return fs.openSync(abs(lockPath), "wx");
|
|
}
|
|
catch (error) {
|
|
if (error?.code !== "EEXIST") throw error;
|
|
try {
|
|
const lock = JSON.parse(fs.readFileSync(abs(lockPath), "utf8"));
|
|
if (Number.isSafeInteger(lock.pid)) {
|
|
try { process.kill(lock.pid, 0); }
|
|
catch (probeError) {
|
|
if (probeError?.code === "ESRCH") {
|
|
fs.unlinkSync(abs(lockPath));
|
|
return fs.openSync(abs(lockPath), "wx");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch {
|
|
// An unreadable lock is treated as owned to prevent concurrent writers.
|
|
}
|
|
throw new Error(`another WBV2 scheduler appears to be running; lock=${lockPath}`);
|
|
}
|
|
};
|
|
|
|
function writeCheckpoint(payload) {
|
|
const next = {
|
|
schemaVersion: 1,
|
|
pid: process.pid,
|
|
updatedAt: new Date().toISOString(),
|
|
...payload,
|
|
};
|
|
const stable = (value) => { const { pid, updatedAt, ...rest } = value ?? {}; return rest; };
|
|
try {
|
|
const current = JSON.parse(read(checkpointPath));
|
|
if (JSON.stringify(stable(current)) === JSON.stringify(stable(next))) return;
|
|
}
|
|
catch { /* The first checkpoint or an interrupted write is not reusable. */ }
|
|
const temporaryPath = `${checkpointPath}.tmp-${process.pid}`;
|
|
fs.writeFileSync(abs(temporaryPath), `${JSON.stringify(next, null, 2)}\n`);
|
|
fs.renameSync(abs(temporaryPath), abs(checkpointPath));
|
|
}
|
|
|
|
function appendLog(message) {
|
|
fs.appendFileSync(abs(logPath), `[${new Date().toISOString()}] ${message}\n`);
|
|
}
|
|
|
|
function read(file) {
|
|
return fs.readFileSync(abs(file), "utf8");
|
|
}
|
|
|
|
function currentTask() {
|
|
const queue = read("docs/EXECUTION_QUEUE.md");
|
|
const task = queue.match(/\| 当前任务 \| `(WBV2-P\d+-\d+)` \|/u)?.[1];
|
|
const parentManifest = queue.match(/\| parent manifest \| `([^`]+)` \|/u)?.[1];
|
|
if (!task && /队列.*(闭合|完成)|queue.*(closed|complete)/iu.test(queue)) return null;
|
|
if (!task || !parentManifest) throw new Error("queue pointer is incomplete");
|
|
return { task, parentManifest };
|
|
}
|
|
function terminalTask(task) {
|
|
try {
|
|
const index = JSON.parse(read("tests/golden/WBV2/task-index.json"));
|
|
const manifestPath = `tests/golden/${task}/manifest.json`;
|
|
const manifest = fs.existsSync(abs(manifestPath)) ? JSON.parse(read(manifestPath)) : null;
|
|
return index.activeTask === null && manifest?.task === task && manifest.status === "done" && manifest.nextTask === null;
|
|
}
|
|
catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function parseTask(task) {
|
|
const match = task.match(/^WBV2-P(\d+)-(00[0-3])$/u);
|
|
if (!match) return { phase: null, index: null, taskClass: "UNKNOWN" };
|
|
const index = Number(match[2]);
|
|
return {
|
|
phase: Number(match[1]),
|
|
index,
|
|
taskClass: index === 1 ? "QUEUE_ENABLEMENT" : index === 2 ? "SOURCE_IMPLEMENTATION" : index === 3 ? "INTEGRATION_BUILD" : "QUEUE_ENABLEMENT",
|
|
};
|
|
}
|
|
|
|
function parentManifest(pointer) {
|
|
const manifest = JSON.parse(read(pointer.parentManifest));
|
|
if (manifest.status !== "done" || manifest.nextTask !== pointer.task) {
|
|
throw new Error(`parent manifest does not authorize task=${pointer.task}: ${pointer.parentManifest}`);
|
|
}
|
|
return manifest;
|
|
}
|
|
|
|
function sourceMappingReadiness(pointer) {
|
|
const { phase, index, taskClass } = parseTask(pointer.task);
|
|
const cardPath = `docs/tasks/${pointer.task}.md`;
|
|
if (!fs.existsSync(abs(cardPath))) return { ok: false, reason: "task_card_missing", taskClass };
|
|
const card = read(cardPath);
|
|
const implementation = card.match(/- Implementation entrypoint: `([^`]+)`/u)?.[1];
|
|
if (!implementation) return { ok: false, reason: "implementation_entrypoint_missing", taskClass };
|
|
|
|
// Continuation source tasks must have an explicit, non-generic phase mapping.
|
|
// This prevents a long-running loop from replaying an older marker forever.
|
|
if (taskClass === "SOURCE_IMPLEMENTATION" && implementation.includes("generate-wbv2-capability-continuation-slice.mjs")) {
|
|
const generator = read("tools/web/generate-wbv2-capability-continuation-slice.mjs");
|
|
const phaseBlock = generator.match(new RegExp(`(?:^|\\n)(?:else )?if \\(phase === ${phase}\\) \\{([\\s\\S]*?)(?=\\n(?:else )?if \\(phase ===|\\nelse if \\(phase >=|\\nfor \\(const file)`, "m"))?.[1];
|
|
if (!phaseBlock) return { ok: false, reason: `source_mapping_missing_phase_${phase}`, taskClass, phase };
|
|
const marker = phaseBlock.match(/markers\[2\] = "([^"]+)"/u)?.[1];
|
|
if (!marker) return { ok: false, reason: `source_mapping_missing_marker_${phase}`, taskClass, phase };
|
|
const genericMarkers = new Set([
|
|
"capability-family-workbench",
|
|
"web_engine_blend_main_set_world_lightgroup",
|
|
"web_engine_blend_main_set_object_lightgroup",
|
|
"web_engine_blend_main_set_scene_view_layer_lightgroups",
|
|
"WEB_ENGINE_COMMAND_CAPABILITIES",
|
|
]);
|
|
if (genericMarkers.has(marker)) return { ok: false, reason: `source_mapping_generic_marker_${marker}`, taskClass, phase, marker };
|
|
const firstSource = phaseBlock.match(/files\[2\] = \[\s*"([^"]+)"/u)?.[1];
|
|
if (!firstSource || !fs.existsSync(abs(firstSource))) return { ok: false, reason: "source_mapping_first_file_missing", taskClass, phase, marker, firstSource };
|
|
if (!read(firstSource).includes(marker)) return { ok: false, reason: "source_behavior_marker_missing", taskClass, phase, marker, firstSource };
|
|
return { ok: true, taskClass, phase, marker, firstSource, implementation };
|
|
}
|
|
|
|
if (index === 3) {
|
|
const parent = parentManifest(pointer);
|
|
if (parent.taskClass !== "SOURCE_IMPLEMENTATION" || parent.assertions?.sourceBacked !== true) {
|
|
return { ok: false, reason: "integration_parent_not_source_backed", taskClass, parentTask: parent.task };
|
|
}
|
|
}
|
|
return { ok: true, taskClass, implementation };
|
|
}
|
|
|
|
function runOne(pointer) {
|
|
const outputPath = `tests/golden/${pointer.task}/scheduler-child.log`;
|
|
fs.mkdirSync(abs(`tests/golden/${pointer.task}`), { recursive: true });
|
|
const args = ["tools/web/run-wbv2-guardian.mjs", "--max-iterations", "1", "--max-restarts", "0"];
|
|
if (commitEnabled) args.push("--commit");
|
|
if (pushEnabled) args.push("--push", "--push-retries", String(pushRetries));
|
|
const result = spawnSync(process.execPath, args, {
|
|
cwd: root,
|
|
encoding: "utf8",
|
|
maxBuffer: 32 * 1024 * 1024,
|
|
});
|
|
const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
|
|
fs.writeFileSync(abs(outputPath), output);
|
|
return { code: result.status ?? 1, signal: result.signal, outputPath, args };
|
|
}
|
|
|
|
let stopRequested = false;
|
|
let stopSignal;
|
|
process.once("SIGINT", () => { stopRequested = true; stopSignal = "SIGINT"; });
|
|
process.once("SIGTERM", () => { stopRequested = true; stopSignal = "SIGTERM"; });
|
|
|
|
lockHandle = acquireLock();
|
|
fs.writeFileSync(lockHandle, `${JSON.stringify({ pid: process.pid, startedAt: new Date().toISOString() })}\n`);
|
|
let released = false;
|
|
const releaseLock = () => {
|
|
if (released) return;
|
|
released = true;
|
|
fs.closeSync(lockHandle);
|
|
try { fs.unlinkSync(abs(lockPath)); }
|
|
catch (error) { if (error?.code !== "ENOENT") throw error; }
|
|
};
|
|
|
|
let exitCode = 0;
|
|
let iteration = 0;
|
|
let completed = false;
|
|
try {
|
|
appendLog(`started pid=${process.pid} maxIterations=${maxIterations} commit=${commitEnabled} push=${pushEnabled}`);
|
|
writeCheckpoint({ state: "started", iteration, current: currentTask(), maxIterations, commit: commitEnabled, push: pushEnabled });
|
|
while (maxIterations === 0 || iteration < maxIterations) {
|
|
if (stopRequested) {
|
|
writeCheckpoint({ state: "stopped", iteration, current: currentTask(), reason: stopSignal });
|
|
exitCode = stopSignal === "SIGINT" ? 130 : 143;
|
|
break;
|
|
}
|
|
const before = currentTask();
|
|
if (!before) {
|
|
writeCheckpoint({ state: "complete", iteration, current: null, reason: "queue_closed" });
|
|
appendLog(`complete queue_closed iteration=${iteration}`);
|
|
completed = true;
|
|
break;
|
|
}
|
|
// A terminal V2 plan keeps the last completed task as an auditable queue
|
|
// pointer. Close cleanly instead of replaying that module through the
|
|
// guardian/supervisor chain.
|
|
try {
|
|
const index = JSON.parse(read("tests/golden/WBV2/task-index.json"));
|
|
if (index.activeTask === null && index.entries?.[before.task]) {
|
|
writeCheckpoint({ state: "complete", iteration, current: before, reason: "v2_plan_terminal" });
|
|
appendLog(`complete v2_plan_terminal task=${before.task} iteration=${iteration}`);
|
|
completed = true;
|
|
break;
|
|
}
|
|
}
|
|
catch (error) {
|
|
recordFailure(root, { task: before.task, phase: "scheduler", reason: "terminal_plan_check_failed", detail: error?.message ?? String(error) });
|
|
writeCheckpoint({ state: "blocked", iteration, before, reason: "terminal_plan_check_failed", error: error?.message ?? String(error) });
|
|
appendLog(`blocked task=${before.task} reason=terminal_plan_check_failed error=${error?.message ?? String(error)}`);
|
|
process.stderr.write(`scheduler-blocked task=${before.task} reason=terminal_plan_check_failed\n`);
|
|
exitCode = 2;
|
|
break;
|
|
}
|
|
let readiness;
|
|
try {
|
|
readiness = sourceMappingReadiness(before);
|
|
}
|
|
catch (error) {
|
|
readiness = { ok: false, reason: "readiness_error", error: error?.message ?? String(error) };
|
|
}
|
|
writeCheckpoint({ state: "preflight", iteration, before, readiness });
|
|
appendLog(`preflight task=${before.task} class=${readiness.taskClass ?? "UNKNOWN"} ok=${readiness.ok} reason=${readiness.reason ?? "ready"}`);
|
|
if (!readiness.ok) {
|
|
recordFailure(root, { task: before.task, phase: "scheduler", reason: readiness.reason });
|
|
writeCheckpoint({ state: "blocked", iteration, before, readiness });
|
|
appendLog(`blocked task=${before.task} reason=${readiness.reason}`);
|
|
process.stderr.write(`scheduler-blocked task=${before.task} reason=${readiness.reason}\n`);
|
|
exitCode = 2;
|
|
break;
|
|
}
|
|
if (preflightOnly) {
|
|
writeCheckpoint({ state: "preflight_ready", iteration, before, readiness });
|
|
process.stdout.write(`scheduler-preflight-ready task=${before.task} class=${readiness.taskClass}\n`);
|
|
break;
|
|
}
|
|
writeCheckpoint({ state: "running", iteration: iteration + 1, before, readiness });
|
|
const child = runOne(before);
|
|
const after = currentTask();
|
|
appendLog(`child task=${before.task} exit=${child.code} signal=${child.signal ?? "none"} after=${after?.task ?? "NONE"} log=${child.outputPath}`);
|
|
if (stopRequested) {
|
|
writeCheckpoint({ state: "stopped", iteration, before, after, reason: stopSignal, childExit: child.code });
|
|
exitCode = stopSignal === "SIGINT" ? 130 : 143;
|
|
break;
|
|
}
|
|
if (child.code !== 0) {
|
|
const reason = after?.task !== before.task ? "child_failed_after_queue_advance" : "child_failed_same_task";
|
|
recordFailure(root, { task: before.task, phase: "scheduler", reason, childExit: child.code });
|
|
writeCheckpoint({ state: "blocked", iteration, before, after, reason, childExit: child.code, childLog: child.outputPath });
|
|
appendLog(`blocked task=${before.task} reason=${reason}`);
|
|
process.stderr.write(`scheduler-blocked task=${before.task} reason=${reason} childExit=${child.code}\n`);
|
|
exitCode = 3;
|
|
break;
|
|
}
|
|
if (after && after.task === before.task && terminalTask(before.task)) {
|
|
writeCheckpoint({ state: "complete", iteration: iteration + 1, before, after, childExit: child.code, reason: "terminal_module_complete", childLog: child.outputPath });
|
|
completed = true;
|
|
iteration += 1;
|
|
break;
|
|
}
|
|
if (!after || after.task === before.task) {
|
|
recordFailure(root, { task: before.task, phase: "scheduler", reason: "child_exited_without_queue_advance", childExit: child.code });
|
|
writeCheckpoint({ state: "blocked", iteration, before, after, reason: "child_exited_without_queue_advance", childExit: child.code, childLog: child.outputPath });
|
|
appendLog(`blocked task=${before.task} reason=child_exited_without_queue_advance`);
|
|
process.stderr.write(`scheduler-blocked task=${before.task} reason=child_exited_without_queue_advance\n`);
|
|
exitCode = 4;
|
|
break;
|
|
}
|
|
iteration += 1;
|
|
writeCheckpoint({ state: "handed_off", iteration, before, after, childLog: child.outputPath });
|
|
process.stdout.write(`scheduler-iteration=${iteration} task=${before.task} next=${after.task}\n`);
|
|
if (pollMs > 0) {
|
|
const wait = new Int32Array(new SharedArrayBuffer(4));
|
|
Atomics.wait(wait, 0, 0, pollMs);
|
|
}
|
|
}
|
|
if (exitCode === 0 && !preflightOnly && !stopRequested) {
|
|
const current = currentTask();
|
|
const state = completed || maxIterations !== 0 ? "complete" : "running";
|
|
writeCheckpoint({ state, iteration, current });
|
|
appendLog(`stopped state=${state} iteration=${iteration} current=${current?.task ?? "NONE"}`);
|
|
}
|
|
}
|
|
catch (error) {
|
|
exitCode = 5;
|
|
try { recordFailure(root, { task: currentTask()?.task ?? "UNKNOWN", phase: "scheduler", reason: "scheduler_error", detail: error?.message ?? String(error) }); }
|
|
catch { /* Preserve the original scheduler failure. */ }
|
|
writeCheckpoint({ state: "blocked", iteration, reason: "scheduler_error", error: error?.message ?? String(error) });
|
|
appendLog(`blocked reason=scheduler_error error=${error?.message ?? String(error)}`);
|
|
}
|
|
finally {
|
|
releaseLock();
|
|
}
|
|
process.exitCode = exitCode;
|