Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

fix(smoke): reap the server's child processes on teardown (#1873)

arookieofcd36cf83f7829
diff --git a/smoke/debug.test.ts b/smoke/debug.test.ts
index 84348d8f6..632304c4f 100644
--- a/smoke/debug.test.ts
+++ b/smoke/debug.test.ts
@@ -105,10 +105,12 @@ beforeAll(() => {
});
afterAll(() => deactivate?.());
-afterEach(() => {
+afterEach(async () => {
resetRuns();
disconnect?.();
- server?.close();
+ // `close` kills the server and what it started (debug adapters, language servers)
+ // and waits until they're gone, so the removal below can't race their writes.
+ await server?.close();
if (base) rmSync(base, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });
});
diff --git a/smoke/server.ts b/smoke/server.ts
index af387c384..aa867c127 100644
--- a/smoke/server.ts
+++ b/smoke/server.ts
@@ -2,7 +2,7 @@
* `openidea-server --stdio`, spoken to as the desktop app does in remote development:
* JSON-RPC with `Content-Length` framing over the server's stdin / stdout.
*/
-import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
+import { type ChildProcessWithoutNullStreams, execFile, spawn } from "node:child_process";
import { appendFileSync } from "node:fs";
import { dirname, join } from "node:path";
@@ -23,6 +23,28 @@ interface Pending {
reject: (error: unknown) => void;
}
+/** `taskkill /T /F`: the tree rooted at `pid` (see `Server.close`). Always resolves. */
+function treeKill(pid: number | undefined): Promise<void> {
+ return new Promise((resolve) => {
+ if (pid === undefined) return resolve();
+ execFile("taskkill", ["/pid", String(pid), "/T", "/F"], () => resolve());
+ });
+}
+
+/** Resolves once no process group `pid` exists anymore (signal 0 only checks). */
+async function waitForGroupExit(pid: number, timeoutMs = 5000): Promise<void> {
+ const start = Date.now();
+ for (;;) {
+ try {
+ process.kill(-pid, 0);
+ } catch {
+ return;
+ }
+ if (Date.now() - start > timeoutMs) return;
+ await new Promise((r) => setTimeout(r, 50));
+ }
+}
+
export class Server {
private nextId = 1;
private readonly pending = new Map<number, Pending>();
@@ -52,6 +74,9 @@ export class Server {
const child = spawn(serverBinary(), ["--stdio"], {
env: { ...process.env, OPENIDEA_SERVER_HOME: home, ...env },
stdio: ["pipe", "pipe", "pipe"],
+ // Its own process group: the language servers it starts (jdtls's JVM) stay in
+ // it, so `close` can reap them together with the server (see below).
+ detached: true,
});
const server = new Server(child);
await server.request("initialize", { version: PROTOCOL_VERSION });
@@ -78,14 +103,36 @@ export class Server {
}
}
- /** Kills the server; resolves once the process is gone (its children may still be exiting). */
+ /**
+ * Kills the server and everything it started; resolves once they're all gone.
+ * The server alone is not enough: a language server's own process (jdtls's JVM)
+ * outlives it and keeps writing under the test's home directory, so deleting that
+ * directory afterwards raced its writes (`ENOTEMPTY` on teardown). The server runs
+ * detached (its own process group), so the group is only it and its children.
+ */
async close(): Promise<void> {
if (this.child.exitCode === null && !this.child.killed) {
const exited = new Promise<void>((resolve) => this.child.once("exit", () => resolve()));
this.child.stdin.end();
- this.child.kill();
+ if (process.platform === "win32") {
+ // `child.kill()` stops only the server; take the whole tree while it is
+ // still enumerable, then wait for the exit below.
+ await treeKill(this.child.pid);
+ } else {
+ this.child.kill();
+ }
await exited;
}
+ if (process.platform !== "win32" && this.child.pid !== undefined) {
+ // Reap what the server started: `SIGKILL` to the group, then wait until it is
+ // gone (termination is asynchronous; files held open can't be deleted meanwhile).
+ try {
+ process.kill(-this.child.pid, "SIGKILL");
+ } catch {
+ // Nothing left running.
+ }
+ await waitForGroupExit(this.child.pid);
+ }
}
private request(method: string, params: unknown): Promise<unknown> {