Files
hyperframes/packages/cli/src/utils/projectLock.test.ts
T
Miguel Ángel 9ebc1f8a13 fix(cli): the check and snapshot project lock works where hard links are refused (#6464)
* fix(cli): the check and snapshot project lock works where hard links are refused

* refactor(cli): drop the project lock comment to fit the comment ratchet
2026-10-26 15:12:20 -04:00

183 lines
7.0 KiB
TypeScript

import { spawn } from "node:child_process";
import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { dirname, join } from "node:path";
import { pathToFileURL } from "node:url";
import { afterEach, describe, expect, it, vi } from "vitest";
import * as fs from "node:fs";
import { ProjectLockTimeout, projectLockPath, withProjectLock } from "./projectLock.js";
vi.mock("node:fs", async (importOriginal) => {
const original = await importOriginal<typeof fs>();
return { ...original, linkSync: vi.fn(original.linkSync) };
});
const directories: string[] = [];
const project = () => {
const directory = mkdtempSync(join(tmpdir(), "hf-project-lock-"));
directories.push(directory);
return directory;
};
afterEach(() => {
for (const directory of directories.splice(0))
rmSync(directory, { recursive: true, force: true });
});
const locked = (waitMs: number) => ({ projectLock: { waitMs } });
const hold = (dir: string, pid: number) => {
mkdirSync(dirname(projectLockPath(dir)), { recursive: true });
writeFileSync(projectLockPath(dir), JSON.stringify({ pid, command: "check", startedAt: 1 }));
};
describe("withProjectLock", () => {
it("runs without a lock file when the capability is absent", async () => {
const dir = project();
expect(
await withProjectLock(dir, "check", async () => existsSync(projectLockPath(dir)), {}),
).toBe(false);
});
it("holds the lock while running and releases it afterwards, even on failure", async () => {
const dir = project();
const seen = await withProjectLock(
dir,
"snapshot",
async () => JSON.parse(readFileSync(projectLockPath(dir), "utf8")),
locked(0),
);
expect(seen).toMatchObject({ pid: process.pid, command: "snapshot" });
expect(existsSync(projectLockPath(dir))).toBe(false);
await expect(
withProjectLock(dir, "check", async () => Promise.reject(new Error("boom")), locked(0)),
).rejects.toThrow("boom");
expect(existsSync(projectLockPath(dir))).toBe(false);
});
it("takes the lock where hard links are refused (EPERM)", async () => {
const dir = project();
vi.mocked(fs.linkSync).mockImplementationOnce(() => {
throw Object.assign(new Error("operation not permitted"), { code: "EPERM" });
});
const seen = await withProjectLock(
dir,
"check",
async () => JSON.parse(readFileSync(projectLockPath(dir), "utf8")),
locked(0),
);
expect(seen).toMatchObject({ pid: process.pid, command: "check" });
expect(existsSync(projectLockPath(dir))).toBe(false);
});
it("serializes concurrent holders in one project", async () => {
const dir = project();
const order: string[] = [];
const task = (name: string) =>
withProjectLock(
dir,
name,
async () => {
order.push(`${name}:start`);
await new Promise((done) => setTimeout(done, 50));
order.push(`${name}:end`);
},
locked(5000),
);
await Promise.all([task("check"), task("snapshot")]);
expect(order).toEqual(["check:start", "check:end", "snapshot:start", "snapshot:end"]);
});
it("waits up to waitMs for a live holder, then refuses with who holds it", async () => {
const dir = project();
hold(dir, process.pid);
const started = Date.now();
await expect(withProjectLock(dir, "snapshot", async () => "ran", locked(300))).rejects.toThrow(
ProjectLockTimeout,
);
expect(Date.now() - started).toBeGreaterThanOrEqual(300);
await expect(withProjectLock(dir, "snapshot", async () => "ran", locked(0))).rejects.toThrow(
`hyperframes check (pid ${process.pid}) is still using this project`,
);
});
it("takes over a lock whose process has exited", async () => {
const dir = project();
hold(dir, 2 ** 22 + 12345);
expect(await withProjectLock(dir, "check", async () => "ran", locked(0))).toBe("ran");
});
it("serializes processes that concurrently take over a dead holder", async () => {
const dir = project();
const events = join(dir, "events.ndjson");
hold(dir, 2 ** 22 + 12345);
const moduleUrl = pathToFileURL(join(import.meta.dirname, "projectLock.ts")).href;
const source = `
import { appendFileSync } from "node:fs";
import { withProjectLock } from ${JSON.stringify(moduleUrl)};
await withProjectLock(
${JSON.stringify(dir)},
"check",
async () => {
appendFileSync(${JSON.stringify(events)}, JSON.stringify({ type: "start", pid: process.pid }) + "\\n");
await new Promise((done) => setTimeout(done, 50));
appendFileSync(${JSON.stringify(events)}, JSON.stringify({ type: "end", pid: process.pid }) + "\\n");
},
{ projectLock: { waitMs: 5000 } },
);
`;
const children = Array.from({ length: 6 }, () =>
spawn(process.execPath, ["--import", "tsx", "--input-type=module", "--eval", source], {
stdio: ["ignore", "ignore", "pipe"],
}),
);
const outcomes = await Promise.all(
children.map(
(child) =>
new Promise<{ code: number | null; error: string }>((resolve) => {
let error = "";
child.stderr.on("data", (chunk) => (error += String(chunk)));
child.on("close", (code) => resolve({ code, error }));
}),
),
);
expect(outcomes).toEqual(outcomes.map(() => ({ code: 0, error: "" })));
const records = readFileSync(events, "utf8")
.trim()
.split("\n")
.map((line) => JSON.parse(line) as { type: "start" | "end"; pid: number });
let active = 0;
for (const record of records) {
active += record.type === "start" ? 1 : -1;
expect(active).toBeLessThanOrEqual(1);
}
expect(active).toBe(0);
});
it("refuses a breaker left by a killed process and names the file", async () => {
const dir = project();
hold(dir, 2 ** 22 + 12345);
const breakPath = `${projectLockPath(dir)}.break`;
const source = `
import { linkSync, writeFileSync } from "node:fs";
const holder = { pid: process.pid, command: "check", startedAt: 1 };
const draft = ${JSON.stringify(`${breakPath}.killed`)};
writeFileSync(draft, JSON.stringify(holder), { flag: "wx" });
linkSync(draft, ${JSON.stringify(breakPath)});
process.kill(process.pid, "SIGKILL");
`;
const child = spawn(process.execPath, ["--input-type=module", "--eval", source], {
stdio: "ignore",
});
const outcome = await new Promise<{ code: number | null; signal: NodeJS.Signals | null }>(
(resolve) => {
child.on("close", (code, signal) => resolve({ code, signal }));
},
);
expect(outcome.signal === "SIGKILL" || outcome.code !== 0).toBe(true);
expect(existsSync(breakPath)).toBe(true);
await expect(withProjectLock(dir, "check", async () => "ran", locked(0))).rejects.toThrow(
`hyperframes left ${breakPath} (pid ${child.pid}); delete it to continue`,
);
expect(existsSync(breakPath)).toBe(true);
expect(existsSync(projectLockPath(dir))).toBe(true);
});
});