feat: allow second precision in mtime comparison (#78)

Author: Alan Shaw

lib/lockfile.js

@@ -111,7 +111,7 @@ function updateLock(file, options) {
                 return updateLock(file, options);
             }
 
-            const isMtimeOurs = lock.mtime.getTime() === stat.mtime.getTime();
+            const isMtimeOurs = lock.mtimeChecker(lock.mtime, stat.mtime);
 
             if (!isMtimeOurs) {
                 return setLockAsCompromised(
@@ -229,6 +229,7 @@ function lock(file, options, callback) {
                     mtime: stat.mtime,
                     options,
                     lastUpdate: Date.now(),
+                    mtimeChecker: createMtimeChecker(),
                 };
 
                 // We must keep the lock fresh to avoid staleness
@@ -309,6 +310,29 @@ function getLocks() {
     return locks;
 }
 
+function createMtimeChecker() {
+    let precision;
+
+    return (lockMtime, statMtime) => {
+        // If lock time was not on the second we can determine precision
+        if (!precision && lockMtime % 1000 !== 0) {
+            precision = statMtime % 1000 === 0 ? 's' : 'ms';
+        }
+
+        if (precision === 's') {
+            const lockTs = lockMtime.getTime();
+            const statTs = statMtime.getTime();
+
+            // Maybe the file system truncates or rounds...
+            return Math.trunc(lockTs / 1000) === Math.trunc(statTs / 1000) ||
+              Math.round(lockTs / 1000) === Math.round(statTs / 1000);
+        }
+
+        // Must be ms or lockMtime was on the second
+        return lockMtime.getTime() === statMtime.getTime();
+    };
+}
+
 // Remove acquired locks on exit
 /* istanbul ignore next */
 onExit(() => {

test/lock.test.js

@@ -520,3 +520,83 @@ it('should not fail to update mtime when we are over the threshold but mtime is
     }, 1000);
     await pDelay(5000);
 }, 16000);
+
+it('should allow truncated second precision mtime', async () => {
+    fs.writeFileSync(`${tmpDir}/foo`, '');
+
+    const customFs = {
+        ...fs,
+        stat(path, cb) {
+            fs.stat(path, (err, stat) => {
+                if (err) {
+                    return cb(err);
+                }
+
+                // Make second precision if not already
+                stat.mtime = new Date(Math.trunc(stat.mtime.getTime() / 1000) * 1000);
+                cb(null, stat);
+            });
+        },
+    };
+
+    const deferred = pDefer();
+
+    // If the module does not detect second precision for mtime, the mtime
+    // comparison will cause the lock to appear compromised.
+    const handleCompromised = (err) => {
+        clearTimeout(successTimeoutId);
+        deferred.reject(err);
+    };
+
+    await lockfile.lock(`${tmpDir}/foo`, {
+        fs: customFs,
+        update: 1000,
+        onCompromised: handleCompromised,
+    });
+
+    // First update is fine because we `stat` after we `mkdir`, it'll fail on
+    // the second update when we use `utimes` and do not `stat` for the `mtime`
+    const successTimeoutId = setTimeout(deferred.resolve, 3000);
+
+    await deferred.promise;
+});
+
+it('should allow rounded second precision mtime', async () => {
+    fs.writeFileSync(`${tmpDir}/foo`, '');
+
+    const customFs = {
+        ...fs,
+        stat(path, cb) {
+            fs.stat(path, (err, stat) => {
+                if (err) {
+                    return cb(err);
+                }
+
+                // Make second precision if not already
+                stat.mtime = new Date(Math.round(stat.mtime.getTime() / 1000) * 1000);
+                cb(null, stat);
+            });
+        },
+    };
+
+    const deferred = pDefer();
+
+    // If the module does not detect second precision for mtime, the mtime
+    // comparison will cause the lock to appear compromised.
+    const handleCompromised = (err) => {
+        clearTimeout(successTimeoutId);
+        deferred.reject(err);
+    };
+
+    await lockfile.lock(`${tmpDir}/foo`, {
+        fs: customFs,
+        update: 1000,
+        onCompromised: handleCompromised,
+    });
+
+    // First update is fine because we `stat` after we `mkdir`, it'll fail on
+    // the second update when we use `utimes` and do not `stat` for the `mtime`
+    const successTimeoutId = setTimeout(deferred.resolve, 3000);
+
+    await deferred.promise;
+});