use homemade filelock impl instead of proper-lockfile

Author: Sebastian-Webster

package-lock.json

@@ -32,7 +32,6 @@
     "@babel/preset-typescript": "^7.25.9",
     "@types/adm-zip": "^0.5.5",
     "@types/node": "^22.7.9",
-    "@types/proper-lockfile": "^4.1.4",
     "@types/semver": "^7.5.8",
     "babel-jest": "^29.7.0",
     "jest": "^29.7.0",
@@ -41,7 +40,6 @@
   },
   "dependencies": {
     "adm-zip": "^0.5.16",
-    "proper-lockfile": "^4.1.2",
     "semver": "^7.6.3"
   },
   "repository": {

package.json

@@ -6,9 +6,8 @@ import AdmZip from 'adm-zip'
 import { normalize as normalizePath } from 'path';
 import { randomUUID } from 'crypto';
 import { execFile } from 'child_process';
-import { lockSync } from 'proper-lockfile';
 import { BinaryInfo, InternalServerOptions } from '../../types';
-import { waitForLock } from './FileLock';
+import { lockFile, waitForLock } from './FileLock';
 
 function getZipData(entry: AdmZip.IZipEntry): Promise<Buffer> {
     return new Promise((resolve, reject) => {
@@ -205,10 +204,10 @@ export function downloadBinary(binaryInfo: BinaryInfo, options: InternalServerOp
 
             while (true) {
                 try {
-                    releaseFunction = lockSync(extractedPath, {realpath: false})
+                    releaseFunction = await lockFile(extractedPath)
                     break
                 } catch (e) {
-                    if (e.code === 'ELOCKED') {
+                    if (e === 'LOCKED') {
                         logger.log('Waiting for lock for MySQL version', version)
                         await waitForLock(extractedPath, options)
                         logger.log('Lock is gone for version', version)

src/libraries/Downloader.ts

@@ -8,8 +8,7 @@ import { GenerateRandomPort } from "./Port";
 import DBDestroySignal from "./AbortSignal";
 import { ExecuteFileReturn, InstalledMySQLVersion, InternalServerOptions, MySQLDB } from "../../types";
 import {normalize as normalizePath, resolve as resolvePath} from 'path'
-import { lockSync } from 'proper-lockfile';
-import { waitForLock } from "./FileLock";
+import { lockFile, waitForLock } from "./FileLock";
 
 class Executor {
     logger: Logger;
@@ -316,10 +315,10 @@ class Executor {
 
                     while(true) {
                         try {
-                            lockRelease = lockSync(copyPath, {realpath: false})
+                            lockRelease = await lockFile(copyPath)
                             break
                         } catch (e) {
-                            if (e.code === 'ELOCKED') {
+                            if (e === 'LOCKED') {
                                 this.logger.log('Waiting for lock for libaio copy')
                                 await waitForLock(copyPath, options)
                                 this.logger.log('Lock is gone for libaio copy')

src/libraries/Executor.ts

@@ -1,22 +1,57 @@
-import { checkSync } from "proper-lockfile";
+import fsPromises from 'fs/promises';
 import { InternalServerOptions } from "../../types";
 
-export function waitForLock(path: string, options: InternalServerOptions): Promise<void> {
-    return new Promise(async (resolve, reject) => {
-        let retries = 0;
-        while (retries <= options.lockRetries) {
-            retries++
-            try {
-                const locked = checkSync(path, {realpath: false});
-                if (!locked) {
-                    return resolve()
-                } else {
-                    await new Promise(resolve => setTimeout(resolve, options.lockRetryWait))
-                }
-            } catch (e) {
-                return reject(e)
+export async function waitForLock(path: string, options: InternalServerOptions): Promise<void> {
+    const lockPath = `${path}.lock`
+    let retries = 0;
+    do {
+        retries++;
+        try {
+            const stat = await fsPromises.stat(lockPath)
+            if (performance.now() - stat.mtime.getTime() > 10_000) {
+                return
+            } else {
+                await new Promise(resolve => setTimeout(resolve, options.lockRetryWait))
             }
+        } catch (e) {
+            if (e.code === 'ENOENT') {
+                return
+            } else {
+                throw e
+            }
+        }
+    } while(retries <= options.lockRetries)
+}
+
+function setupMTimeEditor(lockPath: string): () => Promise<void> {
+    const interval = setInterval(async () => {
+        try {
+            const time = performance.now();
+            await fsPromises.utimes(lockPath, time, time)
+        } catch {}
+    }, 2_000)
+
+    return async () => {
+        clearInterval(interval)
+        await fsPromises.rmdir(lockPath)
+    }
+}
+
+export async function lockFile(path: string): Promise<() => Promise<void>> {
+    const lockPath = `${path}.lock`
+    try {
+        await fsPromises.mkdir(lockPath)
+        return setupMTimeEditor(lockPath)
+    } catch (e) {
+        if (e.code === 'EEXIST') {
+            const stat = await fsPromises.stat(lockPath)
+            if (performance.now() - stat.mtime.getTime() > 10_000) {
+                return setupMTimeEditor(lockPath)
+            } else {
+                throw 'LOCKED'
+            }
+        } else {
+            throw e
         }
-        reject(`lockRetries has been exceeded. Lock had not been released after ${options.lockRetryWait} * ${options.lockRetries} milliseconds.`)
-    })
+    }
 }