mirror of
https://github.com/morluto/rea
synced 2026-10-27 14:42:18 -04:00
morluto
649 lines
25 KiB
TypeScript
649 lines
25 KiB
TypeScript
import { createHash } from "node:crypto";
|
|
import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
|
|
import { tmpdir } from "node:os";
|
|
import { join } from "node:path";
|
|
import { expect, it, vi } from "vitest";
|
|
|
|
const limitReport = [
|
|
"Max address space unlimited unlimited bytes",
|
|
"Max cpu time unlimited unlimited seconds",
|
|
"Max file size unlimited unlimited bytes",
|
|
].join("\n");
|
|
|
|
const closeState = vi.hoisted(() => ({
|
|
path: "",
|
|
failures: 0,
|
|
onClosed: undefined as (() => void) | undefined,
|
|
onLimits: undefined as (() => void) | undefined,
|
|
}));
|
|
|
|
vi.mock("node:fs/promises", async (importOriginal) => {
|
|
const fs = await importOriginal<typeof import("node:fs/promises")>();
|
|
return {
|
|
...fs,
|
|
open: async (...args: Parameters<typeof fs.open>) => {
|
|
const handle = await fs.open(...args);
|
|
if (args[0] !== closeState.path) return handle;
|
|
const close = handle.close.bind(handle);
|
|
handle.close = async () => {
|
|
if (closeState.failures > 0) {
|
|
closeState.failures--;
|
|
throw new Error("injected EVM artifact descriptor close failure");
|
|
}
|
|
await close();
|
|
closeState.onClosed?.();
|
|
};
|
|
return handle;
|
|
},
|
|
readFile: async (...args: Parameters<typeof fs.readFile>) => {
|
|
if (args[0] !== "/proc/self/limits") return fs.readFile(...args);
|
|
closeState.onLimits?.();
|
|
return limitReport;
|
|
},
|
|
};
|
|
});
|
|
|
|
import { EvmoleInterfaceProvider } from "../../../src/evm/EvmoleInterfaceProvider.js";
|
|
import { spawnOwnedProviderProcess } from "../../../src/process/ProviderProcess.js";
|
|
import { cleanupOwnedProcessGroup } from "../../../src/process/ProcessOwnership.js";
|
|
import { PrivateRuntimeRoot } from "../../../src/process/PrivateRuntimeRoot.js";
|
|
import { projectAnalysisError } from "../../../src/domain/analysisErrorProjection.js";
|
|
import { waitForProviderProcessReady } from "../../fixtures/providerProcess.js";
|
|
import { EvmInterfaceService } from "../../../src/application/evm/EvmInterfaceService.js";
|
|
import { AnalysisCancelledError } from "../../../src/domain/analysisErrorCore.js";
|
|
|
|
it.each(["pre-aborted", "admission", "close"] as const)(
|
|
"preserves opaque caller reasons through service cancellation at %s",
|
|
async (stage) => {
|
|
const platform = Object.getOwnPropertyDescriptor(process, "platform");
|
|
const arch = Object.getOwnPropertyDescriptor(process, "arch");
|
|
Object.defineProperty(process, "platform", { ...platform, value: "linux" });
|
|
Object.defineProperty(process, "arch", { ...arch, value: "x64" });
|
|
const workspace = await mkdtemp(join(tmpdir(), "rea-evm-artifact-cancel-"));
|
|
const input = join(workspace, "selected.hex");
|
|
await writeFile(input, "0x60006000f3\n");
|
|
const createRuntime = vi.fn(async () => {
|
|
throw new Error("Worker must not start");
|
|
});
|
|
const provider = new EvmoleInterfaceProvider(
|
|
{ REA_EVM_PRLIMIT_COMMAND: process.execPath },
|
|
undefined,
|
|
createRuntime,
|
|
);
|
|
try {
|
|
for (const reason of [
|
|
null,
|
|
"caller stopped",
|
|
{ requested: "stop" },
|
|
new Error("caller stopped"),
|
|
new AnalysisCancelledError("foreign", {
|
|
cleanup: { reason: "foreign owner", resources: ["foreign-resource"] },
|
|
}),
|
|
]) {
|
|
const controller = new AbortController();
|
|
let closed = false;
|
|
closeState.path = input;
|
|
closeState.onLimits =
|
|
stage === "admission" ? () => controller.abort(reason) : undefined;
|
|
closeState.onClosed = () => {
|
|
closed = true;
|
|
if (stage === "close") controller.abort(reason);
|
|
};
|
|
if (stage === "pre-aborted") controller.abort(reason);
|
|
const result = await new EvmInterfaceService(provider).inspect(
|
|
{ path: input, encoding: "hex" },
|
|
{ signal: controller.signal },
|
|
);
|
|
if (result.ok) throw new Error("Expected cancellation");
|
|
expect(result.error).toBeInstanceOf(AnalysisCancelledError);
|
|
expect(result.error.cause).toBe(reason);
|
|
expect(result.error.cleanupIncomplete).toBe(false);
|
|
expect(result.error.cleanupResources).toEqual([]);
|
|
expect(closed).toBe(stage === "close");
|
|
expect(createRuntime).not.toHaveBeenCalled();
|
|
}
|
|
} finally {
|
|
closeState.path = "";
|
|
closeState.onClosed = undefined;
|
|
closeState.onLimits = undefined;
|
|
await provider.close();
|
|
await rm(workspace, { recursive: true, force: true });
|
|
if (platform !== undefined)
|
|
Object.defineProperty(process, "platform", platform);
|
|
if (arch !== undefined) Object.defineProperty(process, "arch", arch);
|
|
}
|
|
},
|
|
);
|
|
|
|
it.each([
|
|
"completed",
|
|
"malformed-reply",
|
|
"cancelled-cleanup",
|
|
"physical-before-late-cancel",
|
|
] as const)(
|
|
"updates a returned cleanup error after later root release: %s",
|
|
async (scenario) => {
|
|
const platform = Object.getOwnPropertyDescriptor(process, "platform");
|
|
const arch = Object.getOwnPropertyDescriptor(process, "arch");
|
|
Object.defineProperty(process, "platform", { ...platform, value: "linux" });
|
|
Object.defineProperty(process, "arch", { ...arch, value: "x64" });
|
|
const workspace = await mkdtemp(join(tmpdir(), "rea-evm-cleanup-retry-"));
|
|
const input = join(workspace, "selected.hex");
|
|
await writeFile(input, "0x60006000f3\n");
|
|
let rootPath = "";
|
|
let closeAttempts = 0;
|
|
const controller = new AbortController();
|
|
const abortReason = { requested: "cancel during root cleanup" };
|
|
const provider = new EvmoleInterfaceProvider(
|
|
{ REA_EVM_PRLIMIT_COMMAND: process.execPath },
|
|
async (spawn) => {
|
|
// Emulate only Linux admission and limits; restore Darwin before the
|
|
// owned process captures and validates its real host identity.
|
|
if (platform !== undefined)
|
|
Object.defineProperty(process, "platform", platform);
|
|
if (arch !== undefined) Object.defineProperty(process, "arch", arch);
|
|
const requestPath = spawn.arguments.at(-1);
|
|
if (requestPath === undefined) throw new Error("Request path missing");
|
|
const request = JSON.parse(await readFile(requestPath, "utf8")) as {
|
|
reply_path: string;
|
|
};
|
|
if (
|
|
scenario === "malformed-reply" ||
|
|
scenario === "physical-before-late-cancel"
|
|
)
|
|
await writeFile(request.reply_path, "malformed worker reply");
|
|
else {
|
|
const bytes = Buffer.from("60006000f3", "hex");
|
|
await writeFile(
|
|
request.reply_path,
|
|
JSON.stringify({
|
|
ok: true,
|
|
version: "0.9.3",
|
|
bytecode: {
|
|
sha256: createHash("sha256").update(bytes).digest("hex"),
|
|
bytes: bytes.length,
|
|
hex: bytes.toString("hex"),
|
|
},
|
|
raw: { functions: [] },
|
|
}),
|
|
);
|
|
}
|
|
return spawnOwnedProviderProcess({
|
|
...spawn,
|
|
command: process.execPath,
|
|
arguments: [
|
|
"-e",
|
|
'process.stderr.write("controlled worker complete")',
|
|
],
|
|
});
|
|
},
|
|
async () => {
|
|
const runtime = await PrivateRuntimeRoot.create({
|
|
prefix: "rea-evm-cleanup-retry-",
|
|
});
|
|
rootPath = runtime.path;
|
|
const close = runtime.close.bind(runtime);
|
|
return {
|
|
path: runtime.path,
|
|
close: async () => {
|
|
closeAttempts++;
|
|
if (scenario === "cancelled-cleanup" && closeAttempts === 1)
|
|
controller.abort(abortReason);
|
|
if (
|
|
scenario === "physical-before-late-cancel" &&
|
|
closeAttempts === 1
|
|
) {
|
|
setImmediate(() => controller.abort(abortReason));
|
|
throw new Error("physical root close failure before late abort");
|
|
}
|
|
if (closeAttempts <= 2)
|
|
throw new Error("injected retryable root close failure");
|
|
await close();
|
|
},
|
|
};
|
|
},
|
|
);
|
|
|
|
try {
|
|
const result = await provider.inspect(
|
|
{ path: input, encoding: "hex" },
|
|
scenario === "cancelled-cleanup" ||
|
|
scenario === "physical-before-late-cancel"
|
|
? { signal: controller.signal }
|
|
: undefined,
|
|
);
|
|
expect(result.ok).toBe(false);
|
|
if (result.ok) throw new Error("Expected the first root close to fail");
|
|
const originalError = result.error;
|
|
if (scenario === "physical-before-late-cancel")
|
|
await new Promise<void>((resolve) => setImmediate(resolve));
|
|
expect(originalError.cleanupIncomplete).toBe(true);
|
|
expect(originalError.cleanupResources).toContain(rootPath);
|
|
if (scenario === "cancelled-cleanup")
|
|
expect(originalError.cleanupPrimary?.cause).toBe(abortReason);
|
|
if (scenario === "physical-before-late-cancel")
|
|
expect(originalError.cleanupPrimary?.cleanupIncomplete).not.toBe(true);
|
|
const closeFailure = await provider.close().then(
|
|
() => undefined,
|
|
(cause: unknown) => cause,
|
|
);
|
|
expect(closeFailure).toMatchObject({ cleanupIncomplete: true });
|
|
if (!(closeFailure instanceof Error))
|
|
throw new Error("Expected close cleanup failure");
|
|
const reportedCloseError = closeFailure as typeof originalError;
|
|
expect(reportedCloseError.cleanupResources).toContain(rootPath);
|
|
expect(closeAttempts).toBe(2);
|
|
await provider.close();
|
|
expect(closeAttempts).toBe(3);
|
|
await expect(stat(rootPath)).rejects.toMatchObject({
|
|
code: "ENOENT",
|
|
});
|
|
expect(originalError.cleanupIncomplete).toBe(false);
|
|
expect(originalError.cleanupResources).toEqual([]);
|
|
expect(reportedCloseError.cleanupIncomplete).toBe(false);
|
|
expect(reportedCloseError.cleanupResources).toEqual([]);
|
|
expect(projectAnalysisError(originalError).code).toBe(
|
|
scenario === "cancelled-cleanup"
|
|
? "cancelled"
|
|
: scenario === "malformed-reply" ||
|
|
scenario === "physical-before-late-cancel"
|
|
? "unreadable_output"
|
|
: "execution_failure",
|
|
);
|
|
} finally {
|
|
try {
|
|
await provider.close();
|
|
} catch {
|
|
// Preserve the assertion's original failure; the workspace cleanup follows.
|
|
}
|
|
await rm(workspace, { recursive: true, force: true });
|
|
if (platform !== undefined)
|
|
Object.defineProperty(process, "platform", platform);
|
|
if (arch !== undefined) Object.defineProperty(process, "arch", arch);
|
|
}
|
|
},
|
|
);
|
|
|
|
it("keeps descriptor cleanup in close aggregates until the exact file lease releases", async () => {
|
|
const platform = Object.getOwnPropertyDescriptor(process, "platform");
|
|
const arch = Object.getOwnPropertyDescriptor(process, "arch");
|
|
Object.defineProperty(process, "platform", { ...platform, value: "linux" });
|
|
Object.defineProperty(process, "arch", { ...arch, value: "x64" });
|
|
const workspace = await mkdtemp(join(tmpdir(), "rea-evm-descriptor-retry-"));
|
|
const input = join(workspace, "selected.hex");
|
|
await writeFile(input, "0x60006000f3\n");
|
|
closeState.path = input;
|
|
closeState.failures = 2;
|
|
const provider = new EvmoleInterfaceProvider({
|
|
REA_EVM_PRLIMIT_COMMAND: process.execPath,
|
|
});
|
|
try {
|
|
const result = await provider.inspect({ path: input, encoding: "hex" });
|
|
expect(result.ok).toBe(false);
|
|
if (result.ok) throw new Error("Expected an artifact descriptor failure");
|
|
expect(result.error.cleanupIncomplete).toBe(true);
|
|
const aggregate = await provider.close().then(
|
|
() => undefined,
|
|
(cause: unknown) => cause,
|
|
);
|
|
expect(aggregate).toMatchObject({
|
|
cleanupIncomplete: true,
|
|
cleanupResources: [input],
|
|
});
|
|
if (!(aggregate instanceof Error))
|
|
throw new Error("Expected a descriptor cleanup aggregate");
|
|
const returnedAggregate = aggregate as typeof result.error;
|
|
expect(result.error.cleanupIncomplete).toBe(true);
|
|
await provider.close();
|
|
expect(result.error.cleanupIncomplete).toBe(false);
|
|
expect(result.error.cleanupResources).toEqual([]);
|
|
expect(returnedAggregate.cleanupIncomplete).toBe(false);
|
|
expect(returnedAggregate.cleanupResources).toEqual([]);
|
|
} finally {
|
|
closeState.path = "";
|
|
closeState.failures = 0;
|
|
try {
|
|
await provider.close();
|
|
} catch {
|
|
// Preserve the assertion's original failure while releasing test files.
|
|
}
|
|
await rm(workspace, { recursive: true, force: true });
|
|
if (platform !== undefined)
|
|
Object.defineProperty(process, "platform", platform);
|
|
if (arch !== undefined) Object.defineProperty(process, "arch", arch);
|
|
}
|
|
});
|
|
|
|
it("keeps a mixed root and reply-descriptor aggregate pending until both owners release", async () => {
|
|
const platform = Object.getOwnPropertyDescriptor(process, "platform");
|
|
const arch = Object.getOwnPropertyDescriptor(process, "arch");
|
|
Object.defineProperty(process, "platform", { ...platform, value: "linux" });
|
|
Object.defineProperty(process, "arch", { ...arch, value: "x64" });
|
|
const workspace = await mkdtemp(join(tmpdir(), "rea-evm-mixed-owners-"));
|
|
const input = join(workspace, "selected.hex");
|
|
await writeFile(input, "0x60006000f3\n");
|
|
closeState.path = "";
|
|
closeState.failures = 0;
|
|
let replyPath = "";
|
|
let rootPath = "";
|
|
let rootCloseAttempts = 0;
|
|
const provider = new EvmoleInterfaceProvider(
|
|
{ REA_EVM_PRLIMIT_COMMAND: process.execPath },
|
|
async (spawn) => {
|
|
const requestPath = spawn.arguments.at(-1);
|
|
if (requestPath === undefined) throw new Error("Request path missing");
|
|
const request = JSON.parse(await readFile(requestPath, "utf8")) as {
|
|
reply_path: string;
|
|
};
|
|
replyPath = request.reply_path;
|
|
closeState.path = replyPath;
|
|
closeState.failures = 2;
|
|
await writeFile(replyPath, "malformed worker reply");
|
|
if (platform !== undefined)
|
|
Object.defineProperty(process, "platform", platform);
|
|
if (arch !== undefined) Object.defineProperty(process, "arch", arch);
|
|
return spawnOwnedProviderProcess({
|
|
...spawn,
|
|
command: process.execPath,
|
|
arguments: ["-e", 'process.stderr.write("controlled worker complete")'],
|
|
});
|
|
},
|
|
async () => {
|
|
const root = await PrivateRuntimeRoot.create({
|
|
prefix: "rea-evm-mixed-owners-",
|
|
});
|
|
rootPath = root.path;
|
|
const close = root.close.bind(root);
|
|
return {
|
|
path: root.path,
|
|
close: async () => {
|
|
rootCloseAttempts++;
|
|
if (rootCloseAttempts <= 3)
|
|
throw new Error("injected root cleanup refusal");
|
|
await close();
|
|
},
|
|
};
|
|
},
|
|
);
|
|
try {
|
|
const result = await provider.inspect({ path: input, encoding: "hex" });
|
|
expect(result.ok).toBe(false);
|
|
if (result.ok) throw new Error("Expected reply descriptor cleanup failure");
|
|
const original = result.error;
|
|
expect(original.cleanupIncomplete).toBe(true);
|
|
expect(original.cleanupResources).toContain(rootPath);
|
|
expect(original.cleanupResources).toContain(replyPath);
|
|
|
|
const firstAggregate = await provider.close().then(
|
|
() => undefined,
|
|
(cause: unknown) => cause,
|
|
);
|
|
expect(firstAggregate).toMatchObject({ cleanupIncomplete: true });
|
|
if (!(firstAggregate instanceof Error))
|
|
throw new Error("Expected mixed cleanup aggregate");
|
|
const retainedAggregate = firstAggregate as typeof original;
|
|
expect(retainedAggregate.cleanupResources).toContain(rootPath);
|
|
expect(retainedAggregate.cleanupResources).toContain(replyPath);
|
|
|
|
await expect(provider.close()).rejects.toMatchObject({
|
|
cleanupIncomplete: true,
|
|
cleanupResources: [rootPath],
|
|
});
|
|
expect(retainedAggregate.cleanupIncomplete).toBe(true);
|
|
expect(retainedAggregate.cleanupResources).toEqual([rootPath]);
|
|
expect(original.cleanupIncomplete).toBe(true);
|
|
expect(original.cleanupResources).toEqual([rootPath]);
|
|
|
|
await provider.close();
|
|
expect(retainedAggregate.cleanupIncomplete).toBe(false);
|
|
expect(retainedAggregate.cleanupResources).toEqual([]);
|
|
expect(original.cleanupIncomplete).toBe(false);
|
|
expect(original.cleanupResources).toEqual([]);
|
|
} finally {
|
|
closeState.path = "";
|
|
closeState.failures = 0;
|
|
try {
|
|
await provider.close();
|
|
} catch {
|
|
// Preserve the assertion's original failure while releasing test files.
|
|
}
|
|
await rm(workspace, { recursive: true, force: true });
|
|
if (platform !== undefined)
|
|
Object.defineProperty(process, "platform", platform);
|
|
if (arch !== undefined) Object.defineProperty(process, "arch", arch);
|
|
}
|
|
});
|
|
|
|
it("releases a retained process independently while a root cleanup retry remains pending", async () => {
|
|
const platform = Object.getOwnPropertyDescriptor(process, "platform");
|
|
const arch = Object.getOwnPropertyDescriptor(process, "arch");
|
|
Object.defineProperty(process, "platform", { ...platform, value: "linux" });
|
|
Object.defineProperty(process, "arch", { ...arch, value: "x64" });
|
|
const workspace = await mkdtemp(
|
|
join(tmpdir(), "rea-evm-process-root-retry-"),
|
|
);
|
|
const input = join(workspace, "selected.hex");
|
|
await writeFile(input, "0x60006000f3\n");
|
|
let rootPath = "";
|
|
let rootCloseAttempts = 0;
|
|
let cleanupAttempts = 0;
|
|
let allowProcessCleanup = false;
|
|
const provider = new EvmoleInterfaceProvider(
|
|
{ REA_EVM_PRLIMIT_COMMAND: process.execPath },
|
|
async (spawn) => {
|
|
const requestPath = spawn.arguments.at(-1);
|
|
if (requestPath === undefined) throw new Error("Request path missing");
|
|
const request = JSON.parse(await readFile(requestPath, "utf8")) as {
|
|
reply_path: string;
|
|
};
|
|
const bytes = Buffer.from("60006000f3", "hex");
|
|
await writeFile(
|
|
request.reply_path,
|
|
JSON.stringify({
|
|
ok: true,
|
|
version: "0.9.3",
|
|
bytecode: {
|
|
sha256: createHash("sha256").update(bytes).digest("hex"),
|
|
bytes: bytes.length,
|
|
hex: bytes.toString("hex"),
|
|
},
|
|
raw: { functions: [] },
|
|
}),
|
|
);
|
|
if (platform !== undefined)
|
|
Object.defineProperty(process, "platform", platform);
|
|
if (arch !== undefined) Object.defineProperty(process, "arch", arch);
|
|
const launched = await spawnOwnedProviderProcess({
|
|
...spawn,
|
|
command: process.execPath,
|
|
arguments: ["-e", 'process.stderr.write("worker complete")'],
|
|
});
|
|
const cleanup =
|
|
launched.cleanup ??
|
|
(() => cleanupOwnedProcessGroup(launched.ownership));
|
|
return {
|
|
...launched,
|
|
cleanup: async () => {
|
|
cleanupAttempts++;
|
|
if (!allowProcessCleanup)
|
|
throw new Error("injected retained process cleanup failure");
|
|
return cleanup();
|
|
},
|
|
};
|
|
},
|
|
async () => {
|
|
const root = await PrivateRuntimeRoot.create({
|
|
prefix: "rea-evm-process-root-retry-",
|
|
});
|
|
rootPath = root.path;
|
|
const close = root.close.bind(root);
|
|
return {
|
|
path: root.path,
|
|
close: async () => {
|
|
rootCloseAttempts++;
|
|
if (rootCloseAttempts === 1)
|
|
throw new Error("injected retained root cleanup failure");
|
|
await close();
|
|
},
|
|
};
|
|
},
|
|
);
|
|
try {
|
|
const result = await provider.inspect({ path: input, encoding: "hex" });
|
|
expect(result.ok).toBe(false);
|
|
if (result.ok) throw new Error("Expected retained process cleanup failure");
|
|
const original = result.error;
|
|
expect(original.cleanupIncomplete).toBe(true);
|
|
expect(original.cleanupResources).toContain(rootPath);
|
|
expect(original.partialObservation).toMatchObject({
|
|
normalized_result: {
|
|
bytecode: { hex: "60006000f3" },
|
|
evidence_kind: "inferred",
|
|
},
|
|
});
|
|
|
|
allowProcessCleanup = true;
|
|
const firstClose = await provider.close().then(
|
|
() => undefined,
|
|
(cause: unknown) => cause,
|
|
);
|
|
expect(firstClose).toMatchObject({
|
|
cleanupIncomplete: true,
|
|
cleanupResources: [rootPath],
|
|
});
|
|
expect(cleanupAttempts).toBe(2);
|
|
expect(rootCloseAttempts).toBe(1);
|
|
expect(original.cleanupIncomplete).toBe(true);
|
|
expect(original.cleanupResources).toEqual([rootPath]);
|
|
|
|
await provider.close();
|
|
expect(original.cleanupIncomplete).toBe(false);
|
|
expect(original.cleanupResources).toEqual([]);
|
|
expect(cleanupAttempts).toBe(2);
|
|
await expect(stat(rootPath)).rejects.toMatchObject({ code: "ENOENT" });
|
|
} finally {
|
|
allowProcessCleanup = true;
|
|
closeState.path = "";
|
|
closeState.failures = 0;
|
|
try {
|
|
await provider.close();
|
|
} catch {
|
|
// Preserve the assertion's original failure while releasing test files.
|
|
}
|
|
await rm(workspace, { recursive: true, force: true });
|
|
if (platform !== undefined)
|
|
Object.defineProperty(process, "platform", platform);
|
|
if (arch !== undefined) Object.defineProperty(process, "arch", arch);
|
|
}
|
|
});
|
|
|
|
it("preserves an active cancellation through denied owned-group cleanup and later retry", async () => {
|
|
const platform = Object.getOwnPropertyDescriptor(process, "platform");
|
|
const arch = Object.getOwnPropertyDescriptor(process, "arch");
|
|
Object.defineProperty(process, "platform", { ...platform, value: "linux" });
|
|
Object.defineProperty(process, "arch", { ...arch, value: "x64" });
|
|
const workspace = await mkdtemp(join(tmpdir(), "rea-evm-cancel-process-"));
|
|
const input = join(workspace, "selected.hex");
|
|
await writeFile(input, "0x60006000f3\n");
|
|
const controller = new AbortController();
|
|
const abortReason = { requested: "cancel the owned EVM worker" };
|
|
let rootPath = "";
|
|
let pid: number | undefined;
|
|
let cleanupAttempts = 0;
|
|
let allowRootClose = false;
|
|
const provider = new EvmoleInterfaceProvider(
|
|
{ REA_EVM_PRLIMIT_COMMAND: process.execPath },
|
|
async (spawn) => {
|
|
if (platform !== undefined)
|
|
Object.defineProperty(process, "platform", platform);
|
|
if (arch !== undefined) Object.defineProperty(process, "arch", arch);
|
|
const launched = await spawnOwnedProviderProcess({
|
|
...spawn,
|
|
command: process.execPath,
|
|
arguments: [
|
|
"-e",
|
|
'process.stdout.write("ready\\n");setInterval(()=>undefined,1000)',
|
|
],
|
|
});
|
|
pid = launched.process.pid;
|
|
await waitForProviderProcessReady(launched.process);
|
|
setImmediate(() => controller.abort(abortReason));
|
|
const cleanup =
|
|
launched.cleanup ??
|
|
(() => cleanupOwnedProcessGroup(launched.ownership));
|
|
return {
|
|
...launched,
|
|
cleanup: async () => {
|
|
cleanupAttempts++;
|
|
if (cleanupAttempts === 1)
|
|
throw new Error("injected owned-group cleanup refusal");
|
|
return cleanup();
|
|
},
|
|
};
|
|
},
|
|
async () => {
|
|
const root = await PrivateRuntimeRoot.create({
|
|
prefix: "rea-evm-cancel-process-",
|
|
});
|
|
rootPath = root.path;
|
|
const close = root.close.bind(root);
|
|
return {
|
|
path: root.path,
|
|
close: async () => {
|
|
if (!allowRootClose) {
|
|
allowRootClose = true;
|
|
throw new Error("injected retained root cleanup failure");
|
|
}
|
|
await close();
|
|
},
|
|
};
|
|
},
|
|
);
|
|
try {
|
|
const result = await provider.inspect(
|
|
{ path: input, encoding: "hex" },
|
|
{ signal: controller.signal },
|
|
);
|
|
expect(result.ok).toBe(false);
|
|
if (result.ok) throw new Error("Expected cancelled worker cleanup failure");
|
|
const original = result.error;
|
|
expect(original.cleanupIncomplete).toBe(true);
|
|
expect(original.cleanupResources).toContain(rootPath);
|
|
expect(original.cleanupPrimary?.cause).toBe(abortReason);
|
|
if (pid === undefined) throw new Error("Owned worker pid was not captured");
|
|
const ownedPid = pid;
|
|
expect(() => process.kill(ownedPid, 0)).not.toThrow();
|
|
|
|
const firstClose = await provider.close().then(
|
|
() => undefined,
|
|
(cause: unknown) => cause,
|
|
);
|
|
expect(firstClose).toMatchObject({
|
|
cleanupIncomplete: true,
|
|
cleanupResources: [rootPath],
|
|
});
|
|
expect(cleanupAttempts).toBe(2);
|
|
expect(original.cleanupResources).toEqual([rootPath]);
|
|
expect(() => process.kill(ownedPid, 0)).toThrow();
|
|
|
|
await provider.close();
|
|
expect(original.cleanupIncomplete).toBe(false);
|
|
expect(original.cleanupResources).toEqual([]);
|
|
expect(projectAnalysisError(original).category).toBe("cancelled");
|
|
expect(original.cleanupPrimary?.cause).toBe(abortReason);
|
|
expect(cleanupAttempts).toBe(2);
|
|
await expect(stat(rootPath)).rejects.toMatchObject({ code: "ENOENT" });
|
|
} finally {
|
|
allowRootClose = true;
|
|
try {
|
|
await provider.close();
|
|
} catch {
|
|
// Preserve the assertion's original failure while releasing test files.
|
|
}
|
|
await rm(workspace, { recursive: true, force: true });
|
|
if (platform !== undefined)
|
|
Object.defineProperty(process, "platform", platform);
|
|
if (arch !== undefined) Object.defineProperty(process, "arch", arch);
|
|
}
|
|
});
|