More

Author: timfish

.github/workflows/ci.yml

@@ -416,7 +416,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        os: [ubuntu-latest, macos-latest, windows-2022]
         node: [18, 26]
     steps:
       - name: Check out current commit

src/index.ts

@@ -1,12 +1,12 @@
 /* eslint-disable no-console */
 import type { AsyncLocalStorage } from 'node:async_hooks';
 import { spawnSync } from 'node:child_process';
-import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { env } from 'node:process';
 import { threadId } from 'node:worker_threads';
 import { abi, arch, identifier, platform, stdlib } from './constants';
 import { copyBinary } from './copy-binary';
+import { withRebuildLock } from './rebuild-lock';
 
 type AsyncStorageArgs = {
   /** The AsyncLocalStorage instance used to fetch the store */
@@ -257,27 +257,13 @@ function getNativeModule(): Native {
     return nativeModule;
   }
 
-  // Exclusive-create a lock file so only one process/thread runs node-gyp at a
-  // time. Losers (EEXIST) wait for the winner to finish before trying to load.
-  const lockFile = path.join(__dirname, '..', '.rebuild-lock');
-  let lockFd: number | undefined;
-  try { lockFd = fs.openSync(lockFile, 'wx'); } catch { /* another caller holds the lock */ }
-
-  if (lockFd !== undefined) {
+  withRebuildLock(() => {
     try {
       recompileFromSource();
     } catch (e) {
       console.warn('Failed to compile from source:', e);
-    } finally {
-      try { fs.closeSync(lockFd); } catch { /* ignore */ }
-      try { fs.unlinkSync(lockFile); } catch { /* ignore */ }
-    }
-  } else {
-    const timer = new Int32Array(new SharedArrayBuffer(4));
-    while (fs.existsSync(lockFile)) {
-      Atomics.wait(timer, 0, 0, 250);
     }
-  }
+  });
 
   // Try again after recompile (or after another caller finished theirs).
   nativeModule = tryLoad();

src/rebuild-lock.ts

@@ -0,0 +1,73 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+const lockFile = path.join(__dirname, '..', '.rebuild-lock');
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    // EPERM: process exists but we can't signal it — treat as alive
+    // ESRCH: no such process — stale lock
+    return (e as NodeJS.ErrnoException).code === 'EPERM';
+  }
+}
+
+function tryAcquire(): number | undefined {
+  let fd: number | undefined;
+  try {
+    fd = fs.openSync(lockFile, 'wx');
+    fs.writeSync(fd, String(process.pid));
+    return fd;
+  } catch {
+    try { if (fd !== undefined) fs.closeSync(fd); } catch { /* ignore */ }
+    return undefined;
+  }
+}
+
+function release(fd: number): void {
+  try { fs.closeSync(fd); } catch { /* ignore */ }
+  try { fs.unlinkSync(lockFile); } catch { /* ignore */ }
+}
+
+function clearStaleLock(): void {
+  try {
+    const pid = parseInt(fs.readFileSync(lockFile, 'utf8'), 10);
+    if (!isNaN(pid) && !isProcessAlive(pid)) {
+      fs.unlinkSync(lockFile);
+    }
+  } catch { /* ignore — another waiter may have already cleared it */ }
+}
+
+function waitForLockRelease(): void {
+  const timer = new Int32Array(new SharedArrayBuffer(4));
+  while (fs.existsSync(lockFile)) {
+    clearStaleLock();
+    Atomics.wait(timer, 0, 0, 250);
+  }
+}
+
+/**
+ * Runs `work` while holding an exclusive lock on `lockFile`. If another caller
+ * holds the lock, blocks until it is released (or until a stale lock from a
+ * crashed process is detected and cleared).
+ */
+export function withRebuildLock(work: () => void): void {
+  let fd = tryAcquire();
+
+  if (fd === undefined) {
+    waitForLockRelease();
+    // Try once more after waiting — another waiter may have cleared a stale
+    // lock and then done the rebuild itself, so we may not need to rebuild.
+    fd = tryAcquire();
+  }
+
+  if (fd !== undefined) {
+    try {
+      work();
+    } finally {
+      release(fd);
+    }
+  }
+}