rewrite single file watcher from scratch to directly poll, and toss in exponential backoff

- why?  because I think it watchFile in node is somehow broken...

Author: williamstein

src/packages/backend/watcher.ts

@@ -25,57 +25,89 @@ lacking in functionality (e.g., https://github.com/paulmillr/chokidar/issues/113
 and declared all bugs fixed, so we steer clear.  It had a lot of issues
 with just noticing actual file changes.
 
+I tried using node:fs's built-in watchFile and it randomly stopped working.
+Very weird.   I think this might have something to do with file paths versus inodes.
+
+I ended up just writing a file watcher using polling from scratch.
+
 We *always* use polling to fully support networked filesystems.
+We use exponential backoff though which doesn't seem to be in any other
+polling implementation, but reduces load and make sense for our use case.
 */
 
 import { EventEmitter } from "node:events";
-import { unwatchFile, watchFile } from "node:fs";
 import { getLogger } from "./logger";
 import { debounce as lodashDebounce } from "lodash";
+import { stat } from "fs/promises";
 
 const logger = getLogger("backend:watcher");
 
+// exponential backoff to reduce load for inactive files
+const BACKOFF = 1.2;
+const MIN_INTERVAL_MS = 750;
+const MAX_INTERVAL_MS = 5000;
+
 export class Watcher extends EventEmitter {
-  private path: string;
+  private path?: string;
+  private prev: any = null;
+  private interval: number;
+  private minInterval: number;
+  private maxInterval: number;
 
   constructor(
     path: string,
-    { debounce, interval = 750 }: { debounce?: number; interval?: number } = {},
+    {
+      debounce,
+      interval = MIN_INTERVAL_MS,
+      maxInterval = MAX_INTERVAL_MS,
+    }: { debounce?: number; interval?: number; maxInterval?: number } = {},
   ) {
     super();
-    this.path = path;
-
-    logger.debug("watchFile", { path, debounce, interval });
-    watchFile(this.path, { persistent: false, interval }, this.handleChange);
-
     if (debounce) {
       this.emitChange = lodashDebounce(this.emitChange, debounce);
     }
+    logger.debug("Watcher", { path, debounce, interval, maxInterval });
+    this.path = path;
+    this.minInterval = interval;
+    this.maxInterval = maxInterval;
+    this.interval = interval;
+    setTimeout(this.update, interval);
   }
 
-  private emitChange = (stats) => {
-    this.emit("change", stats.ctime, stats);
-  };
-
-  private handleChange = (curr, prev) => {
-    const path = this.path;
-    if (!curr.dev) {
-      logger.debug("handleChange: delete", { path });
-      this.emit("delete");
+  private update = async () => {
+    if (this.path == null) {
+      // closed
       return;
     }
-    if (curr.mtimeMs == prev.mtimeMs && curr.mode == prev.mode) {
-      logger.debug("handleChange: access but no change", { path });
-      // just *accessing* triggers watchFile (really StatWatcher), of course.
-      return;
+    try {
+      const prev = this.prev;
+      const curr = await stat(this.path);
+      if (curr.mtimeMs != prev?.mtimeMs || curr.mode != prev?.mode) {
+        this.prev = curr;
+        this.interval = this.minInterval;
+        this.emitChange(curr);
+      }
+    } catch (_err) {
+      if (this.prev != null) {
+        this.interval = this.minInterval;
+        this.prev = null;
+        logger.debug("delete", this.path);
+        this.emit("delete");
+      }
+    } finally {
+      setTimeout(this.update, this.interval);
+      this.interval = Math.min(this.maxInterval, this.interval * BACKOFF);
     }
-    logger.debug("handleChange: change", { path });
-    this.emitChange(curr);
+  };
+
+  private emitChange = (stats) => {
+    logger.debug("change", this.path);
+    this.emit("change", stats.ctime, stats);
   };
 
   close = () => {
     logger.debug("close", this.path);
     this.removeAllListeners();
-    unwatchFile(this.path, this.handleChange);
+    delete this.path;
   };
 }

src/packages/util/failing-to-save.ts

@@ -44,7 +44,7 @@ export function failing_to_save(
   hash: number,
   expected_hash?: number
 ): boolean {
-  if (expected_hash == undefined) {
+  if (expected_hash == null) {
     return false;
   }
   if (!state[path]) {