querysub 0.311.0 → 0.312.0

package/package.json

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

package/src/-c-identity/IdentityController.ts

@@ -16,6 +16,7 @@ import { timeoutToError } from "../errors";
 import { delay } from "socket-function/src/batching";
 import { formatTime } from "socket-function/src/formatting/format";
 import { waitForFirstTimeSync } from "socket-function/time/trueTimeShim";
+import { red } from "socket-function/src/formatting/logColors";
 
 let callerInfo = new Map<CallerContext, {
     reconnectNodeId: string | undefined;
@@ -200,5 +201,10 @@ SocketFunction.addGlobalClientHook(async function identityHook(context) {
     if (isClientNodeId(context.call.nodeId)) {
         return;
     }
+    let time = Date.now();
     await changeIdentityOnce(context.connectionId);
+    let duration = Date.now() - time;
+    if (duration > 200) {
+        console.log(red(`IdentityHook took ${formatTime(duration)} for ${context.connectionId.nodeId} ${context.call.classGuid}.${context.call.functionName}`));
+    }
 });

package/src/-d-trust/NetworkTrust2.ts

@@ -51,7 +51,7 @@ export const assertIsNetworkTrusted = requiresNetworkTrustHook;
 let lastArchivesTrusted: string[] | undefined;
 let trustedCache = new Set<string>();
 let untrustedCache = new Map<string, number>();
-export const isTrusted = runInSerial(async function isTrusted(machineId: string) {
+export const isTrusted = measureWrap(async function isTrusted(machineId: string) {
     // See the comment in requiresNetworkTrustHook for why clients have to trust all callers.
     if (isClient()) return true;
 
@@ -68,11 +68,26 @@ export const isTrusted = runInSerial(async function isTrusted(machineId: string)
         return false;
     }
 
-    // Find is faster than get, and usually we don't need the full certificate
-    let trustedMachineIds = await archives().find("");
-    lastArchivesTrusted = trustedMachineIds.slice();
+    return await isTrustedBase(machineId);
+});
+let trustedCachePopulated = false;
+const isTrustedBase = runInSerial(measureWrap(async function isTrustedBase(machineId: string) {
+    if (!trustedCachePopulated) {
+        trustedCachePopulated = true;
+        let trustedMachineIds = await archives().find("");
+        lastArchivesTrusted = trustedMachineIds.slice();
+        for (let trustedMachineId of trustedMachineIds) {
+            trustedCache.add(trustedMachineId);
+        }
+    } else {
+        // Checking a single entry is a lot faster (as find is slow)
+        let trusted = await archives().get(machineId);
+        if (trusted) {
+            trustedCache.add(machineId);
+        }
+    }
     // Always trust ourself
-    trustedMachineIds.push(getOwnMachineId());
+    trustedCache.add(getOwnMachineId());
     // IF developing, trust localhost. This allows us to develop without port forwards,
     //  on our services, which INCREASES security, and prevents dev machines from being
     //  connected to by attackers (as dev machines might reveal unfinished content, or even
@@ -80,13 +95,7 @@ export const isTrusted = runInSerial(async function isTrusted(machineId: string)
     //  - Don't trust this on public, as in theory an attacker MIGHT be able to connect
     //      from localhost (but not have disk read/write access)? Maybe...
     if (!isPublic()) {
-        trustedMachineIds.push("127-0-0-1." + getDomain());
-    }
-
-    // NOTE: This should be safe from collisions with existing files, because... while there might be a metadata
-    //  file which exists, it will never also be a valid hash/public key, which machineId will always be.
-    for (let trustedMachineId of trustedMachineIds) {
-        trustedCache.add(trustedMachineId);
+        trustedCache.add("127-0-0-1." + getDomain());
     }
 
     if (!trustedCache.has(machineId)) {
@@ -95,7 +104,7 @@ export const isTrusted = runInSerial(async function isTrusted(machineId: string)
     } else {
         return true;
     }
-});
+}));
 
 export async function isNodeTrusted(nodeId: string) {
     let domainName = getNodeIdDomainMaybeUndefined(nodeId);

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

@@ -44,6 +44,8 @@ let DISK_AUDIT_RATE = timeInMinute * 15;
 //  probably is less than that). Which is around 2.5 cents on digital ocean IF we go over
 //  our 1TB/month allowance.
 let API_AUDIT_RATE = timeInSecond * 30;
+// BUT, for now, poll less often... because I think it is lagging our 2 core potato digital ocean server.
+API_AUDIT_RATE = timeInMinute * 5;
 let API_AUDIT_COUNT = 12;
 
 
@@ -353,7 +355,7 @@ async function runHeartbeatAuditLoop() {
         if (removedNodeIds.length > 0) {
             console.log(blue(`Removed ${removedNodeIds.length}/${nodeIds.length} nodes from node list`), { removedNodeIds });
             await syncArchives();
-            await tellEveryoneNodesChanges();
+            await tellEveryoneNodesChanges(`removedNodeIds ${removedNodeIds.join("|")}`);
         }
     });
 }
@@ -517,7 +519,7 @@ if (isServer()) {
 
 export async function forceRemoveNode(nodeId: string) {
     await archives().del(nodeId);
-    void tellEveryoneNodesChanges();
+    void tellEveryoneNodesChanges(`forceRemoveNode ${nodeId}`);
 }
 
 
@@ -528,13 +530,14 @@ export async function nodeDiscoveryShutdown() {
     if (isServer()) {
         await archives().del(getOwnNodeId());
     }
-    void tellEveryoneNodesChanges();
+    void tellEveryoneNodesChanges("nodeDiscoveryShutdown");
 }
-const tellEveryoneNodesChanges = throttleFunction(1000, function tellEveryoneNodesChanges() {
+const tellEveryoneNodesChanges = throttleFunction(1000, function tellEveryoneNodesChanges(reason: string) {
     if (isClient()) return;
+    console.log(red(`Telling everyone nodes changed`));
     for (let nodeId of allNodeIds2) {
         if (isOwnNodeId(nodeId)) continue;
-        ignoreErrors(NodeDiscoveryController.nodes[nodeId].resyncNodes());
+        ignoreErrors(NodeDiscoveryController.nodes[nodeId].resyncNodes(reason));
     }
 });
 
@@ -544,7 +547,9 @@ class NodeDiscoveryControllerBase {
         console.log(magenta(`Received addNode`), { nodeId });
         addNodeId(nodeId);
     }
-    public async resyncNodes() {
+    public async resyncNodes(reason: string) {
+        let caller = SocketFunction.getCaller();
+        console.log(magenta(`Received resyncNodes from ${caller.nodeId}, reason = ${reason}`));
         await syncArchives();
     }
     public async getAllNodesHash(): Promise<string> {