Skip to content

The open-source app everyone uses to manage agents at work

fix(adapter-utils): make the directory merge lock crash test deterministic (#14881)

Nicky Leach9d0f7e2ddd59
diff --git a/packages/adapter-utils/src/directory-merge-lock.test.ts b/packages/adapter-utils/src/directory-merge-lock.test.ts
index c05305fb8d..a2b71aac55 100644
--- a/packages/adapter-utils/src/directory-merge-lock.test.ts
+++ b/packages/adapter-utils/src/directory-merge-lock.test.ts
@@ -10,7 +10,13 @@ import { afterEach, describe, expect, it, vi } from "vitest";
import { withDirectoryMergeLock, WORKSPACE_RESTORE_LOCK_TIMEOUT_CODE } from "./workspace-restore-merge.js";
describe("directory merge lock process lifetime", () => {
- const loader = fileURLToPath(new URL("../../../cli/node_modules/tsx/dist/cli.mjs", import.meta.url));
+ // Load tsx as an --import hook, not tsx's own CLI entry point. The CLI entry
+ // point re-spawns the evaluated code in a further child process, so killing
+ // the process this file spawns would leave that further child as an orphan
+ // that still holds the lock. The --import hook runs the evaluated code in
+ // the process this file spawns directly, so killing it really does release
+ // the lock.
+ const loader = fileURLToPath(new URL("../../../cli/node_modules/tsx/dist/loader.mjs", import.meta.url));
const module = fileURLToPath(new URL("./workspace-restore-merge.ts", import.meta.url));
const directories: string[] = [];
const children: ChildProcess[] = [];
@@ -38,7 +44,7 @@ describe("directory merge lock process lifetime", () => {
}
async function holder(target: string, env: NodeJS.ProcessEnv) {
- const child = spawn(process.execPath, [loader, "--eval", `
+ const child = spawn(process.execPath, ["--import", loader, "--eval", `
import { withDirectoryMergeLock } from ${JSON.stringify(module)};
withDirectoryMergeLock(${JSON.stringify(target)}, async () => {
process.send?.("locked");
@@ -63,10 +69,15 @@ describe("directory merge lock process lifetime", () => {
return await access(`${lock}.owner.json`).then(() => `${lock}.owner.json`, () => path.join(lock, "owner.json"));
}
- function expireWait() {
- const now = Date.now();
- return vi.spyOn(Date, "now").mockReturnValueOnce(now).mockReturnValue(now + 60_000);
- }
+ // A short real wait budget for a test that asserts a timeout. 200 ms still
+ // lets the implementation's 50 ms retry interval run at least 4 retries, so
+ // the timeout is reached because the lock is genuinely held, not because
+ // the clock was replaced.
+ const TIMEOUT_ASSERTION_WAIT_MS = 200;
+ // A short real wait budget for the crash-recovery test, which asserts a
+ // successful acquisition. It must absorb ordinary scheduling jitter around
+ // the crash while still resolving well inside the test timeout below.
+ const CRASH_RECOVERY_WAIT_MS = 5_000;
it("recovers a killed holder even when its recorded PID has been reused", async () => {
const { target, env, lock } = await fixture();
@@ -77,10 +88,7 @@ describe("directory merge lock process lifetime", () => {
const recordPath = await ownerPath(lock);
const record = JSON.parse(await readFile(recordPath, "utf8"));
await writeFile(recordPath, JSON.stringify({ ...record, pid: process.pid }));
- const clock = expireWait();
- try {
- await expect(withDirectoryMergeLock(target, async () => "restored", env)).resolves.toBe("restored");
- } finally { clock.mockRestore(); }
+ await expect(withDirectoryMergeLock(target, async () => "restored", env, undefined, CRASH_RECOVERY_WAIT_MS)).resolves.toBe("restored");
}, 15_000);
it("protects a live holder in another process regardless of diagnostic PID or age", async () => {
@@ -89,10 +97,7 @@ describe("directory merge lock process lifetime", () => {
const recordPath = await ownerPath(lock);
await writeFile(recordPath, JSON.stringify({ pid: 2_147_483_647, createdAt: "2000-01-01T00:00:00.000Z" }));
const contender = vi.fn();
- const clock = expireWait();
- try {
- await expect(withDirectoryMergeLock(target, contender, env)).rejects.toMatchObject({ code: WORKSPACE_RESTORE_LOCK_TIMEOUT_CODE });
- } finally { clock.mockRestore(); }
+ await expect(withDirectoryMergeLock(target, contender, env, undefined, TIMEOUT_ASSERTION_WAIT_MS)).rejects.toMatchObject({ code: WORKSPACE_RESTORE_LOCK_TIMEOUT_CODE });
expect(contender).not.toHaveBeenCalled();
const exited = once(child, "exit");
child.send("release");
@@ -109,18 +114,12 @@ describe("directory merge lock process lifetime", () => {
it("keeps the OS lock when a same-process contender closes its connection", async () => {
const { target, env } = await fixture();
await withDirectoryMergeLock(target, async () => {
- const clock = expireWait();
- try {
- await expect(withDirectoryMergeLock(target, async () => undefined, env)).rejects.toMatchObject({ code: WORKSPACE_RESTORE_LOCK_TIMEOUT_CODE });
- } finally { clock.mockRestore(); }
+ await expect(withDirectoryMergeLock(target, async () => undefined, env, undefined, TIMEOUT_ASSERTION_WAIT_MS)).rejects.toMatchObject({ code: WORKSPACE_RESTORE_LOCK_TIMEOUT_CODE });
// A same-process test alone cannot prove that the OS lock survived: on
// POSIX, closing an unmanaged descriptor can drop process-wide locks.
- const result = await promisify(execFile)(process.execPath, [loader, "--eval", `
+ const result = await promisify(execFile)(process.execPath, ["--import", loader, "--eval", `
import { withDirectoryMergeLock, WORKSPACE_RESTORE_LOCK_TIMEOUT_CODE } from ${JSON.stringify(module)};
- const now = Date.now();
- let calls = 0;
- Date.now = () => now + calls++ * 60_000;
- withDirectoryMergeLock(${JSON.stringify(target)}, async () => "entered")
+ withDirectoryMergeLock(${JSON.stringify(target)}, async () => "entered", undefined, undefined, ${TIMEOUT_ASSERTION_WAIT_MS})
.then(() => { console.error("Entered a live holder's lock"); process.exit(1); })
.catch(error => {
if (error.code !== WORKSPACE_RESTORE_LOCK_TIMEOUT_CODE) { console.error(error); process.exit(1); }
@@ -162,10 +161,7 @@ describe("directory merge lock process lifetime", () => {
await mkdir(lock, { recursive: true });
if (kind !== "missing") await writeFile(path.join(lock, "owner.json"), kind === "malformed" ? "{broken" : JSON.stringify({ pid: 2_147_483_647, createdAt: "2000-01-01T00:00:00.000Z" }));
const contender = vi.fn();
- const clock = expireWait();
- try {
- await expect(withDirectoryMergeLock(target, contender, env)).rejects.toMatchObject({ code: WORKSPACE_RESTORE_LOCK_TIMEOUT_CODE });
- } finally { clock.mockRestore(); }
+ await expect(withDirectoryMergeLock(target, contender, env, undefined, TIMEOUT_ASSERTION_WAIT_MS)).rejects.toMatchObject({ code: WORKSPACE_RESTORE_LOCK_TIMEOUT_CODE });
expect(contender).not.toHaveBeenCalled();
expect((await stat(lock)).isDirectory()).toBe(true);
});
diff --git a/packages/adapter-utils/src/workspace-restore-merge.ts b/packages/adapter-utils/src/workspace-restore-merge.ts
index 6b05b135b9..14c58371b3 100644
--- a/packages/adapter-utils/src/workspace-restore-merge.ts
+++ b/packages/adapter-utils/src/workspace-restore-merge.ts
@@ -341,9 +341,9 @@ export function describeWorkspaceRestoreFailure(code: WorkspaceRestoreFailureCod
}
}
-async function acquireDirectoryMergeLock(lockDir: string, operation?: DirectoryMergeLockOperation): Promise<() => Promise<void>> {
+async function acquireDirectoryMergeLock(lockDir: string, operation?: DirectoryMergeLockOperation, waitMs: number = LOCK_WAIT_MS): Promise<() => Promise<void>> {
const startedAt = performance.now();
- const deadline = Date.now() + LOCK_WAIT_MS;
+ const deadline = Date.now() + waitMs;
const databasePath = `${lockDir}.sqlite`;
const ownerPath = `${lockDir}.owner.json`;
async function waitForLock(diagnosticOwnerPath: string) {
@@ -496,13 +496,16 @@ export async function withDirectoryMergeLock<T>(
fn: (canonicalTargetDir: string) => Promise<T>,
env: NodeJS.ProcessEnv = process.env,
diagnosticOperation?: DirectoryMergeLockOperation,
+ // Test seam only: overrides how long acquisition waits before it reports a
+ // timeout. Production callers must omit this and keep the real budget.
+ waitMs: number = LOCK_WAIT_MS,
): Promise<T> {
// Canonicalize before we hash or lock: a retargeted symlink must not let the
// lock protect one directory while the caller mutates another.
const canonicalTargetDir = await fs.realpath(targetDir);
const lockRoot = await resolveDirectoryMergeLockRoot(env);
const lockKey = createHash("sha256").update(canonicalTargetDir).digest("hex");
- const releaseLock = await acquireDirectoryMergeLock(path.join(lockRoot, `${lockKey}.lock`), diagnosticOperation);
+ const releaseLock = await acquireDirectoryMergeLock(path.join(lockRoot, `${lockKey}.lock`), diagnosticOperation, waitMs);
try {
return await fn(canonicalTargetDir);
} finally {