Add a dormant sequential-fit coordinator

This commit is contained in:
salman committed 2026-08-30 12:51:27 +02:00
1 parent 8832bc9fb9
commit 9c3d9f4623
3 files changed
+559 -9

No files matched your search

+200 -9
View File
@@ -1496,6 +1496,18 @@ function seriesTransactionError(error, fallback) {
return error && error.message ? error.message : String(error || fallback || "operation-failed");
}
function isValidPreparedSeriesCandidate(candidate) {
return candidate && Number.isInteger(candidate.run) && candidate.run > 0
&& new Set(["fit", "retry", "refit"]).has(candidate.action)
&& typeof candidate.targetPath === "string" && candidate.targetPath !== ""
&& typeof candidate.text === "string"
&& (candidate.action == "fit"
|| (typeof candidate.expectedTargetText === "string"
&& candidate.expectedTargetText !== "")
|| (typeof candidate.expectedTargetHash === "string"
&& candidate.expectedTargetHash !== ""));
}
async function discardSeriesTransactionStages(adapter, staged, errors) {
for (let index = staged.length - 1; index >= 0; index--) {
let item = staged[index];
@@ -1566,18 +1578,10 @@ async function stageAndPromoteSeriesMSRCandidates(prepared, adapter, options = {
return result;
}
let allowedActions = new Set(["fit", "retry", "refit"]);
let targets = new Set();
let items = [];
for (let candidate of prepared.candidates) {
if (!candidate || !allowedActions.has(candidate.action)
|| typeof candidate.targetPath !== "string" || candidate.targetPath === ""
|| typeof candidate.text !== "string"
|| (candidate.action != "fit"
&& (typeof candidate.expectedTargetText !== "string"
|| candidate.expectedTargetText === "")
&& (typeof candidate.expectedTargetHash !== "string"
|| candidate.expectedTargetHash === ""))) {
if (!isValidPreparedSeriesCandidate(candidate)) {
result.reason = "invalid-series-candidate";
return result;
}
@@ -1879,6 +1883,193 @@ async function finalizeSeriesMSRTransaction(transaction, adapter, decision) {
return result;
}
function seriesRunResultSucceeded(runResult) {
if (!runResult || typeof runResult !== "object"
|| (runResult.ok !== true && runResult.ok !== 1)) {
return false;
}
if (runResult.code !== undefined && runResult.code !== null
&& Number(runResult.code) !== 0) {
return false;
}
if (runResult.signal) return false;
return !runResult.outcome || runResult.outcome == "success";
}
function seriesSequenceTransactionId(sequenceId, candidate, index) {
let suffix = "-" + (index + 1) + "-" + candidate.run;
return normalizeSeriesTransactionId(
sequenceId.substring(0, Math.max(1, 64 - suffix.length)) + suffix
);
}
// Run prepared independent fits in strict sequence. Each candidate gets its
// own transaction so a successfully committed prefix survives a later failure.
// The injected runner is the only operation that may execute musrfit; this
// shared helper itself has no process, CGI, UI, or platform dependency.
// It remains disconnected from startFit() until the platform runner adapters
// and user-facing progress/cancellation behavior are added.
async function runPreparedSeriesFitSequence(
prepared, transactionAdapter, runCandidate, options = {}
) {
let sequenceId = normalizeSeriesTransactionId(options.transactionId);
let result = {
ok: false,
reason: "invalid-prepared-series",
sequenceId: sequenceId,
completed: [],
excluded: prepared && Array.isArray(prepared.excluded)
? prepared.excluded.slice() : [],
failed: null
};
if (!prepared || prepared.ok !== true || !Array.isArray(prepared.candidates)) {
return result;
}
if (typeof runCandidate !== "function") {
result.reason = "series-runner-unavailable";
return result;
}
// Validate the complete sequence before staging the first run. Per-run
// transactions would otherwise allow malformed later input to be discovered
// only after an earlier fit had already committed.
let targets = new Set();
for (let candidate of prepared.candidates) {
if (!isValidPreparedSeriesCandidate(candidate)
|| targets.has(candidate.targetPath)) {
result.reason = targets.has(candidate && candidate.targetPath)
? "duplicate-series-target" : "invalid-series-candidate";
return result;
}
targets.add(candidate.targetPath);
}
let blocked = result.excluded.filter(function(entry) {
return entry && entry.action == "blocked";
});
if (prepared.candidates.length === 0) {
result.ok = blocked.length === 0;
result.reason = blocked.length > 0
? "series-no-runnable-candidates" : "series-already-complete";
return result;
}
for (let index = 0; index < prepared.candidates.length; index++) {
let candidate = prepared.candidates[index];
let transaction = await stageAndPromoteSeriesMSRCandidates(
{ ok: true, candidates: [candidate] },
transactionAdapter,
{ transactionId: seriesSequenceTransactionId(sequenceId, candidate, index) }
);
if (!transaction.ok) {
result.reason = "series-candidate-staging-failed";
result.failed = {
run: candidate.run,
action: candidate.action,
targetPath: candidate.targetPath,
phase: "stage",
transaction: transaction
};
return result;
}
let receipt = transaction.receipts[0];
if (transaction.receipts.length !== 1 || !receipt
|| receipt.run !== candidate.run
|| receipt.targetPath !== candidate.targetPath) {
result.reason = "series-candidate-stage-uncertain";
result.failed = {
run: candidate.run,
action: candidate.action,
targetPath: candidate.targetPath,
phase: "stage",
transaction: transaction
};
return result;
}
let runResult;
try {
runResult = await runCandidate(receipt, candidate, {
index: index,
position: index + 1,
total: prepared.candidates.length,
sequenceId: sequenceId,
transactionId: transaction.transactionId,
referenceRun: prepared.referenceRun || 0
});
} catch (error) {
runResult = {
ok: false,
code: null,
error: seriesTransactionError(error, "series-runner-failed")
};
}
if (!seriesRunResultSucceeded(runResult)) {
let rollback = await finalizeSeriesMSRTransaction(
transaction, transactionAdapter, "rollback"
);
result.reason = rollback.ok
? "series-candidate-run-failed" : "series-candidate-rollback-failed";
result.failed = {
run: candidate.run,
action: candidate.action,
targetPath: candidate.targetPath,
phase: "run",
transactionId: transaction.transactionId,
runResult: runResult,
rollback: rollback
};
return result;
}
let commit = await finalizeSeriesMSRTransaction(
transaction, transactionAdapter, "commit"
);
if (!commit.ok) {
// A failed preflight is known to be mutation-free and can therefore
// be rolled back automatically. Transport and partial-finalization
// failures are ambiguous; preserve their manifest/backup for explicit
// recovery rather than guessing which side completed.
let rollback = null;
if (commit.reason == "series-finalization-preflight-failed") {
rollback = await finalizeSeriesMSRTransaction(
transaction, transactionAdapter, "rollback"
);
}
result.reason = rollback
? (rollback.ok
? "series-candidate-result-invalid" : "series-candidate-rollback-failed")
: "series-candidate-commit-uncertain";
result.failed = {
run: candidate.run,
action: candidate.action,
targetPath: candidate.targetPath,
phase: "commit",
transactionId: transaction.transactionId,
runResult: runResult,
commit: commit,
rollback: rollback
};
return result;
}
result.completed.push({
run: candidate.run,
action: candidate.action,
targetPath: candidate.targetPath,
transactionId: transaction.transactionId,
runResult: runResult
});
}
result.ok = blocked.length === 0;
result.reason = blocked.length > 0
? "series-sequence-completed-with-blocked-runs"
: "series-sequence-completed";
return result;
}
// Store only presentation-ready fit quality in the job state. Both web and
// Electron call this after reading the fitted MSR, keeping parsing independent
// of the transport used to run musrfit.
+43
View File
@@ -0,0 +1,43 @@
# Copyright (C) 2026 Zaher Salman
# SPDX-License-Identifier: GPL-3.0-or-later
# Minimal application/x-www-form-urlencoded parser used only by the repository
# tests when the host does not provide CGI.pm. Production continues to use the
# system CGI module and never deploys this tests/ directory.
package CGI;
use strict;
use warnings;
sub _decode_component {
my ($value) = @_;
$value = "" if !defined($value);
$value =~ tr/+/ /;
$value =~ s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg;
return $value;
}
sub new {
my ($class) = @_;
my $length = $ENV{CONTENT_LENGTH} || 0;
my $body = "";
read(STDIN, $body, $length) if $length > 0;
my %parameters = ();
foreach my $pair (split(/&/, $body, -1)) {
next if $pair eq "";
my ($key, $value) = split(/=/, $pair, 2);
$key = _decode_component($key);
$value = _decode_component($value);
push(@{$parameters{$key}}, $value);
}
return bless({ parameters => \%parameters }, $class);
}
sub param {
my ($self, $name) = @_;
return keys(%{$self->{parameters}}) if !defined($name);
my $values = $self->{parameters}{$name} || [];
return wantarray ? @{$values} : (@{$values} ? $values->[0] : undef);
}
1;
+316
View File
@@ -0,0 +1,316 @@
// Copyright (C) 2026 Zaher Salman
// SPDX-License-Identifier: GPL-3.0-or-later
const assert = require("assert");
const fs = require("fs");
const path = require("path");
const vm = require("vm");
const repoRoot = path.resolve(__dirname, "..");
function loadLibrary() {
const sandbox = { console: console, window: { MSREditor: {} } };
sandbox.global = sandbox;
vm.runInNewContext(
fs.readFileSync(path.join(repoRoot, "muSRFitlib.js"), "utf8"),
sandbox,
{ filename: "muSRFitlib.js" }
);
return sandbox;
}
function candidate(run, action, oldText) {
const result = {
run: run,
action: action,
targetPath: "/work/" + run + "_asy.msr",
text: "RUN " + run + "\n"
};
if (action !== "fit") result.expectedTargetText = oldText;
return result;
}
function prepared(candidates, excluded = []) {
return {
ok: true,
referenceRun: 514,
candidates: candidates,
excluded: excluded
};
}
function memoryTransactionAdapter(initialFiles = {}) {
const files = Object.assign({}, initialFiles);
const events = [];
return {
files: files,
events: events,
exists: async function(filePath) {
return Object.prototype.hasOwnProperty.call(files, filePath);
},
createExclusive: async function(filePath, text) {
if (Object.prototype.hasOwnProperty.call(files, filePath)) {
throw new Error("exclusive-create-collision");
}
events.push({ operation: "stage", path: filePath });
files[filePath] = text;
},
read: async function(filePath) {
return files[filePath];
},
promote: async function(item) {
if (item.replace) files[item.backupPath] = files[item.targetPath];
files[item.targetPath] = files[item.stagePath];
delete files[item.stagePath];
events.push({ operation: "promote", run: item.run });
return {
run: item.run,
action: item.action,
targetPath: item.targetPath,
backupPath: item.backupPath,
replaced: item.replace,
promotedText: item.expectedText,
originalText: item.replace ? files[item.backupPath] : ""
};
},
discard: async function(filePath) {
delete files[filePath];
},
verifyFinalize: async function(receipt, decision) {
if (!Object.prototype.hasOwnProperty.call(files, receipt.targetPath)) {
throw new Error("target-missing");
}
if (decision === "commit" && !/\nCONVERGED\n$/.test(files[receipt.targetPath])) {
throw new Error("target-not-converged");
}
if (receipt.replaced && files[receipt.backupPath] !== receipt.originalText) {
throw new Error("backup-changed");
}
},
commit: async function(receipt) {
await this.verifyFinalize(receipt, "commit");
if (receipt.replaced) delete files[receipt.backupPath];
events.push({ operation: "commit", run: receipt.run });
},
rollback: async function(receipt) {
if (receipt.replaced) {
files[receipt.targetPath] = files[receipt.backupPath];
delete files[receipt.backupPath];
} else {
delete files[receipt.targetPath];
}
events.push({ operation: "rollback", run: receipt.run });
}
};
}
async function testRunsAndCommitsOneAtATime(lib) {
const adapter = memoryTransactionAdapter({ "/work/516_asy.msr": "old-516" });
const runs = [];
const result = await lib.runPreparedSeriesFitSequence(
prepared([
candidate(515, "fit"),
candidate(516, "retry", "old-516")
], [{ run: 514, action: "skip" }]),
adapter,
async function(receipt, item, context) {
runs.push({ run: item.run, position: context.position, total: context.total });
adapter.events.push({ operation: "run", run: item.run });
adapter.files[receipt.targetPath] += "\nCONVERGED\n";
return { ok: true, code: 0 };
},
{ transactionId: "sequence" }
);
assert.strictEqual(result.ok, true);
assert.strictEqual(result.reason, "series-sequence-completed");
assert.deepStrictEqual(Array.from(result.completed.map(function(item) {
return item.run;
})), [515, 516]);
assert.deepStrictEqual(runs, [
{ run: 515, position: 1, total: 2 },
{ run: 516, position: 2, total: 2 }
]);
assert.deepStrictEqual(adapter.events.filter(function(event) {
return ["promote", "run", "commit"].includes(event.operation);
}), [
{ operation: "promote", run: 515 },
{ operation: "run", run: 515 },
{ operation: "commit", run: 515 },
{ operation: "promote", run: 516 },
{ operation: "run", run: 516 },
{ operation: "commit", run: 516 }
]);
assert.match(adapter.files["/work/515_asy.msr"], /CONVERGED/);
assert.match(adapter.files["/work/516_asy.msr"], /CONVERGED/);
assert.strictEqual(Object.keys(adapter.files).some(function(filePath) {
return /musrflow-(?:stage|backup)/.test(filePath);
}), false);
}
async function testFailureKeepsCommittedPrefix(lib) {
const adapter = memoryTransactionAdapter({
"/work/516_asy.msr": "old-516",
"/work/517_asy.msr": "old-517"
});
const attempted = [];
const result = await lib.runPreparedSeriesFitSequence(
prepared([
candidate(515, "fit"),
candidate(516, "retry", "old-516"),
candidate(517, "refit", "old-517")
]),
adapter,
async function(receipt, item) {
attempted.push(item.run);
adapter.files[receipt.targetPath] += "\nCONVERGED\n";
return item.run === 516 ? { ok: false, code: 2 } : { ok: true, code: 0 };
}
);
assert.strictEqual(result.ok, false);
assert.strictEqual(result.reason, "series-candidate-run-failed");
assert.deepStrictEqual(attempted, [515, 516]);
assert.deepStrictEqual(Array.from(result.completed.map(function(item) {
return item.run;
})), [515]);
assert.strictEqual(result.failed.run, 516);
assert.strictEqual(result.failed.rollback.ok, true);
assert.match(adapter.files["/work/515_asy.msr"], /CONVERGED/);
assert.strictEqual(adapter.files["/work/516_asy.msr"], "old-516");
assert.strictEqual(adapter.files["/work/517_asy.msr"], "old-517");
}
async function testExitCodeAndConvergenceBothMatter(lib) {
let adapter = memoryTransactionAdapter();
let result = await lib.runPreparedSeriesFitSequence(
prepared([candidate(515, "fit")]),
adapter,
async function(receipt) {
adapter.files[receipt.targetPath] += "\nCONVERGED\n";
return { ok: true, code: 3 };
}
);
assert.strictEqual(result.reason, "series-candidate-run-failed");
assert.strictEqual(Object.prototype.hasOwnProperty.call(
adapter.files, "/work/515_asy.msr"
), false);
adapter = memoryTransactionAdapter();
result = await lib.runPreparedSeriesFitSequence(
prepared([candidate(515, "fit")]),
adapter,
async function() {
return { ok: true, code: 0 };
}
);
assert.strictEqual(result.reason, "series-candidate-result-invalid");
assert.strictEqual(result.failed.phase, "commit");
assert.strictEqual(result.failed.rollback.ok, true);
assert.strictEqual(Object.prototype.hasOwnProperty.call(
adapter.files, "/work/515_asy.msr"
), false);
}
async function testBlockedRunsAreReportedAfterEligibleRuns(lib) {
const adapter = memoryTransactionAdapter();
const result = await lib.runPreparedSeriesFitSequence(
prepared(
[candidate(515, "fit")],
[{ run: 514, action: "skip" }, { run: 516, action: "blocked" }]
),
adapter,
async function(receipt) {
adapter.files[receipt.targetPath] += "\nCONVERGED\n";
return { ok: true, code: 0 };
}
);
assert.strictEqual(result.ok, false);
assert.strictEqual(result.reason, "series-sequence-completed-with-blocked-runs");
assert.strictEqual(result.completed.length, 1);
assert.strictEqual(result.excluded.length, 2);
}
async function testWholeSequenceIsValidatedBeforeWriting(lib) {
const adapter = memoryTransactionAdapter();
const result = await lib.runPreparedSeriesFitSequence(
prepared([
candidate(515, "fit"),
{ run: 516, action: "fit", targetPath: "", text: "bad" }
]),
adapter,
async function() {
throw new Error("runner must not be called");
}
);
assert.strictEqual(result.ok, false);
assert.strictEqual(result.reason, "invalid-series-candidate");
assert.deepStrictEqual(Object.keys(adapter.files), []);
assert.deepStrictEqual(adapter.events, []);
}
async function testMalformedRemoteReceiptIsNotRun(lib) {
let runnerCalled = false;
const result = await lib.runPreparedSeriesFitSequence(
prepared([candidate(515, "fit")]),
{
transactBatch: async function() {
return {
ok: true,
reason: "series-candidates-promoted",
receipts: [],
staged: [],
backups: []
};
}
},
async function() {
runnerCalled = true;
return { ok: true, code: 0 };
}
);
assert.strictEqual(result.ok, false);
assert.strictEqual(result.reason, "series-candidate-stage-uncertain");
assert.strictEqual(runnerCalled, false);
}
async function testAmbiguousCommitPreservesRecoveryFiles(lib) {
const adapter = memoryTransactionAdapter({ "/work/516_asy.msr": "old-516" });
adapter.commit = async function() {
throw new Error("injected-commit-failure");
};
const result = await lib.runPreparedSeriesFitSequence(
prepared([candidate(516, "retry", "old-516")]),
adapter,
async function(receipt) {
adapter.files[receipt.targetPath] += "\nCONVERGED\n";
return { ok: true, code: 0 };
}
);
assert.strictEqual(result.ok, false);
assert.strictEqual(result.reason, "series-candidate-commit-uncertain");
assert.strictEqual(result.failed.rollback, null);
assert.match(adapter.files["/work/516_asy.msr"], /CONVERGED/);
assert.strictEqual(Object.keys(adapter.files).some(function(filePath) {
return /musrflow-backup/.test(filePath)
&& adapter.files[filePath] === "old-516";
}), true);
assert.strictEqual(adapter.events.some(function(event) {
return event.operation === "rollback";
}), false);
}
(async function() {
const lib = loadLibrary();
await testRunsAndCommitsOneAtATime(lib);
await testFailureKeepsCommittedPrefix(lib);
await testExitCodeAndConvergenceBothMatter(lib);
await testBlockedRunsAreReportedAfterEligibleRuns(lib);
await testWholeSequenceIsValidatedBeforeWriting(lib);
await testMalformedRemoteReceiptIsNotRun(lib);
await testAmbiguousCommitPreservesRecoveryFiles(lib);
console.log("series fit runner tests passed");
})().catch(function(error) {
console.error(error);
process.exit(1);
});