@gtkx/utils 2.0.0-beta.1 → 2.0.0-beta.10

package/src/process/kill-marked-processes.ts

@@ -1,44 +1,89 @@
 import { readdirSync, readFileSync } from "node:fs";
+import { readProcessStatFields } from "./process-status.ts";
+
+type ProcessIdentity = {
+    pid: number;
+    sessionId: number;
+    startTime: string;
+};
+
+type MarkerMatcher = (assignment: string) => boolean;
 
 const PROCESS_MARKER = "GTKX_PROCESS_GUARD";
 const MAX_KILL_PASSES = 8;
+const JOB_ID_PATTERN = /^[0-9a-f]{8}$/;
 
-const isMarked = (pid: number, prefix: string): boolean => {
+const processIdentity = (pid: number): ProcessIdentity | undefined => {
+    const fields = readProcessStatFields(pid);
+    const sessionId = Number(fields?.[3]);
+    const startTime = fields?.[19];
+
+    return startTime !== undefined && Number.isSafeInteger(sessionId)
+        ? { pid, sessionId, startTime }
+        : undefined;
+};
+
+const isMarked = (pid: number, isMatch: MarkerMatcher): boolean => {
     try {
         return readFileSync(`/proc/${String(pid)}/environ`, "utf8")
             .split("\0")
-            .some((assignment) => assignment.startsWith(prefix));
+            .some((assignment) => isMatch(assignment));
     } catch {
         return false;
     }
 };
 
-const markedPids = (prefix: string): number[] =>
+const markedProcesses = (isMatch: MarkerMatcher): ProcessIdentity[] =>
     readdirSync("/proc")
         .map(Number)
         .filter((pid) => Number.isSafeInteger(pid) && pid > 1 && pid !== process.pid)
-        .filter((pid) => isMarked(pid, prefix));
+        .filter((pid) => isMarked(pid, isMatch))
+        .map((pid) => processIdentity(pid))
+        .filter((identity): identity is ProcessIdentity => identity !== undefined);
+
+const killProcess = (identity: ProcessIdentity, isMatch: MarkerMatcher): void => {
+    if (!isMarked(identity.pid, isMatch)) {
+        return;
+    }
+
+    const current = processIdentity(identity.pid);
+
+    if (
+        current?.sessionId !== identity.sessionId ||
+        current.startTime !== identity.startTime
+    ) {
+        return;
+    }
 
-const killPid = (pid: number): void => {
     try {
-        process.kill(pid, "SIGKILL");
+        process.kill(identity.pid, "SIGKILL");
     } catch {
         return;
     }
 };
 
-function killMarkedProcesses(prefix: string): void {
+const killMatchingProcesses = (isMatch: MarkerMatcher): void => {
     for (let pass = 0; pass < MAX_KILL_PASSES; pass += 1) {
-        const pids = markedPids(prefix);
+        const processes = markedProcesses(isMatch);
 
-        if (pids.length === 0) {
+        if (processes.length === 0) {
             return;
         }
 
-        for (const pid of pids) {
-            killPid(pid);
+        for (const identity of processes) {
+            killProcess(identity, isMatch);
         }
     }
-}
+};
+
+const killMarkedProcesses = (marker: string): void => {
+    killMatchingProcesses((assignment) => assignment === marker);
+};
+
+const killMarkedProcessRun = (runPrefix: string): void => {
+    killMatchingProcesses((assignment) =>
+        assignment.startsWith(runPrefix) && JOB_ID_PATTERN.test(assignment.slice(runPrefix.length)),
+    );
+};
 
-export { PROCESS_MARKER, killMarkedProcesses };
+export { PROCESS_MARKER, killMarkedProcessRun, killMarkedProcesses };

package/src/process/kill-process-group.ts

@@ -0,0 +1,105 @@
+import { lstatSync, rmSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import { readProcessStatFields } from "./process-status.ts";
+
+type ProcessGroupIdentity = {
+    processGroupId: number;
+    leaderStartTime: string;
+};
+
+type CleanupDirectoryIdentity = {
+    path: string;
+    device: string;
+    inode: string;
+    userId: string;
+};
+
+const isProcessGroupId = (value: number): boolean => Number.isSafeInteger(value) && value > 1;
+
+const processGroupIdentity = (processGroupId: number): ProcessGroupIdentity | undefined => {
+    if (!isProcessGroupId(processGroupId)) {
+        return undefined;
+    }
+
+    const fields = readProcessStatFields(processGroupId);
+
+    if (fields === undefined) {
+        return undefined;
+    }
+
+    const actualProcessGroupId = Number(fields[2]);
+    const sessionId = Number(fields[3]);
+    const leaderStartTime = fields[19];
+
+    return actualProcessGroupId === processGroupId && sessionId === processGroupId && leaderStartTime !== undefined
+        ? { processGroupId, leaderStartTime }
+        : undefined;
+};
+
+const isCurrentProcessGroup = (identity: ProcessGroupIdentity): boolean => {
+    const current = processGroupIdentity(identity.processGroupId);
+
+    return current?.leaderStartTime === identity.leaderStartTime;
+};
+
+const killProcessGroup = (identity: ProcessGroupIdentity, signal: NodeJS.Signals = "SIGKILL"): void => {
+    if (!isCurrentProcessGroup(identity)) {
+        return;
+    }
+
+    try {
+        process.kill(-identity.processGroupId, signal);
+    } catch {
+        return;
+    }
+};
+
+const cleanupDirectoryIdentity = (path: string): CleanupDirectoryIdentity | undefined => {
+    const absolutePath = resolve(path);
+
+    if (absolutePath === "/" || !isAbsolute(path)) {
+        return undefined;
+    }
+
+    try {
+        const entry = lstatSync(absolutePath, { bigint: true });
+
+        return entry.isDirectory()
+            ? {
+                    path: absolutePath,
+                    device: entry.dev.toString(),
+                    inode: entry.ino.toString(),
+                    userId: entry.uid.toString(),
+                }
+            : undefined;
+    } catch {
+        return undefined;
+    }
+};
+
+const removeCleanupDirectory = (identity: CleanupDirectoryIdentity): void => {
+    const current = cleanupDirectoryIdentity(identity.path);
+
+    if (
+        current?.device !== identity.device ||
+        current.inode !== identity.inode ||
+        current.userId !== identity.userId
+    ) {
+        return;
+    }
+
+    try {
+        rmSync(identity.path, { recursive: true, force: true });
+    } catch {
+        return;
+    }
+};
+
+export {
+    type CleanupDirectoryIdentity,
+    cleanupDirectoryIdentity,
+    killProcessGroup,
+    type ProcessGroupIdentity,
+    processGroupIdentity,
+    removeCleanupDirectory,
+};

package/src/process/process-guard.ts

@@ -1,20 +1,275 @@
-import { killMarkedProcesses } from "./kill-marked-processes.ts";
+import { readFileSync } from "node:fs";
+import { killMarkedProcesses, killMarkedProcessRun } from "./kill-marked-processes.ts";
+import {
+    type CleanupDirectoryIdentity,
+    killProcessGroup,
+    type ProcessGroupIdentity,
+    processGroupIdentity,
+    removeCleanupDirectory,
+} from "./kill-process-group.ts";
 
 const GUARD_PREFIX = process.argv[2] ?? "";
+const PROCESS_WATCH_ARGUMENT = process.argv[3];
 const WATCHED_SIGNALS = ["SIGTERM", "SIGINT", "SIGHUP"] as const satisfies NodeJS.Signals[];
+const OWNER_POLL_INTERVAL_MS = 50;
+const SUPERVISOR_EXIT_TIMEOUT_MS = 2000;
 
-const sweep = (): void => {
+type ProcessIdentity = {
+    pid: number;
+    startTime: string;
+};
+
+type ProcessWatch = {
+    owner: ProcessIdentity;
+    target: ProcessIdentity;
+};
+
+type GuardJob = {
+    marker: string;
+    processGroup: ProcessGroupIdentity;
+    cleanupDirectories: CleanupDirectoryIdentity[];
+    signal: NodeJS.Signals;
+};
+
+const state: { bufferedCommands: string; isSweeping: boolean; jobs: Map<string, GuardJob> } = {
+    bufferedCommands: "",
+    isSweeping: false,
+    jobs: new Map(),
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+    typeof value === "object" && value !== null && !Array.isArray(value);
+
+const isProcessIdentity = (value: unknown): value is ProcessIdentity =>
+    isRecord(value) &&
+    typeof value.pid === "number" &&
+    Number.isSafeInteger(value.pid) &&
+    value.pid > 1 &&
+    typeof value.startTime === "string" &&
+    /^\d+$/.test(value.startTime);
+
+const isProcessWatch = (value: unknown): value is ProcessWatch =>
+    isRecord(value) && isProcessIdentity(value.owner) && isProcessIdentity(value.target);
+
+const isProcessGroupIdentity = (value: unknown): value is ProcessGroupIdentity =>
+    isRecord(value) &&
+    typeof value.processGroupId === "number" &&
+    Number.isSafeInteger(value.processGroupId) &&
+    value.processGroupId > 1 &&
+    typeof value.leaderStartTime === "string" &&
+    /^\d+$/.test(value.leaderStartTime);
+
+const isCleanupDirectoryIdentity = (value: unknown): value is CleanupDirectoryIdentity =>
+    isRecord(value) &&
+    typeof value.path === "string" &&
+    typeof value.device === "string" &&
+    typeof value.inode === "string" &&
+    typeof value.userId === "string";
+
+const isGuardJob = (value: unknown): value is GuardJob =>
+    isRecord(value) &&
+    typeof value.marker === "string" &&
+    isProcessGroupIdentity(value.processGroup) &&
+    Array.isArray(value.cleanupDirectories) &&
+    value.cleanupDirectories.every(isCleanupDirectoryIdentity) &&
+    (value.signal === "SIGKILL" || value.signal === "SIGCONT");
+
+const parseProcessWatch = (): ProcessWatch | undefined => {
+    if (PROCESS_WATCH_ARGUMENT === undefined) {
+        return undefined;
+    }
+
+    try {
+        const value: unknown = JSON.parse(PROCESS_WATCH_ARGUMENT);
+
+        return isProcessWatch(value) ? value : undefined;
+    } catch {
+        return undefined;
+    }
+};
+
+const currentProcessIdentity = (pid: number): ProcessIdentity | undefined => {
+    try {
+        const stat = readFileSync(`/proc/${String(pid)}/stat`, "utf8");
+        const fields = stat.slice(stat.lastIndexOf(") ") + 2).split(" ", 20);
+        const state = fields[0];
+        const startTime = fields[19];
+
+        return startTime !== undefined && state !== undefined && !["Z", "X", "x"].includes(state)
+            ? { pid, startTime }
+            : undefined;
+    } catch {
+        return undefined;
+    }
+};
+
+const isCurrentProcess = (identity: ProcessIdentity): boolean =>
+    currentProcessIdentity(identity.pid)?.startTime === identity.startTime;
+
+const killProcess = (identity: ProcessIdentity): void => {
+    if (!isCurrentProcess(identity)) {
+        return;
+    }
+
+    try {
+        process.kill(identity.pid, "SIGKILL");
+    } catch {
+        return;
+    }
+};
+
+const applyCommand = (command: string): void => {
+    const operation = command[0];
+    let value: unknown;
+
+    try {
+        value = JSON.parse(command.slice(1));
+    } catch {
+        return;
+    }
+
+    if (!isGuardJob(value)) {
+        return;
+    }
+
+    if (operation === "+") {
+        state.jobs.set(value.marker, value);
+    } else if (operation === "-") {
+        state.jobs.delete(value.marker);
+    }
+};
+
+const receiveCommands = (chunk: Buffer | string): void => {
+    state.bufferedCommands += chunk.toString();
+    const commands = state.bufferedCommands.split("\n");
+    state.bufferedCommands = commands.pop() ?? "";
+
+    for (const command of commands) {
+        applyCommand(command);
+    }
+};
+
+const killJobs = (): void => {
+    for (const job of state.jobs.values()) {
+        killProcessGroup(job.processGroup, job.signal);
+
+        if (job.signal === "SIGKILL") {
+            killMarkedProcesses(job.marker);
+        }
+    }
+};
+
+const removeCleanupDirectories = (): void => {
+    const cleanupDirectories: Map<string, CleanupDirectoryIdentity> = new Map();
+
+    for (const job of state.jobs.values()) {
+        for (const identity of job.cleanupDirectories) {
+            cleanupDirectories.set(`${identity.device}:${identity.inode}`, identity);
+        }
+    }
+
+    for (const identity of cleanupDirectories.values()) {
+        removeCleanupDirectory(identity);
+    }
+};
+
+const hasRunningSupervisor = (): boolean => {
+    for (const job of state.jobs.values()) {
+        if (job.signal !== "SIGCONT") {
+            continue;
+        }
+
+        const current = processGroupIdentity(job.processGroup.processGroupId);
+
+        if (current?.leaderStartTime === job.processGroup.leaderStartTime) {
+            return true;
+        }
+    }
+
+    return false;
+};
+
+const forceSupervisors = (): void => {
+    for (const job of state.jobs.values()) {
+        if (job.signal === "SIGCONT") {
+            killProcessGroup(job.processGroup);
+        }
+    }
+};
+
+const finishSweep = (): void => {
     if (GUARD_PREFIX.length > 0) {
-        killMarkedProcesses(GUARD_PREFIX);
+        killMarkedProcessRun(GUARD_PREFIX);
     }
 
+    removeCleanupDirectories();
     process.exit(0);
 };
 
+const awaitSupervisors = (deadline: number): void => {
+    if (hasRunningSupervisor() && Date.now() < deadline) {
+        setTimeout(() => {
+            awaitSupervisors(deadline);
+        }, OWNER_POLL_INTERVAL_MS);
+
+        return;
+    }
+
+    forceSupervisors();
+    finishSweep();
+};
+
+const sweep = (target?: ProcessIdentity): void => {
+    if (state.isSweeping) {
+        return;
+    }
+
+    state.isSweeping = true;
+    applyCommand(state.bufferedCommands);
+
+    if (target !== undefined) {
+        killProcess(target);
+    }
+
+    killJobs();
+    awaitSupervisors(Date.now() + SUPERVISOR_EXIT_TIMEOUT_MS);
+};
+
+const watch = parseProcessWatch();
+
+const startOwnerPoll = (): void => {
+    if (watch === undefined) {
+        return;
+    }
+
+    const ownerPoll = setInterval(() => {
+        if (isCurrentProcess(watch.owner)) {
+            return;
+        }
+
+        clearInterval(ownerPoll);
+        sweep(watch.target);
+    }, OWNER_POLL_INTERVAL_MS);
+
+    if (!isCurrentProcess(watch.owner)) {
+        clearInterval(ownerPoll);
+        sweep(watch.target);
+    }
+};
+
+startOwnerPoll();
+
 process.stdin.resume();
-process.stdin.on("end", sweep);
-process.stdin.on("error", sweep);
+process.stdin.on("data", receiveCommands);
+process.stdin.on("end", () => {
+    sweep();
+});
+process.stdin.on("error", () => {
+    sweep();
+});
 
 for (const signal of WATCHED_SIGNALS) {
-    process.on(signal, sweep);
+    process.on(signal, () => {
+        sweep();
+    });
 }

package/src/process/process-status.ts

@@ -0,0 +1,25 @@
+import { readFileSync } from "node:fs";
+
+const REAPED_STATES: ReadonlySet<string> = new Set(["Z", "X", "x"]);
+
+const readProcessStatFields = (pid: number): string[] | undefined => {
+    if (!Number.isSafeInteger(pid) || pid <= 0) {
+        return undefined;
+    }
+
+    try {
+        const stat = readFileSync(`/proc/${String(pid)}/stat`, "utf8");
+        const separator = stat.lastIndexOf(") ");
+
+        return separator === -1 ? undefined : stat.slice(separator + 2).split(" ");
+    } catch {
+        return undefined;
+    }
+};
+
+const isReapedState = (state: string | undefined): boolean => state === undefined || REAPED_STATES.has(state);
+
+const isProcessAlive = (pid: number | undefined): boolean =>
+    pid !== undefined && pid > 1 && !isReapedState(readProcessStatFields(pid)?.[0]);
+
+export { isProcessAlive, isReapedState, readProcessStatFields };