@dxos/lock-file 0.8.4-main.1da679c → 0.8.4-main.1f223c7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/lock-file",
-  "version": "0.8.4-main.1da679c",
+  "version": "0.8.4-main.1f223c7",
   "description": "Lock file .",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -24,11 +24,13 @@
     "src"
   ],
   "dependencies": {
-    "koffi": "^2.8.0",
-    "@dxos/node-std": "0.8.4-main.1da679c",
-    "@dxos/async": "0.8.4-main.1da679c"
+    "fs-ext": "2.0.0",
+    "@dxos/async": "0.8.4-main.1f223c7",
+    "@dxos/node-std": "0.8.4-main.1f223c7"
+  },
+  "devDependencies": {
+    "@types/fs-ext": "2.0.0"
   },
-  "devDependencies": {},
   "publishConfig": {
     "access": "public"
   }

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

@@ -4,27 +4,19 @@
 
 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 { afterAll, beforeAll, describe, expect, onTestFinished, test } from 'vitest';
+import { 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 () => {
@@ -47,65 +39,16 @@ describe('LockFile', () => {
     });
 
     const trigger = new Trigger();
-    const processHandle = spawn('vite-node', [new URL('./locker-subprocess.ts', import.meta.url).pathname, filename], {
+    const processHandle = spawn('node', ['-e', `(${lockInProcess.toString()})(${JSON.stringify(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.stdin.write('close');
-
-    // 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}`));
+        expect(data.toString().trim()).to.equal('locked');
+        trigger.wake();
       });
     }
 
@@ -113,7 +56,8 @@ describe('LockFile', () => {
 
     await expect(LockFile.acquire(filename)).rejects.toBeInstanceOf(Error);
 
-    processHandle.kill('SIGKILL');
+    processHandle.stdin.write('close');
+    processHandle.kill();
 
     // Wait for process to be killed
     await expect
@@ -137,55 +81,44 @@ describe('LockFile', () => {
       expect(await LockFile.isLocked(filename)).to.be.false;
     }
   });
+});
 
-  // 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);
-  });
-
-  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');
+// 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);
     });
+  });
 
-    await LockFile.release(handle);
+  // 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();
+    }
   });
-});
+};

package/src/lock-file.ts

@@ -5,34 +5,35 @@
 import { existsSync } from 'node:fs';
 import { type FileHandle, constants, open } from 'node:fs/promises';
 
-import { LockfileSys } from './sys';
-
-const sys = new LockfileSys();
+import { flock } from 'fs-ext';
 
 export class LockFile {
   static async acquire(filename: string): Promise<FileHandle> {
-    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;
-    }
+    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;
   }
 
   static async release(handle: FileHandle): Promise<void> {
-    try {
-      // Release the lock
-      sys.flock(handle.fd, 'un');
-    } finally {
-      await handle.close();
-    }
+    await new Promise<void>((resolve, reject) => {
+      flock(handle.fd, 'un', (err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve();
+      });
+    });
+    await handle.close();
   }
 
   static async isLocked(filename: string): Promise<boolean> {
@@ -42,6 +43,7 @@ export class LockFile {
     try {
       const handle = await LockFile.acquire(filename);
       await LockFile.release(handle);
+
       return false;
     } catch (e) {
       return true;

package/dist/types/src/locker-subprocess.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=locker-subprocess.d.ts.map

package/dist/types/src/locker-subprocess.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"locker-subprocess.d.ts","sourceRoot":"","sources":["../../../src/locker-subprocess.ts"],"names":[],"mappings":""}

package/dist/types/src/sys.d.ts

@@ -1,10 +0,0 @@
-export declare class LockfileSys {
-    private _init;
-    private _koffi;
-    private _libc;
-    private _flockNative;
-    init(): Promise<void>;
-    private _runInit;
-    flock(fd: number, operation: string): void;
-}
-//# sourceMappingURL=sys.d.ts.map

package/dist/types/src/sys.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sys.d.ts","sourceRoot":"","sources":["../../../src/sys.ts"],"names":[],"mappings":"AAcA,qBAAa,WAAW;IACtB,OAAO,CAAC,KAAK,CAA8B;IAE3C,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,KAAK,CAAgC;IAC7C,OAAO,CAAC,YAAY,CAAoC;IAElD,IAAI;YAII,QAAQ;IAetB,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;CA2CpC"}

package/src/locker-subprocess.ts

@@ -1,22 +0,0 @@
-//
-// 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

@@ -1,84 +0,0 @@
-//
-// 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}`);
-    }
-  }
-}