@dxos/lock-file 0.8.4-main.67995b8 → 0.8.4-main.a4bbb77

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/lock-file",
-  "version": "0.8.4-main.67995b8",
+  "version": "0.8.4-main.a4bbb77",
   "description": "Lock file .",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -10,9 +10,9 @@
   "type": "module",
   "exports": {
     ".": {
+      "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
-      "node": "./dist/lib/node-esm/index.mjs",
-      "source": "./src/index.ts"
+      "node": "./dist/lib/node-esm/index.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
@@ -24,13 +24,11 @@
     "src"
   ],
   "dependencies": {
-    "fs-ext": "^2.0.0",
-    "@dxos/async": "0.8.4-main.67995b8",
-    "@dxos/node-std": "0.8.4-main.67995b8"
-  },
-  "devDependencies": {
-    "@types/fs-ext": "^2.0.0"
+    "koffi": "^2.8.0",
+    "@dxos/async": "0.8.4-main.a4bbb77",
+    "@dxos/node-std": "0.8.4-main.a4bbb77"
   },
+  "devDependencies": {},
   "publishConfig": {
     "access": "public"
   }

package/src/lock-file.node.test.ts

@@ -4,18 +4,27 @@
 
 import { spawn } from 'node:child_process';
 import { existsSync, mkdirSync, unlinkSync } from 'node:fs';
+import { rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { beforeAll, describe, expect, onTestFinished, test } from 'vitest';
+
+import { afterAll, beforeAll, describe, expect, onTestFinished, test } from 'vitest';
 
 import { Trigger } from '@dxos/async';
 
 import { LockFile } from './lock-file';
 
 const TEST_DIR = '/tmp/dxos/testing/lock-file';
+const TEMP_TEST_DIR = join(tmpdir(), 'lock-file-test-' + Date.now());
 
 describe('LockFile', () => {
   beforeAll(() => {
     mkdirSync(TEST_DIR, { recursive: true });
+    mkdirSync(TEMP_TEST_DIR, { recursive: true });
+  });
+
+  afterAll(async () => {
+    await rm(TEMP_TEST_DIR, { recursive: true, force: true });
   });
 
   test('basic', async () => {
@@ -38,16 +47,21 @@ describe('LockFile', () => {
     });
 
     const trigger = new Trigger();
-    const processHandle = spawn('node', ['-e', `(${lockInProcess.toString()})(${JSON.stringify(filename)})`], {
+    const processHandle = spawn('vite-node', [new URL('./locker-subprocess.ts', import.meta.url).pathname, filename], {
       stdio: 'pipe',
     });
 
     {
       // Wait for process to start
-
       processHandle.stdout.on('data', (data: Uint8Array) => {
-        expect(data.toString().trim()).to.equal('locked');
-        trigger.wake();
+        process.stdout.write(data);
+        if (data.toString().trim().startsWith('#')) {
+          expect(data.toString().trim()).to.equal('# locked');
+          trigger.wake();
+        }
+      });
+      processHandle.on('exit', (code) => {
+        trigger.throw(new Error(`Process exited pre with code ${code}`));
       });
     }
 
@@ -56,7 +70,50 @@ describe('LockFile', () => {
     await expect(LockFile.acquire(filename)).rejects.toBeInstanceOf(Error);
 
     processHandle.stdin.write('close');
-    processHandle.kill();
+
+    // Wait for process to be killed
+    await expect
+      .poll(async () => {
+        return await LockFile.isLocked(filename);
+      })
+      .toBe(false);
+
+    const handle = await LockFile.acquire(filename);
+    await LockFile.release(handle);
+  });
+
+  test('released when process killed with SIGKILL', { timeout: 10_000 }, async () => {
+    const filename = join(TEST_DIR, `lock-${Math.random()}.lock`);
+    onTestFinished(() => {
+      if (existsSync(filename)) {
+        unlinkSync(filename);
+      }
+    });
+
+    const trigger = new Trigger();
+    const processHandle = spawn('vite-node', [new URL('./locker-subprocess.ts', import.meta.url).pathname, filename], {
+      stdio: 'pipe',
+    });
+
+    {
+      // Wait for process to start
+      processHandle.stdout.on('data', (data: Uint8Array) => {
+        process.stdout.write(data);
+        if (data.toString().trim().startsWith('#')) {
+          expect(data.toString().trim()).to.equal('# locked');
+          trigger.wake();
+        }
+      });
+      processHandle.on('exit', (code) => {
+        trigger.throw(new Error(`Process exited pre with code ${code}`));
+      });
+    }
+
+    await trigger.wait({ timeout: 5_000 });
+
+    await expect(LockFile.acquire(filename)).rejects.toBeInstanceOf(Error);
+
+    processHandle.kill('SIGKILL');
 
     // Wait for process to be killed
     await expect
@@ -80,44 +137,55 @@ describe('LockFile', () => {
       expect(await LockFile.isLocked(filename)).to.be.false;
     }
   });
-});
 
-// NOTE: Self-contained so when function.toString is called the code runs.
-const lockInProcess = (filename: string) => {
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const { open } = require('node:fs/promises');
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const { constants } = require('node:fs');
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const { flock } = require('fs-ext');
-
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  let fileHandle;
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  open(filename, constants.O_CREAT).then((handle) => {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    flock(handle.fd, 'exnb', (err) => {
-      if (err) {
-        handle.close();
-        console.error(err);
-        return;
-      }
-      fileHandle = handle;
-      console.log('locked');
-      // Hang
-      setTimeout(() => {}, 1_000_000);
-    });
+  // New tests merged from lock-file.test.ts
+  test('should acquire and release lock', async () => {
+    const lockFile = join(TEMP_TEST_DIR, 'test.lock');
+    const handle = await LockFile.acquire(lockFile);
+    expect(handle).toBeDefined();
+    expect(handle.fd).toBeGreaterThan(0);
+
+    // Lock should be held
+    await expect(LockFile.isLocked(lockFile)).resolves.toBe(true);
+
+    await LockFile.release(handle);
+
+    // Lock should be released
+    await expect(LockFile.isLocked(lockFile)).resolves.toBe(false);
   });
 
-  // Close file handle on stdin close.
-  process.stdin.on('data', (data) => {
-    if (data.toString().trim() === 'close') {
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      fileHandle.close();
-    }
+  test('should fail to acquire lock when already locked', async () => {
+    const lockFile = join(TEMP_TEST_DIR, 'test2.lock');
+    const handle = await LockFile.acquire(lockFile);
+
+    // Try to acquire again - should fail
+    await expect(LockFile.acquire(lockFile)).rejects.toThrow('flock failed');
+
+    await LockFile.release(handle);
   });
-};
+
+  test('isLocked should return false for non-existent file', async () => {
+    const nonExistent = join(TEMP_TEST_DIR, 'non-existent.lock');
+    await expect(LockFile.isLocked(nonExistent)).resolves.toBe(false);
+  });
+
+  test('should handle concurrent lock attempts', async () => {
+    const lockFile = join(TEMP_TEST_DIR, 'test3.lock');
+    const handle = await LockFile.acquire(lockFile);
+
+    // Multiple attempts to acquire should all fail
+    const attempts = Array(5)
+      .fill(0)
+      .map(() => LockFile.acquire(lockFile).catch((err) => err));
+
+    const results = await Promise.all(attempts);
+
+    // All attempts should have failed
+    results.forEach((result) => {
+      expect(result).toBeInstanceOf(Error);
+      expect(result.message).toContain('flock failed');
+    });
+
+    await LockFile.release(handle);
+  });
+});

package/src/lock-file.ts

@@ -2,37 +2,37 @@
 // Copyright 2023 DXOS.org
 //
 
-import { flock } from 'fs-ext';
 import { existsSync } from 'node:fs';
-import { open, type FileHandle, constants } from 'node:fs/promises';
+import { type FileHandle, constants, open } from 'node:fs/promises';
+
+import { LockfileSys } from './sys';
+
+const sys = new LockfileSys();
 
 export class LockFile {
   static async acquire(filename: string): Promise<FileHandle> {
-    const handle = await open(filename, constants.O_CREAT);
-    await new Promise<void>((resolve, reject) => {
-      flock(handle.fd, 'exnb', async (err) => {
-        if (err) {
-          reject(err);
-          await handle.close();
-          return;
-        }
-        resolve();
-      });
-    });
-    return handle;
+    await sys.init();
+
+    const handle = await open(filename, constants.O_CREAT | constants.O_RDWR);
+
+    try {
+      // Try to acquire exclusive non-blocking lock
+      sys.flock(handle.fd, 'exnb');
+      return handle;
+    } catch (err) {
+      // Close the file handle if we can't acquire the lock
+      await handle.close();
+      throw err;
+    }
   }
 
   static async release(handle: FileHandle): Promise<void> {
-    await new Promise<void>((resolve, reject) => {
-      flock(handle.fd, 'un', (err) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve();
-      });
-    });
-    await handle.close();
+    try {
+      // Release the lock
+      sys.flock(handle.fd, 'un');
+    } finally {
+      await handle.close();
+    }
   }
 
   static async isLocked(filename: string): Promise<boolean> {
@@ -42,7 +42,6 @@ export class LockFile {
     try {
       const handle = await LockFile.acquire(filename);
       await LockFile.release(handle);
-
       return false;
     } catch (e) {
       return true;

package/src/locker-subprocess.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { LockFile } from './lock-file';
+
+const filename = process.argv[2];
+
+console.log('will lock');
+
+const handle = await LockFile.acquire(filename);
+// parents looks for # symbol in the output to know when the lock is acquired
+console.log('# locked');
+
+// Close file handle on stdin close.
+process.stdin.on('data', async (data) => {
+  if (data.toString().trim() === 'close') {
+    console.log('will unlock');
+    await LockFile.release(handle);
+    console.log('unlocked');
+  }
+});

package/src/sys.ts

@@ -0,0 +1,84 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { platform } from 'node:os';
+
+import type * as koffi from 'koffi';
+
+// flock constants
+const LOCK_SH = 1; // Shared lock
+const LOCK_EX = 2; // Exclusive lock
+const LOCK_NB = 4; // Non-blocking
+const LOCK_UN = 8; // Unlock
+
+export class LockfileSys {
+  private _init: Promise<void> | null = null;
+
+  private _koffi: typeof koffi | null = null;
+  private _libc: koffi.IKoffiLib | null = null;
+  private _flockNative: koffi.KoffiFunction | null = null;
+
+  async init() {
+    await (this._init ??= this._runInit());
+  }
+
+  private async _runInit() {
+    this._koffi = await import('koffi');
+    switch (platform()) {
+      case 'darwin':
+        this._libc = this._koffi.load('libc.dylib');
+        break;
+      case 'linux':
+        this._libc = this._koffi.load('libc.so.6');
+        break;
+      default:
+        throw new Error(`Unsupported platform: ${platform()}`);
+    }
+    this._flockNative = this._libc.func('flock', 'int', ['int', 'int']);
+  }
+
+  flock(fd: number, operation: string) {
+    if (!this._flockNative) {
+      throw new Error('flock not initialized');
+    }
+    let op = 0;
+
+    switch (operation) {
+      case 'ex':
+        op = LOCK_EX;
+        break;
+      case 'exnb':
+        op = LOCK_EX | LOCK_NB;
+        break;
+      case 'sh':
+        op = LOCK_SH;
+        break;
+      case 'shnb':
+        op = LOCK_SH | LOCK_NB;
+        break;
+      case 'un':
+        op = LOCK_UN;
+        break;
+      default:
+        throw new Error(`Invalid flock operation: ${operation}`);
+    }
+
+    const result = this._flockNative!(fd, op);
+
+    if (result !== 0) {
+      // Get the errno to provide a more meaningful error
+      const errno = this._koffi!.errno();
+      const errorMessages: { [key: number]: string } = {
+        11: 'Resource temporarily unavailable (EAGAIN/EWOULDBLOCK)',
+        13: 'Permission denied (EACCES)',
+        22: 'Invalid argument (EINVAL)',
+        9: 'Bad file descriptor (EBADF)',
+        35: 'Resource temporarily unavailable (EAGAIN on macOS)',
+      };
+
+      const errorMessage = errorMessages[errno] || `Unknown error (errno: ${errno})`;
+      throw new Error(`flock failed: ${errorMessage}`);
+    }
+  }
+}