querysub 0.146.0 → 0.148.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.146.0",
+  "version": "0.148.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/src/0-path-value-core/pathValueCore.ts

@@ -580,8 +580,10 @@ class AuthorityPathValueStorage {
         childPaths.add(path);
     }
 
-    /** Called by PathWatcher / ourself when paths are unwatched / destroyed */
-    public markPathAsUnwatched(path: string) {
+    /** Called by PathWatcher / ourself when paths are unwatched / destroyed, to free memory.
+     *      NOOPS if we are the authority of the path.
+     */
+    public destroyPath(path: string) {
         // If we are the authority we:
         //  1) Need to maintain the values for other nodes
         //  2) Don't need to worry about the values getting out of date,
@@ -1096,7 +1098,7 @@ class AuthorityPathValueStorage {
 
             if (pathsToClear.size > 0) {
                 for (let path of pathsToClear) {
-                    this.markPathAsUnwatched(path);
+                    this.destroyPath(path);
                     // I'm not sure if removing it as a parent is needed, or... maybe it is needed,
                     //  and this isn't enough of a check?
                     this.markParentPathAsUnwatched(path);
@@ -1322,27 +1324,6 @@ class PathWatcher {
 
         let pathsWatched = this.watchersToPaths.get(callback);
 
-        for (let path of config.paths) {
-            if (pathsWatched) {
-                pathsWatched.paths.delete(path);
-            }
-
-            let watchers = this.watchers.get(path);
-            if (!watchers) continue;
-            watchers.watchers.delete(callback);
-            if (watchers.watchers.size === 0) {
-                this.watchers.delete(path);
-
-                let parentPath = getParentPathStr(path);
-                let parentWatchers = this.watcherParentToPath.get(parentPath);
-                if (parentWatchers) {
-                    parentWatchers.delete(path);
-                }
-
-                fullyUnwatched.paths.push(path);
-                authorityStorage.markPathAsUnwatched(path);
-            }
-        }
         for (let path of config.parentPaths) {
             if (pathsWatched) {
                 pathsWatched.parents.delete(path);
@@ -1364,6 +1345,46 @@ class PathWatcher {
 
                 if (watchersObj.size === 0) {
                     this.parentWatchers.delete(unpackedPath);
+
+                    let childPaths = authorityStorage.getPathsFromParent(unpackedPath);
+                    // Destroy values that now have no watchers (no value watchers, and now no parent watcher
+                    if (childPaths) {
+                        for (let childPath of childPaths) {
+                            if (!this.watchers.has(childPath)) {
+                                authorityStorage.destroyPath(childPath);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // NOTE: Unwatch parents, then values, as parent paths might keep alive value path watches.
+        for (let path of config.paths) {
+            if (pathsWatched) {
+                pathsWatched.paths.delete(path);
+            }
+
+            let watchers = this.watchers.get(path);
+            if (!watchers) continue;
+            watchers.watchers.delete(callback);
+            if (watchers.watchers.size === 0) {
+                this.watchers.delete(path);
+
+                let parentPath = getParentPathStr(path);
+                let parentWatchers = this.watcherParentToPath.get(parentPath);
+                if (parentWatchers) {
+                    parentWatchers.delete(path);
+                }
+
+                fullyUnwatched.paths.push(path);
+                // NOTE: If the parent is being watched, don't destroy the value.
+                //  - The fact that we only do the check here does mean that if the path is unwatched
+                //      first and then later the parent path is unwatched we will fail to properly destroy
+                //      the path. However, in practice, either both are unwatched at the same time, or more
+                //      likely, the value watch only goes away because it's made redundant by the parent watch.
+                if (!this.parentWatchers.has(parentPath)) {
+                    authorityStorage.destroyPath(path);
                 }
             }
         }

package/src/4-deploy/edgeBootstrap.ts

@@ -367,8 +367,8 @@ async function edgeNodeFunction(config: {
         let PARALLEL_FACTOR = 3;
         for (let i = 0; i < edgeNodes.length; i += PARALLEL_FACTOR) {
             let node = await new Promise<EdgeNodeConfig | undefined>(resolve => {
+                let finished = 0;
                 for (let j = 0; j < PARALLEL_FACTOR; j++) {
-                    let finished = 0;
                     ((async () => {
                         try {
                             let node = edgeNodes[i + j];

package/src/4-querysub/querysubPrediction.ts

@@ -422,11 +422,6 @@ function predictCall(config: {
     logErrors(predictPromise);
 
     let didCancel = false;
-    // ALWAYS reject the prediction eventually, in case the function runner server is down.
-    //  - ALSO, once it goes back up, the write will be too far in the future, and our lock won't be rejected.
-    //      And don't really want endTime to be infinitely in the future, as then cleanup code has a harder time
-    //      removing the lock, as then in theory it can always be rejected, no matter how long we wait.
-    setTimeout(rejectPrediction, Querysub.PREDICTION_MAX_LIFESPAN);
     function rejectPrediction() {
         if (didCancel) return;
         didCancel = true;
@@ -439,9 +434,18 @@ function predictCall(config: {
             reason: "prediction timeout rejected",
         }]);
     }
-    setTimeout(auditPrediction, Querysub.PREDICTION_MAX_LIFESPAN);
-    function auditPrediction() {
+
+    setTimeout(cleanupPrediction, Querysub.PREDICTION_MAX_LIFESPAN);
+    function cleanupPrediction() {
         if (didCancel) return;
+
+        // ALWAYS reject the prediction, in case the function runner server is down.
+        //  - ALSO, once it goes back up, the write likely will be too far in the future, so our lock won't be rejected,
+        //      will will cause the bad value to stick around.
+        //      We could fix this with an endTime infinitely in the future, but then the lock can never be GCed,
+        //      which create a memory leak.
+        rejectPrediction();
+
         if (Querysub.AUDIT_PREDICTIONS && predictions) {
             const afterTime = { time: call.runAtTime.time, version: Number.MAX_SAFE_INTEGER, creatorId: 0 };
             // Clone predictions, to strip symbols