querysub 0.53.0 → 0.55.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.53.0",
+  "version": "0.55.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -24,7 +24,7 @@
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
     "preact": "^10.11.3",
-    "socket-function": "^0.47.0",
+    "socket-function": "^0.50.0",
     "terser": "^5.31.0",
     "typesafecss": "^0.6.3",
     "yaml": "^2.5.0",

package/src/-f-node-discovery/NodeDiscovery.ts

@@ -1,7 +1,7 @@
 import { SocketFunction } from "socket-function/SocketFunction";
 import { getArchives } from "../-a-archives/archives";
 import { getDomain, isDevDebugbreak, isNoNetwork } from "../config";
-import { measureWrap } from "socket-function/src/profiling/measure";
+import { measureBlock, measureWrap } from "socket-function/src/profiling/measure";
 import { isNode, sha256Hash, throttleFunction, timeInMinute, timeInSecond } from "socket-function/src/misc";
 import { errorToUndefined, errorToUndefinedSilent, ignoreErrors, logErrors, timeoutToUndefined, timeoutToUndefinedSilent } from "../errors";
 import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
@@ -261,7 +261,7 @@ async function syncArchives() {
 }
 
 async function runHeartbeatAuditLoop() {
-    await onNodeDiscoveryReady();
+    await getAllNodeIds();
     let deadCount = new Map<string, number>();
     // 90% of the normal interval, so we don't run at the same tmie as the other audit
     await runInfinitePollCallAtStart(CHECK_INTERVAL * 0.9, async () => {
@@ -349,7 +349,7 @@ async function fastMemorySync() {
 }
 
 async function runMemoryAuditLoop() {
-    await onNodeDiscoveryReady();
+    await getAllNodeIds();
     runInfinitePoll(DISK_AUDIT_RATE, syncArchives);
     runInfinitePoll(API_AUDIT_RATE, fastMemorySync);
 }
@@ -416,18 +416,14 @@ async function runMainSyncLoops(discoveryReady: PromiseObj<void>) {
     });
 }
 
+let discoveryReady = new PromiseObj<void>();
+beforeGetNodeAllId = async () => {
+    await discoveryReady.promise;
+};
 export async function onNodeDiscoveryReady() {
-    // NOTE: This isn't really early enough, especially in the browser, because a lot of calls are created
-    //  immediately on render. But... it should be good enough for now.
-    await waitForFirstTimeSync();
-    await getAllNodeIds();
+    await beforeGetNodeAllId();
 }
-
 if (isServer()) {
-    let discoveryReady = new PromiseObj<void>();
-    beforeGetNodeAllId = async () => {
-        await discoveryReady.promise;
-    };
     setImmediate(() => {
         logErrors(runHeartbeatAuditLoop());
         logErrors(runMemoryAuditLoop());
@@ -437,28 +433,25 @@ if (isServer()) {
             discoveryReady.reject(e);
             logErrors(Promise.reject(e));
         });
-        // // Wait until we mount
-        // void SocketFunction.mountPromise.finally(async () => {
-
-        // });
     });
 } else {
-    setImmediate(() => {
-        if (isNode()) {
-            // Just get the archives, syncing again if we haven't synced in a while
-            let lastGetTime = 0;
-            beforeGetNodeAllId = async () => {
-                let lastGetThreshold = lastGetTime + CLIENTSIDE_POLL_RATE;
-                if (Date.now() > lastGetThreshold) {
-                    lastGetTime = Date.now();
-                    await syncArchives();
-                }
-            };
-        } else {
-            let discoveryReady = new PromiseObj<void>();
+
+    if (isNode()) {
+        discoveryReady.resolve();
+        // Just get the archives, syncing again if we haven't synced in a while
+        let lastGetTime = 0;
+        beforeGetNodeAllId = async () => {
+            let lastGetThreshold = lastGetTime + CLIENTSIDE_POLL_RATE;
+            if (Date.now() > lastGetThreshold) {
+                lastGetTime = Date.now();
+                await syncArchives();
+            }
+        };
+    } else {
+        setImmediate(() => {
             let browserNodeId = getBrowserUrlNode();
             let nodes = [getBrowserUrlNode()];
-            logErrors((async function checkForLocalHost() {
+            logErrors(measureWrap((async function checkForLocalHost() {
                 // If there is a server at the localhost domain, AND, it's the same as the current server...
                 //  use that domain instead. This is just an optimization, but makes a big difference
                 //  when using management tools to scan the DB (otherwise the entire DB has to go through
@@ -482,12 +475,8 @@ if (isServer()) {
 
                 allNodeIds2 = new Set(nodes);
                 discoveryReady.resolve();
-            })());
+            }))());
 
-            // Block until we finish checking for local host
-            beforeGetNodeAllId = async () => {
-                await discoveryReady.promise;
-            };
 
             // NOTE: We run into TLS issues (as in, our servers use self signed certs), if we try to talk to just
             //  any node, so... we better just talk to the edge node
@@ -495,8 +484,8 @@ if (isServer()) {
             //      certs (I think we can only wildcard a single depth anyways), and A records for the machines too...
             //      but... having all traffic route through an edge node is probably better anyways...
             nodeOverrides = nodes;
-        }
-    });
+        });
+    }
 }
 
 

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

@@ -199,9 +199,14 @@ class NodePathAuthorities {
 
     private previouslyNotAvailableNodes = new Set<string>();
 
+
+    private BOOT_TIME = Date.now();
+    private d = (type: string) => console.log(`TEST | ${type} at ${formatTime(Date.now() - this.BOOT_TIME)}`);
     @measureFnc
     private async watchAuthorityPaths() {
+        this.d("watchAuthorityPaths");
         await onNodeDiscoveryReady();
+        this.d("after onNodeDiscoveryReady");
 
         onReadReady = (nodeId, time) => {
             let obj = this.authorities.get(nodeId);
@@ -219,6 +224,7 @@ class NodePathAuthorities {
         logErrors(firstPromise.promise);
 
         const ingestNewNodeIds = (newNodeIds: string[], removedNodeIds: string[]) => {
+            this.d("ingestNewNodeIds");
             for (let nodeId of removedNodeIds) {
                 this.authorities.delete(nodeId);
             }
@@ -308,6 +314,8 @@ class NodePathAuthorities {
         watchDeltaNodeIds(obj => ingestNewNodeIds(obj.newNodeIds, obj.removedNodeIds));
         await firstPromise.promise;
 
+        this.d("after firstPromise");
+
         let recoveryIndex = 0;
         runInfinitePoll(INITIAL_RECOVERY_POLL_INTERVAL, async () => {
             // Wait longer the more times we loop. This allows us to reconnect quickly on startup

package/src/4-querysub/Querysub.ts

@@ -39,7 +39,7 @@ import { minify_sync } from "terser";
 import { isClient } from "../config2";
 import { remoteWatcher } from "../1-path-client/RemoteWatcher";
 import { waitForFirstTimeSync } from "socket-function/time/trueTimeShim";
-import { measureFnc } from "socket-function/src/profiling/measure";
+import { measureBlock, measureFnc } from "socket-function/src/profiling/measure";
 import { delay } from "socket-function/src/batching";
 import { MaybePromise } from "socket-function/src/types";
 import { devDebugbreak, getDomain, isDevDebugbreak, isNoNetwork, isPublic } from "../config";
@@ -200,7 +200,9 @@ export class Querysub {
      */
     @measureFnc
     public static async optionalStartupWait() {
-        await waitForFirstTimeSync();
+        await measureBlock(async () => {
+            await waitForFirstTimeSync();
+        }, "waitForFirstTimeSync");
         await nodePathAuthority.waitUntilRoutingIsReady();
     }