mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-16 11:59:26 +01:00
## Thinking Path > - Paperclip is the open source app people use to manage AI agents for work > - The Runner end-to-end harness stops the Paperclip server and its launcher through a process tree owner that reads `ps` > - The owner already waits out a briefly uncertain process group, but one failed `ps` listing ended the stop at once > - The stop then fell back to the direct child and always reported `Owned tree cleanup incomplete`, even when the launcher exited normally > - CI showed this as `Owned tree cleanup incomplete: Error: Could not inspect owned process identities` in `server-stop.test.ts` on 5 unrelated branches > - This pull request re-reads a failed listing a bounded number of times inside the same deadline, and names why `ps` failed > - The benefit is that one transient listing failure no longer fails a server stop, and a persistent failure is diagnosable ## Linked Issues or Issue Description **What happened?** `tests/runner-e2e/server-stop.test.ts > lets launcher cancellation join wrapper shutdown without signaling the server twice` (job "Runner support suite", project `runner-e2e-support`) fails intermittently with `Error: Owned tree cleanup incomplete: Error: Could not inspect owned process identities`, thrown from `tests/runner-e2e/process-tree-owner.ts:265`. It failed 6 times on 5 unrelated branches in 48 hours. **Steps to reproduce** 1. The failing inspection is `readProcessTable()` returning `null` (non-zero `ps` exit, `ps` timeout, or spawn error). The CI logs do not say which, because `ps` stderr was discarded. 2. Locally on macOS, 40 plain runs pass (the Linux `ps` failure does not occur on this host). 3. Inject the fault: make `readProcessTable()` return `null` for 15% of calls. 26 of 30 runs then fail with the exact CI error. **Paperclip version or commit** `master` at the base of this branch (CI on unrelated pull requests, 2026-11-10 to 2026-11-12). **Expected behavior** A failed listing grants no authority to signal anything. The stop reads the table again within its deadline, as it already does for an uncertain group, and it still falls back to the direct child when the listing keeps failing. **Actual behavior** `settleUncertainIdentity` only retried the uncertain-identity error. The first failed listing went straight to `incompleteTreeFallback`, which always throws. ## What Changed - `process-tree-owner.ts`: `settleUncertainIdentity` also re-reads after `Could not inspect owned process identities`, up to 3 attempts per step. It does not start a new read when less than one poll interval (100 ms) is left before the step deadline. No signal is sent between attempts. A persistent failure keeps the old fallback, so the direct child still gets its grace period. - `process-tree.ts`: `readProcessTable` takes an optional `onFailure(reason)` callback and keeps `ps` stderr. The owner adds the reason (exit code, signal, timeout, or stderr tail) to the inspection error. - `process-tree-owner.test.ts`: four regression tests. A listing that fails once during a stop no longer fails it. A listing that always fails still falls back to the direct child after 3 reads. No read starts at the deadline. A failed listing reports its reason. ## Verification - Red/green: both new tests fail on master. The first fails with the exact CI message `Owned tree cleanup incomplete: Error: Could not inspect owned process identities`. Both pass with this change. - Loop of the flaky test, 30 runs each, with a temporary local fault injection (`readProcessTable` returns `null` for 15% of calls, not committed): - Before: 4 pass, 26 fail (24 with `Owned tree cleanup incomplete: Error: Could not inspect owned process identities`). - After: 27 pass, 3 fail. In a 20-run recheck, the only failures (2) came from the test's own preliminary `await owner.observe()` at line 166, outside the stop path. The 15% injected rate is far above the real rate. - Without injection: 40 of 40 pass on master locally. - `npx vitest run --config tests/runner-e2e/vitest.config.ts tests/runner-e2e/process-tree-owner.test.ts tests/runner-e2e/server-stop.test.ts`: 41 tests pass. - `tsc --noEmit -p tests/runner-e2e/tsconfig.json`: no errors in the changed files. ## Risks - Low risk. This is test harness code. Each step can now wait up to 2 extra 100 ms polls when `ps` fails. No new read starts within 100 ms of the deadline. As before this change, one `ps` read that is already running can still take up to its 5 s timeout. The exact cause of the Linux `ps` failure is not proven yet. The new error text will name it if it happens again. ## Model Used - Claude Opus 5.5 (`claude-opus-5-5`), Anthropic, used through Claude Code with tool use (shell, file edits) and extended reasoning. ## Checklist - [x] I have included a thinking path that traces from project context to this change - [x] I have specified the model used (with version and capability details) - [x] I have checked ROADMAP.md and confirmed this PR does not duplicate planned core work - [x] I have searched GitHub for duplicate or related PRs and linked them above - [x] I have either (a) linked existing issues with `Fixes: #` / `Closes #` / `Refs #` OR (b) described the issue in-PR following the relevant issue template - [x] I have not referenced internal/instance-local Paperclip issues or links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip` URLs) - [x] My branch name describes the change (e.g. `docs/...`, `fix/...`) and contains no internal Paperclip ticket id or instance-derived details - [x] I have run tests locally and they pass - [x] I have added or updated tests where applicable - [x] I have updated relevant documentation to reflect my changes - [x] I have considered and documented any risks above - [ ] All Paperclip CI gates are green - [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups - [x] I will address all Greptile and reviewer comments before requesting merge 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
356 lines
17 KiB
TypeScript
356 lines
17 KiB
TypeScript
import { spawn, type ChildProcess } from "node:child_process";
|
|
import { expect, it } from "vitest";
|
|
import { createProcessTreeOwner, stopOwnedProcessTree } from "./process-tree-owner.js";
|
|
import { readProcessTable, type ProcessObservation } from "./process-tree.js";
|
|
|
|
function row(pid: number, parentPid: number, processGroupId: number, started = `start-${pid}`, state = "S"): ProcessObservation {
|
|
return { pid, parentPid, processGroupId, started, state, kind: "node" };
|
|
}
|
|
function fixture(initial: ProcessObservation[]) {
|
|
let table = [row(process.pid, 1, 10), ...initial];
|
|
const root = { pid: 100, exitCode: null as number | null, signalCode: null as NodeJS.Signals | null };
|
|
const signals: Array<[number, NodeJS.Signals]> = [];
|
|
const owner = createProcessTreeOwner(root as ChildProcess, {
|
|
readTable: async () => table,
|
|
signalGroup: (pid, signal) => { signals.push([pid, signal]); },
|
|
});
|
|
return { root, owner, signals, replace: (rows: ProcessObservation[]) => { table = [row(process.pid, 1, 10), ...rows]; } };
|
|
}
|
|
|
|
it.skipIf(process.platform === "win32")("revalidates PID/start before signaling and refuses a recycled group", async () => {
|
|
const f = fixture([row(100, process.pid, 100), row(200, 100, 200)]);
|
|
try {
|
|
await f.owner.observe();
|
|
f.replace([row(100, process.pid, 100), row(200, 1, 200, "new-start")]);
|
|
await expect(f.owner.signal("SIGKILL")).rejects.toThrow("identity became uncertain");
|
|
expect(f.signals).toEqual([]);
|
|
} finally { f.owner.stopObserving(); }
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")("keeps surviving peer identities when a descendant traversal ends at a short-lived child", async () => {
|
|
const f = fixture([row(100, process.pid, 100), row(101, 100, 100), row(200, 100, 200), row(201, 200, 200)]);
|
|
try {
|
|
await f.owner.observe();
|
|
await f.owner.observe();
|
|
f.replace([row(100, process.pid, 100), row(200, 100, 200)]);
|
|
await f.owner.signal("SIGKILL");
|
|
expect(f.signals).toEqual([[200, "SIGKILL"], [100, "SIGKILL"]]);
|
|
} finally { f.owner.stopObserving(); }
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")("admits replacement group members only through a still-owned ancestor", async () => {
|
|
const f = fixture([row(100, process.pid, 100), row(200, 100, 200)]);
|
|
try {
|
|
await f.owner.observe();
|
|
// The short-lived group leader exited between polls. Its new member is
|
|
// independently owned through the original, still-live controller.
|
|
f.replace([row(100, process.pid, 100), row(300, 100, 200)]);
|
|
await f.owner.signal("SIGKILL");
|
|
expect(f.signals).toEqual([[200, "SIGKILL"], [100, "SIGKILL"]]);
|
|
} finally { f.owner.stopObserving(); }
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")("keeps surviving peers after the launcher exits without admitting an unobserved group", async () => {
|
|
const f = fixture([row(100, process.pid, 100), row(200, 100, 200), row(201, 200, 200)]);
|
|
try {
|
|
await f.owner.observe();
|
|
f.root.exitCode = 0;
|
|
f.replace([row(200, 1, 200), row(201, 200, 200)]);
|
|
await f.owner.observe();
|
|
f.replace([row(200, 1, 200), row(999, 1, 999)]);
|
|
await f.owner.signal("SIGTERM");
|
|
expect(f.signals).toEqual([[200, "SIGTERM"]]);
|
|
} finally { f.owner.stopObserving(); }
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")("refuses replacement groups containing any unowned live member", async () => {
|
|
const f = fixture([row(100, process.pid, 100), row(200, 100, 200)]);
|
|
try {
|
|
await f.owner.observe();
|
|
f.replace([row(100, process.pid, 100), row(300, 100, 200), row(400, 1, 200)]);
|
|
await expect(f.owner.signal("SIGKILL")).rejects.toThrow("identity became uncertain");
|
|
expect(f.signals).toEqual([]);
|
|
} finally { f.owner.stopObserving(); }
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")("does not use a recycled controller as a replacement member's ownership anchor", async () => {
|
|
const f = fixture([row(100, process.pid, 100), row(200, 100, 200)]);
|
|
try {
|
|
await f.owner.observe();
|
|
f.replace([row(100, process.pid, 100, "recycled-controller"), row(300, 100, 200)]);
|
|
await expect(f.owner.signal("SIGKILL")).rejects.toThrow("identity became uncertain");
|
|
expect(f.signals).toEqual([]);
|
|
} finally { f.owner.stopObserving(); }
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")("retains observed descendants when the root exits and excludes the caller group", async () => {
|
|
const f = fixture([row(100, process.pid, 100), row(200, 100, 200), row(300, 100, 10), row(999, process.pid, 999)]);
|
|
try {
|
|
await f.owner.observe();
|
|
f.root.exitCode = 1;
|
|
f.replace([row(200, 1, 200), row(300, 1, 10), row(999, process.pid, 999)]);
|
|
await f.owner.signal("SIGTERM");
|
|
expect(f.signals).toEqual([[200, "SIGTERM"]]);
|
|
} finally { f.owner.stopObserving(); }
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")("treats an unreaped zombie as stopped without signaling a replacement", async () => {
|
|
const f = fixture([row(100, process.pid, 100), row(200, 100, 200)]);
|
|
try {
|
|
await f.owner.observe();
|
|
f.root.exitCode = 1;
|
|
f.replace([row(200, 1, 200, "start-200", "Z")]);
|
|
await f.owner.signal("SIGKILL");
|
|
expect(f.owner.liveGroups()).toEqual([]);
|
|
expect(f.signals).toEqual([]);
|
|
} finally { f.owner.stopObserving(); }
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")("sends launcher grace only to the root while retaining nested groups for escalation", async () => {
|
|
const f = fixture([row(100, process.pid, 100), row(200, 100, 200), row(300, 200, 300)]);
|
|
try {
|
|
await f.owner.observe();
|
|
await f.owner.signal("SIGTERM", f.owner.gracefulRoots());
|
|
expect(f.signals).toEqual([[100, "SIGTERM"]]);
|
|
f.root.exitCode = 1;
|
|
f.replace([row(200, 1, 200), row(300, 200, 300)]);
|
|
await f.owner.observe();
|
|
expect([...f.owner.gracefulRoots()]).toEqual([200]);
|
|
await f.owner.signal("SIGKILL");
|
|
expect(f.signals.slice(1).map(([pid]) => pid).sort()).toEqual([200, 300]);
|
|
} finally { f.owner.stopObserving(); }
|
|
});
|
|
|
|
it.skipIf(process.platform === 'win32')('reselects a vanished owner only when no graceful signal was delivered', async () => {
|
|
let table = [row(process.pid, 1, 10), row(100, process.pid, 100), row(200, 100, 200)];
|
|
const child = { pid: 100, exitCode: null as number | null, signalCode: null };
|
|
const delivered: number[] = [];
|
|
let reads = 0;
|
|
let stopping = false;
|
|
const owner = createProcessTreeOwner(child as ChildProcess, {
|
|
readTable: async () => {
|
|
if (stopping && ++reads === 2) { child.exitCode = 0; table = [row(process.pid, 1, 10), row(200, 1, 200)]; }
|
|
return table;
|
|
},
|
|
signalGroup: (pid, signal) => {
|
|
expect(signal).toBe('SIGTERM');
|
|
if (pid === 100) {
|
|
child.exitCode = 0; table = [row(process.pid, 1, 10), row(200, 1, 200)];
|
|
throw Object.assign(new Error('vanished'), { code: 'ESRCH' });
|
|
}
|
|
delivered.push(pid); table = [row(process.pid, 1, 10)];
|
|
},
|
|
});
|
|
try {
|
|
await owner.observe(); stopping = true;
|
|
const { stopOwnedProcessTree } = await import('./process-tree-owner.js');
|
|
await stopOwnedProcessTree(child as ChildProcess, owner, 150, 100);
|
|
expect(delivered).toEqual([200]);
|
|
} finally { owner.stopObserving(); }
|
|
});
|
|
|
|
|
|
it.skipIf(process.platform === "win32")("rejects an overflowing inspector instead of returning a partial identity table", async () => {
|
|
const inspector = spawn(process.execPath, ["-e", "process.stdout.write('x'.repeat(2 * 1024 * 1024)); setInterval(() => {}, 1000)"], {
|
|
stdio: ["ignore", "pipe", "ignore"],
|
|
});
|
|
const exited = new Promise<void>(resolve => inspector.once("exit", () => resolve()));
|
|
try {
|
|
expect(await readProcessTable(() => inspector)).toBeNull();
|
|
await exited;
|
|
expect(inspector.signalCode).toBe("SIGKILL");
|
|
} finally { if (inspector.exitCode === null && inspector.signalCode === null) inspector.kill("SIGKILL"); }
|
|
});
|
|
|
|
it.skipIf(process.platform === 'win32')('bounds fallback even when the known direct child cannot be killed', async () => {
|
|
const signals: NodeJS.Signals[] = [];
|
|
const child = { pid: 100, exitCode: null, signalCode: null,
|
|
kill: (signal: NodeJS.Signals) => { signals.push(signal); return false; } } as ChildProcess;
|
|
const owner = createProcessTreeOwner(child, { readTable: async () => null,
|
|
signalGroup: () => { throw new Error('must not signal an unobserved group'); } });
|
|
try {
|
|
const { stopOwnedProcessTree } = await import('./process-tree-owner.js');
|
|
await expect(stopOwnedProcessTree(child, owner, 10, 10)).rejects.toThrow('Known direct child remained');
|
|
expect(signals).toEqual(['SIGTERM', 'SIGKILL']);
|
|
} finally { owner.stopObserving(); }
|
|
});
|
|
|
|
function epermFixture(afterSignal: ProcessObservation[]) {
|
|
let table = [row(process.pid, 1, 10), row(100, process.pid, 100), row(200, 100, 200)];
|
|
const root = { pid: 100, exitCode: null as number | null, signalCode: null as NodeJS.Signals | null };
|
|
const attempts: Array<[number, NodeJS.Signals]> = [];
|
|
const owner = createProcessTreeOwner(root as ChildProcess, {
|
|
readTable: async () => table,
|
|
signalGroup: (pid, signal) => {
|
|
attempts.push([pid, signal]);
|
|
if (pid !== 200) return;
|
|
// Darwin killpg reports EPERM, not ESRCH, once every group member exited
|
|
// but is not reaped yet. The group exits between inspection and signal.
|
|
table = [row(process.pid, 1, 10), row(100, process.pid, 100), ...afterSignal];
|
|
throw Object.assign(new Error("kill EPERM"), { code: "EPERM" });
|
|
},
|
|
});
|
|
return { owner, attempts };
|
|
}
|
|
|
|
it.skipIf(process.platform === "win32")("treats EPERM from a group that is now only zombies as already exited", async () => {
|
|
const f = epermFixture([row(200, 100, 200, "start-200", "Z")]);
|
|
try {
|
|
await f.owner.observe();
|
|
await expect(f.owner.signal("SIGKILL")).resolves.toEqual([100]);
|
|
expect(f.attempts).toEqual([[200, "SIGKILL"], [100, "SIGKILL"]]);
|
|
} finally { f.owner.stopObserving(); }
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")("keeps EPERM fatal while the group still has a running member", async () => {
|
|
const f = epermFixture([row(200, 100, 200, "start-200", "Z"), row(201, 200, 200)]);
|
|
try {
|
|
await f.owner.observe();
|
|
await expect(f.owner.signal("SIGKILL")).rejects.toThrow("kill EPERM");
|
|
} finally { f.owner.stopObserving(); }
|
|
});
|
|
|
|
function turnoverFixture(uncertainReads: number) {
|
|
// Server 100 owns runner group 200. Between two inspections the observed
|
|
// runner exits and a straggler nobody saw start (201) is left in group 200,
|
|
// reparented to init: its identity is unproven, so it must never be signaled.
|
|
const settledTable = () => [row(process.pid, 1, 10)];
|
|
let table = [row(process.pid, 1, 10), row(100, process.pid, 100), row(200, 100, 200)];
|
|
const killed: NodeJS.Signals[] = [];
|
|
const signals: Array<[number, NodeJS.Signals]> = [];
|
|
const child = { pid: 100, exitCode: null as number | null, signalCode: null as NodeJS.Signals | null,
|
|
kill: (signal: NodeJS.Signals) => { killed.push(signal); return true; } };
|
|
let stopping = false;
|
|
let uncertain = 0;
|
|
const owner = createProcessTreeOwner(child as unknown as ChildProcess, {
|
|
readTable: async () => {
|
|
if (!stopping) return table;
|
|
if (uncertain < uncertainReads) {
|
|
uncertain += 1;
|
|
return [row(process.pid, 1, 10), row(201, 1, 200, "unseen-start")];
|
|
}
|
|
child.exitCode = 0;
|
|
return settledTable();
|
|
},
|
|
signalGroup: (pid, signal) => { signals.push([pid, signal]); },
|
|
});
|
|
return { owner, child: child as unknown as ChildProcess, signals, killed, stop: () => { stopping = true; table = settledTable(); } };
|
|
}
|
|
|
|
it.skipIf(process.platform === "win32")("waits out a briefly uncertain group under load without signaling it", async () => {
|
|
const f = turnoverFixture(3);
|
|
try {
|
|
await f.owner.observe();
|
|
f.stop();
|
|
await stopOwnedProcessTree(f.child, f.owner, 2_000, 500);
|
|
expect(f.signals.filter(([pid]) => pid === 200)).toEqual([]);
|
|
expect(f.killed).toEqual([]);
|
|
} finally { f.owner.stopObserving(); }
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")("still fails without signaling the uncertain group when the uncertainty outlasts the deadline", async () => {
|
|
const f = turnoverFixture(Number.POSITIVE_INFINITY);
|
|
try {
|
|
await f.owner.observe();
|
|
f.stop();
|
|
await expect(stopOwnedProcessTree(f.child, f.owner, 300, 100)).rejects.toThrow("identity became uncertain");
|
|
expect(f.signals).toEqual([]);
|
|
} finally { f.owner.stopObserving(); }
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")("keeps an uncertainty that starts at SIGKILL escalation inside one forced window", async () => {
|
|
// The launcher ignores grace; its runner group turns over only once grace has expired.
|
|
const gracefulMs = 300, forcedMs = 300;
|
|
const self = row(process.pid, 1, 10);
|
|
let stopAt: number | null = null;
|
|
const signals: Array<[number, NodeJS.Signals]> = [];
|
|
const child = { pid: 100, exitCode: null as number | null, signalCode: null as NodeJS.Signals | null, kill: () => true };
|
|
const owner = createProcessTreeOwner(child as unknown as ChildProcess, {
|
|
readTable: async () => stopAt === null || Date.now() - stopAt < gracefulMs
|
|
? [self, row(100, process.pid, 100), row(200, 100, 200)]
|
|
: [self, row(100, process.pid, 100), row(201, 1, 200, "unseen-start")],
|
|
signalGroup: (pid, signal) => { signals.push([pid, signal]); },
|
|
});
|
|
try {
|
|
await owner.observe();
|
|
stopAt = Date.now();
|
|
await expect(stopOwnedProcessTree(child as unknown as ChildProcess, owner, gracefulMs, forcedMs)).rejects.toThrow("identity became uncertain");
|
|
const elapsed = Date.now() - stopAt;
|
|
expect(elapsed).toBeLessThan(gracefulMs + forcedMs + 250);
|
|
expect(signals.filter(([, signal]) => signal === "SIGKILL")).toEqual([]);
|
|
} finally { owner.stopObserving(); }
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")("re-reads a process listing that fails once while the launcher stops", async () => {
|
|
const self = row(process.pid, 1, 10);
|
|
let table: ProcessObservation[] = [self, row(100, process.pid, 100)];
|
|
let failedReads = 0;
|
|
let stopping = false;
|
|
const signals: Array<[number, NodeJS.Signals]> = [];
|
|
const child = { pid: 100, exitCode: null as number | null, signalCode: null as NodeJS.Signals | null,
|
|
kill: () => { throw new Error("must not fall back to the direct child"); } };
|
|
const owner = createProcessTreeOwner(child as unknown as ChildProcess, {
|
|
readTable: async () => {
|
|
if (stopping && failedReads === 0) { failedReads += 1; return null; }
|
|
return table;
|
|
},
|
|
signalGroup: (pid, signal) => {
|
|
signals.push([pid, signal]);
|
|
child.exitCode = 0; table = [self];
|
|
},
|
|
});
|
|
try {
|
|
await owner.observe();
|
|
stopping = true;
|
|
await stopOwnedProcessTree(child as unknown as ChildProcess, owner, 2_000, 500);
|
|
expect(failedReads).toBe(1);
|
|
expect(signals).toEqual([[100, "SIGTERM"]]);
|
|
} finally { owner.stopObserving(); }
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")("reports why the process listing failed", async () => {
|
|
const reasons: string[] = [];
|
|
const inspector = spawn(process.execPath, ["-e", "process.stderr.write('listing unavailable'); process.exit(3)"], {
|
|
stdio: ["ignore", "pipe", "pipe"],
|
|
});
|
|
expect(await readProcessTable(() => inspector, reason => reasons.push(reason))).toBeNull();
|
|
expect(reasons).toEqual(["ps exited code=3 signal=null: listing unavailable"]);
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")("still falls back to the direct child when every process listing fails", async () => {
|
|
let reads = 0;
|
|
const signals: NodeJS.Signals[] = [];
|
|
const child = { pid: 100, exitCode: null as number | null, signalCode: null as NodeJS.Signals | null,
|
|
kill: (signal: NodeJS.Signals) => { signals.push(signal); child.signalCode = signal; return true; } };
|
|
const owner = createProcessTreeOwner(child as unknown as ChildProcess, {
|
|
readTable: async () => { reads += 1; return null; },
|
|
signalGroup: () => { throw new Error("must not signal an unobserved group"); },
|
|
});
|
|
try {
|
|
await expect(owner.observe()).rejects.toThrow("Could not inspect owned process identities");
|
|
reads = 0;
|
|
const started = Date.now();
|
|
await expect(stopOwnedProcessTree(child as unknown as ChildProcess, owner, 2_000, 500))
|
|
.rejects.toThrow("Owned tree cleanup incomplete: Error: Could not inspect owned process identities");
|
|
expect(reads).toBeGreaterThanOrEqual(3);
|
|
expect(signals).toEqual(["SIGTERM"]);
|
|
expect(Date.now() - started).toBeLessThan(1_000);
|
|
} finally { owner.stopObserving(); }
|
|
});
|
|
|
|
it.skipIf(process.platform === "win32")("does not re-read a failed process listing past the stop deadline", async () => {
|
|
let reads = 0;
|
|
const child = { pid: 100, exitCode: null as number | null, signalCode: null as NodeJS.Signals | null,
|
|
kill: (signal: NodeJS.Signals) => { child.signalCode = signal; return true; } };
|
|
const owner = createProcessTreeOwner(child as unknown as ChildProcess, {
|
|
readTable: async () => { reads += 1; return null; },
|
|
signalGroup: () => { throw new Error("must not signal an unobserved group"); },
|
|
});
|
|
try {
|
|
await expect(owner.observe()).rejects.toThrow("Could not inspect owned process identities");
|
|
reads = 0;
|
|
await expect(stopOwnedProcessTree(child as unknown as ChildProcess, owner, 50, 500)).rejects.toThrow("Owned tree cleanup incomplete");
|
|
expect(reads).toBe(1);
|
|
} finally { owner.stopObserving(); }
|
|
});
|