Files
reverse-engineering-anything/src/process/DarwinCompilationRetirement.test.ts
T
00a3f4d2b9 fix(process): preserve Darwin snapshot and cleanup failures (#12100)
* fix(process): preserve Darwin opening snapshot failures

* fix(process): retain the exact Darwin helper cleanup owner

Transfer the failed helper-root capability across repeated prepare failures. Reuse that same owner for retirement and reader close so stale cleanup cannot remove a replacement helper.

Co-authored-by: Anandumv <anandumv@gmail.com>
Co-authored-by: nextjohnp7 <nextjohnp7@gmail.com>

* test(process): isolate retained cleanup and compiler acknowledgements

---------

Co-authored-by: Anandumv <anandumv@gmail.com>
Co-authored-by: nextjohnp7 <nextjohnp7@gmail.com>
2026-11-18 17:34:25 -05:00

272 lines
9.4 KiB
TypeScript

import { readNativeProcessIdentityMap } from "./ProcessOwnershipObservation.js";
import {
readProcessRunToken,
readProcessRunTokens,
} from "./ProcessRunTokenObservations.js";
import { ExecFileOutputCancelledError } from "./ExecFileOutput.js";
import { basename, dirname, join } from "node:path";
import { tmpdir } from "node:os";
import { access, mkdir, readFile, writeFile } from "node:fs/promises";
import { expect, it, onTestFinished, vi } from "vitest";
import { createTestTempDirectory } from "../../tests/fixtures/temporaryDirectory.js";
import { awaitAcknowledgement } from "../../tests/fixtures/lifecycleAcknowledgement.js";
import { ProviderCleanupError } from "../domain/providerCleanupError.js";
import { RetainedCommandCleanup } from "./RetainedCommandCleanup.js";
const fixture = vi.hoisted(() => {
let start!: () => void;
let aborted!: () => void;
let release!: () => void;
let started: Promise<void>;
let stopped: Promise<void>;
let gate: Promise<void>;
let mode: "failure" | "abort" | "cleanup" | "abort-error";
let remainingRemovalFailures = 0;
let calls = 0;
const compilerFailure = new Error("controlled compiler failure");
const compilerAbortError = new DOMException(
"independent compiler failure",
"AbortError",
);
return {
compilerFailure,
compilerAbortError,
configure(
selected: "failure" | "abort" | "cleanup" | "abort-error",
removalFailures = selected === "cleanup" ? 1 : 0,
) {
remainingRemovalFailures = removalFailures;
mode = selected;
calls = 0;
started = new Promise((resolve) => {
start = resolve;
});
stopped = new Promise((resolve) => {
aborted = resolve;
});
gate = new Promise((resolve) => {
release = resolve;
});
},
remove() {
if (remainingRemovalFailures > 0) {
remainingRemovalFailures--;
throw new Error("controlled cleanup failure");
}
},
allowRemoval() {
remainingRemovalFailures = 0;
},
get started() {
return started;
},
get stopped() {
return stopped;
},
release() {
release();
},
get calls() {
return calls;
},
async run(
path: string,
args: readonly string[],
options: { signal?: AbortSignal },
) {
if (basename(path) !== "fixture-swiftc")
throw new Error("unexpected helper");
calls++;
if (calls === 1) {
options.signal?.addEventListener("abort", aborted, { once: true });
start();
await gate;
if (mode === "abort-error") throw compilerAbortError;
if (mode !== "failure")
throw new ExecFileOutputCancelledError(options.signal?.reason);
throw compilerFailure;
}
const output = args[args.indexOf("-o") + 1];
if (output === undefined) throw new Error("missing output");
await writeFile(output, "fixture");
return { stdout: "", stderr: "", stdoutBytes: 0, stderrBytes: 0 };
},
};
});
vi.mock("node:fs/promises", async (importOriginal) => {
const actual = await importOriginal<typeof import("node:fs/promises")>();
return {
...actual,
rm: async (...args: Parameters<typeof actual.rm>) => {
if (String(args[0]).includes("rea-process-token-")) fixture.remove();
return actual.rm(...args);
},
};
});
vi.mock("./ExecFileOutput.js", async (importOriginal) => ({
...(await importOriginal<typeof import("./ExecFileOutput.js")>()),
execFileOutput: fixture.run,
}));
import {
createDarwinProcessRunTokenReader,
DarwinProcessOwnershipInspectionError,
} from "./DarwinProcessRunTokenReader.js";
const createFixtureReader = () =>
createDarwinProcessRunTokenReader({
compiler: {
kind: "swiftc",
executable: join(tmpdir(), "fixture-swiftc"),
sdkRoot: tmpdir(),
},
environment: {},
});
it.each(["failure", "abort", "cleanup", "abort-error"] as const)(
"handles a %s outcome for a waiter joining retirement",
async (mode) => {
fixture.configure(mode);
const reader = createFixtureReader();
const controller = new AbortController();
const first = reader.prepare(controller.signal);
let second: Promise<string> | undefined;
onTestFinished(async () => {
fixture.release();
await Promise.allSettled([first, second, reader.close()]);
});
await awaitAcknowledgement(fixture.started, first, "compiler startup");
controller.abort(new Error("first caller left"));
await awaitAcknowledgement(fixture.stopped, first, "compiler cancellation");
second = reader.prepare();
fixture.release();
if (mode === "cleanup")
await expect(first).rejects.toMatchObject({
cause: expect.objectContaining({ message: "first caller left" }),
});
else
await expect(first).rejects.toMatchObject({
reason: expect.objectContaining({ message: "first caller left" }),
});
if (mode === "failure" || mode === "abort-error") {
await expect(second).rejects.toMatchObject({
cause:
mode === "failure"
? fixture.compilerFailure
: fixture.compilerAbortError,
});
expect(fixture.calls).toBe(1);
} else if (mode === "cleanup") {
const failure = await second.then(
() => undefined,
(cause: unknown) => cause,
);
expect(failure).toBeInstanceOf(DarwinProcessOwnershipInspectionError);
if (!(failure instanceof DarwinProcessOwnershipInspectionError))
throw new Error("expected cleanup owner");
expect(failure.cleanupFailure?.cleanupIncomplete).toBe(true);
expect(fixture.calls).toBe(1);
const rows = [
{
pid: 42,
parentPid: 1,
processGroupId: 42,
state: "S",
command: "fixture",
},
];
const fail = async (): Promise<never> => {
throw failure;
};
const host = {
listProcesses: async () => rows,
environment: fail,
runTokens: fail,
processIdentities: fail,
signalGroup: () => {
throw new Error("Unexpected signal");
},
};
const batch = async () => {
for await (const _row of readProcessRunTokens(host, rows)) {
throw new Error(
"Retained inspector must not produce unavailable rows",
);
}
};
const observations = await Promise.all(
[
readNativeProcessIdentityMap(rows, host),
readProcessRunToken(host, 42),
batch(),
].map((pending) => pending.catch((cause: unknown) => cause)),
);
for (const observation of observations) expect(observation).toBe(failure);
await failure.cleanupOwner?.close();
expect(failure.cleanupFailure?.cleanupIncomplete).toBe(false);
} else {
await expect(second).resolves.toMatch(/reader$/);
expect(fixture.calls).toBe(2);
}
},
);
it("transfers the same helper root after a second failed cleanup", async () => {
fixture.configure("failure", 2);
const reader = createFixtureReader();
const prepare = reader.prepare();
const first = prepare.catch((cause: unknown) => cause);
onTestFinished(async () => {
fixture.release();
await first;
fixture.allowRemoval();
await reader.close();
});
await awaitAcknowledgement(fixture.started, prepare, "compiler startup");
fixture.release();
const initialFailure = await first;
if (!(initialFailure instanceof DarwinProcessOwnershipInspectionError))
throw new Error("Expected the initial inspection cleanup failure", {
cause: initialFailure,
});
const [root] = initialFailure.cleanupFailure?.cleanupResources ?? [];
if (root === undefined) throw new Error("Missing retained helper root");
expect(initialFailure.cause).toBe(fixture.compilerFailure);
expect(initialFailure.cleanupFailure?.cleanupIncomplete).toBe(true);
await expect(access(root)).resolves.toBeUndefined();
const retryFailure = await reader.prepare().catch((cause: unknown) => cause);
if (!(retryFailure instanceof DarwinProcessOwnershipInspectionError))
throw new Error("Expected the retry inspection cleanup failure", {
cause: retryFailure,
});
const owner = retryFailure.cleanupOwner;
if (owner === undefined) throw new Error("Missing retry cleanup owner");
expect(owner).toBe(initialFailure.cleanupOwner);
expect(retryFailure.cleanupFailure).toBeInstanceOf(ProviderCleanupError);
expect(retryFailure.cleanupFailure?.cleanupResources).toEqual([root]);
expect(retryFailure.cleanupFailure?.cleanupIncomplete).toBe(true);
expect(fixture.calls).toBe(1);
const fixtureDirectory = await createTestTempDirectory(
"rea-retained-command-",
);
const scratch = join(fixtureDirectory, "command");
await mkdir(scratch);
const retained = new RetainedCommandCleanup(scratch, retryFailure);
try {
expect(retained.cleanupResources).toEqual([root, scratch]);
} finally {
await retained.close();
}
await expect(access(fixtureDirectory)).resolves.toBeUndefined();
await expect(access(scratch)).rejects.toMatchObject({ code: "ENOENT" });
await expect(access(root)).rejects.toMatchObject({ code: "ENOENT" });
expect(initialFailure.cleanupFailure?.cleanupIncomplete).toBe(false);
expect(retryFailure.cleanupFailure?.cleanupIncomplete).toBe(false);
const replacement = await reader.prepare();
expect(dirname(replacement)).not.toBe(root);
await owner.close();
await expect(readFile(replacement, "utf8")).resolves.toBe("fixture");
});