this does fix #6580 by adding polling every 7.5 seconds to check readonly status

- chokidar with polling doesn't even report change in permissions, hence
  the original cause of #6580
- cleans up and refactors various code to prevent bugs and confusion,
  but shouldn't actually change anything
- I noticed issues with watching + polling while testing this and will
  address that in another commit

Author: williamstein

src/compute/compute/lib/listings.ts

@@ -52,8 +52,8 @@ export async function initListings({
     project_id,
     compute_server_id,
     getListing,
-    createWatcher: (path: string, debounceMs: number) =>
-      new Watcher(path, debounceMs),
+    createWatcher: (path: string, debounce: number) =>
+      new Watcher(path, { debounce }),
     onDeletePath: (path) => {
       logger.debug("onDeletePath -- TODO:", { path });
     },

src/packages/backend/path-watcher.ts

@@ -4,6 +4,9 @@
  */
 
 /*
+Watch A DIRECTORY for changes.  Use ./watcher.ts for a single file.
+
+
 Slightly generalized fs.watch that works even when the directory doesn't exist,
 but also doesn't provide any information about what changed.
 
@@ -76,11 +79,18 @@ export class Watcher extends EventEmitter {
   private exists: boolean;
   private watchContents?: FSWatcher;
   private watchExistence?: FSWatcher;
+  private interval_ms: number;
   private debounce_ms: number;
   private debouncedChange: any;
   private log: Function;
 
-  constructor(path: string, debounce_ms: number) {
+  constructor(
+    path: string,
+    {
+      debounce: debounce_ms = 0,
+      interval: interval_ms,
+    }: { debounce?: number; interval?: number } = {},
+  ) {
     super();
     this.log = logger.extend(path).debug;
     this.log(`initializing: poll=${POLLING}`);
@@ -89,10 +99,13 @@ export class Watcher extends EventEmitter {
     }
     this.path = path.startsWith("/") ? path : join(process.env.HOME, path);
     this.debounce_ms = debounce_ms;
-    this.debouncedChange = debounce(this.change.bind(this), this.debounce_ms, {
-      leading: true,
-      trailing: true,
-    }).bind(this);
+    this.interval_ms = interval_ms ?? DEFAULT_POLL_MS;
+    this.debouncedChange = this.debounce_ms
+      ? debounce(this.change, this.debounce_ms, {
+          leading: true,
+          trailing: true,
+        }).bind(this)
+      : this.change;
     this.init();
   }
 
@@ -109,8 +122,16 @@ export class Watcher extends EventEmitter {
     }
   }
 
+  private chokidarOptions = () => {
+    return {
+      ...ChokidarOpts,
+      interval: this.interval_ms,
+      binaryInterval: this.interval_ms,
+    };
+  };
+
   private initWatchContents(): void {
-    this.watchContents = watch(this.path, ChokidarOpts);
+    this.watchContents = watch(this.path, this.chokidarOptions());
     this.watchContents.on("all", this.debouncedChange);
     this.watchContents.on("error", (err) => {
       this.log(`error watching listings -- ${err}`);
@@ -119,7 +140,7 @@ export class Watcher extends EventEmitter {
 
   private async initWatchExistence(): Promise<void> {
     const containing_path = path_split(this.path).head;
-    this.watchExistence = watch(containing_path, ChokidarOpts);
+    this.watchExistence = watch(containing_path, this.chokidarOptions());
     this.watchExistence.on("all", this.watchExistenceChange(containing_path));
     this.watchExistence.on("error", (err) => {
       this.log(`error watching for existence of ${this.path} -- ${err}`);
@@ -147,9 +168,9 @@ export class Watcher extends EventEmitter {
     }
   };
 
-  private change(): void {
+  private change = (): void => {
     this.emit("change");
-  }
+  };
 
   public close(): void {
     this.watchExistence?.close();

src/packages/backend/watcher.ts

@@ -4,12 +4,12 @@
  */
 
 /*
-Watch a file for changes
+Watch one SINGLE FILE for changes.   Use ./path-watcher.ts for a directory.
 
 Watch for changes to the given file.  Returns obj, which
 is an event emitter with events:
 
-   - 'change', ctime - when file changes or is created
+   - 'change', ctime, stats - when file changes or is created
    - 'delete' - when file is deleted
 
 and a method .close().
@@ -25,30 +25,30 @@ import { watch, FSWatcher } from "chokidar";
 import { getLogger } from "./logger";
 import { debounce as lodashDebounce } from "lodash";
 
-const L = getLogger("watcher");
+const logger = getLogger("backend:watcher");
 
 export class Watcher extends EventEmitter {
   private path: string;
-  private interval: number;
   private watcher: FSWatcher;
 
-  constructor(path: string, interval: number = 300, debounce: number = 0) {
+  constructor(
+    path: string,
+    { debounce, interval = 300 }: { debounce?: number; interval?: number } = {},
+  ) {
     super();
     this.path = path;
-    this.interval = interval;
 
-    L.debug(`${path}: interval=${interval}, debounce=${debounce}`);
+    logger.debug({ path, debounce, interval });
     this.watcher = watch(this.path, {
-      interval: this.interval,
+      interval,
       // polling is critical for network mounted file systems,
       // and given architecture of cocalc there is no easy way around this.
       // E.g., on compute servers, everything breaks involving sync or cloudfs,
       // and in shared project s3/gcsfuse/sshfs would all break. So we
       // use polling.
       usePolling: true,
-      persistent: false,
+      persistent: true,
       alwaysStat: true,
-      atomic: true,
     });
     this.watcher.on("unlink", () => {
       this.emit("delete");
@@ -57,24 +57,29 @@ export class Watcher extends EventEmitter {
       this.emit("delete");
     });
 
-    const emitChange = lodashDebounce(
-      (ctime) => this.emit("change", ctime),
-      debounce,
-    );
+    const f = (ctime, stats) => {
+      logger.debug("change", this.path, ctime);
+      this.emit("change", ctime, stats);
+    };
+    const emitChange = debounce ? lodashDebounce(f, debounce) : f;
+
     this.watcher.on("error", (err) => {
-      L.debug("WATCHER error -- ", err);
+      logger.debug("WATCHER error -- ", err);
     });
 
     this.watcher.on("change", (_, stats) => {
       if (stats == null) {
-        L.debug("WATCHER change with no stats (shouldn't happen)", { path });
+        logger.debug("WATCHER change with no stats (shouldn't happen)", {
+          path,
+        });
         return;
       }
-      emitChange(stats.ctime);
+      emitChange(stats.ctime, stats);
     });
   }
 
   close = async () => {
+    logger.debug("close", this.path);
     this.removeAllListeners();
     await this.watcher.close();
   };

src/packages/project/sync/listings.ts

@@ -27,8 +27,8 @@ export function registerListingsTable(table, query): void {
     await close_all_syncdocs_in_tree(path);
   };
 
-  const createWatcher = (path: string, debounceMs: number) =>
-    new Watcher(path, debounceMs);
+  const createWatcher = (path: string, debounce: number) =>
+    new Watcher(path, { debounce });
 
   const { project_id, compute_server_id } = query.listings[0];
 

src/packages/server/purchases/subscription-renewal-emails.ts

@@ -111,7 +111,7 @@ You have ${subs.length} ${siteName} ${plural(
 <ul>
 ${subscriptionList.join("\n")}
 </ul>
-NOTE: You can easily cancel any subscription by clicking the link above without having to sign in to ${siteName}.
+NOTE: You can cancel a subscription via the link above without having to sign in to ${siteName}.
 
 <br/><br/>
 

src/packages/sync-client/lib/client-fs.ts

@@ -220,8 +220,8 @@ export class FileSystemClient {
     debounce?: number;
   }): Watcher => {
     const path = join(this.home, relPath);
-    logger.debug("watching file", path);
-    return new Watcher(path, interval, debounce, );
+    logger.debug("watching file", { path, interval, debounce });
+    return new Watcher(path, { interval, debounce });
   };
 
   is_deleted = (_path: string, _project_id: string) => {