querysub 0.128.0 → 0.130.0

package/package.json

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

package/src/4-deploy/deployMain.ts

@@ -144,7 +144,7 @@ export async function deployMain() {
         },
     });
 
-    console.log(magenta(`FINISHED DEPLOY`));
+    console.log(magenta(`FINISHED DEPLOY (${gitRef})`));
 }
 
 

package/src/4-deploy/edgeBootstrap.ts

@@ -303,6 +303,17 @@ async function edgeNodeFunction(config: {
 
         // I guess... only allow private nodes, if they specify the exact host (which would match above).
         edgeNodes = edgeNodes.filter(x => x.public);
+        if (edgeNodes.length === 0) {
+            throw new Error(`No public nodes found`);
+        }
+
+        let liveNodes = edgeNodes.filter(x => x.gitHash === edgeIndex.liveHash);
+        if (liveNodes.length === 0) {
+            let latestHash = edgeNodes[0].gitHash;
+            console.warn(`Could not find any live nodes (${edgeIndex.liveHash}), falling back to latest hash: ${latestHash}`);
+            liveNodes = edgeNodes.filter(x => x.gitHash === latestHash);
+        }
+        edgeNodes = liveNodes;
 
         // TODO: Instead of randomly shuffling, use the node's current load when picking a node.
         //  All our future traffic (such as syncing) goes through the edge node we use, so it preferrable

package/src/4-deploy/edgeNodes.ts

@@ -18,7 +18,7 @@ import path from "path";
 import debugbreak from "debugbreak";
 import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
 import { getControllerNodeIdList } from "../-g-core-values/NodeCapabilities";
-import { blue } from "socket-function/src/formatting/logColors";
+import { blue, magenta } from "socket-function/src/formatting/logColors";
 import { errorToUndefined } from "../errors";
 import { deploySchema } from "./deploySchema";
 import { proxyWatcher } from "../2-proxy/PathValueProxyWatcher";
@@ -29,6 +29,7 @@ const UPDATE_POLL_INTERVAL = timeInMinute;
 const DEAD_NODE_COUNT_THRESHOLD = 15;
 
 const edgeNodeStorage = nestArchives("edgenodes/", getArchivesBackblazePublic(getDomain()));
+const edgeNodeIndexFile = "edge-nodes-index.json";
 
 const getEdgeNodeConfig = cacheLimited(10000, async (fileName: string): Promise<EdgeNodeConfig | undefined> => {
     let edgeNodeConfig = await edgeNodeStorage.get(fileName);
@@ -48,15 +49,20 @@ function getNodeIdFromPath(path: string) {
 // NOTE: We update this in the update loop
 const getEdgeNodesIndex = lazy(async (): Promise<EdgeNodesIndex> => {
     await startUpdateLoop();
-    let edgeNodesIndex = await edgeNodeStorage.get("edgeNodesIndex.json");
+    let edgeNodesIndex = await edgeNodeStorage.get(edgeNodeIndexFile);
+    let liveHash = await Querysub.commitSynced(() => {
+        return deploySchema()[getDomain()].deploy.live.hash;
+    });
     if (!edgeNodesIndex) return {
         edgeNodes: [],
+        liveHash,
     };
     return JSON.parse(edgeNodesIndex.toString());
 });
 
 export type EdgeNodesIndex = {
     edgeNodes: EdgeNodeConfig[];
+    liveHash: string;
 };
 
 
@@ -91,21 +97,12 @@ export async function registerEdgeNode(config: {
 
     await waitForFirstTimeSync();
 
-    let gitHash = getGitRef();
-
     if (!isLocal()) {
-        gitHash = await Querysub.commitSynced(() => {
-            return deploySchema()[getDomain()].deploy.live.hash;
-        });
         let loadedHash = "";
         Querysub.createWatcher(() => {
             let hash = deploySchema()[getDomain()].deploy.live.hash;
             if (hash === loadedHash || !Querysub.isAllSynced()) return;
 
-            // todonext
-            // Remove this line, it is just to verify our preloading works
-            if (loadedHash) return;
-
             loadedHash = hash;
             void Promise.resolve().then(async () => {
                 await loadEntryPointsByHash({
@@ -116,6 +113,7 @@ export async function registerEdgeNode(config: {
             });
         });
     } else {
+        let gitHash = getGitRef();
 
         let nodeId = getOwnNodeId();
         let machineId = getOwnMachineId();
@@ -177,9 +175,12 @@ const loadEntryPointsByHash = runInSerial(async function loadEntryPointsByHash(c
     };
 
     await edgeNodeStorage.set(getNextNodePath(), Buffer.from(JSON.stringify(edgeNodeConfig)));
+    console.log(magenta(`Deployed edge node`), edgeNodeConfig);
 
     SocketFunction.expose(EdgeNodeController);
 
+    await updateEdgeNodesFile();
+
     onEdgeNodesChanged();
 });
 
@@ -189,7 +190,7 @@ export const getEdgeNodeConfigURL = lazy(async () => {
         subdomain: `edge`,
         domain: getDomain(),
     });
-    return await getURL("edge-nodes-index.json");
+    return await getURL(edgeNodeIndexFile);
 });
 
 const startUpdateLoop = lazy(async () => {
@@ -220,34 +221,43 @@ async function runEdgeNodesAliveCheck() {
     }
 }
 async function updateEdgeNodesFile() {
-    let prevEdgeNodeFile = await edgeNodeStorage.get("edgeNodesIndex.json");
+    let prevEdgeNodeFile = await edgeNodeStorage.get(edgeNodeIndexFile);
     let prevEdgeNodeIndex: EdgeNodesIndex = {
         edgeNodes: [],
+        liveHash: "",
     };
     try {
         if (prevEdgeNodeFile) {
             prevEdgeNodeIndex = JSON.parse(prevEdgeNodeFile.toString());
         }
     } catch (e) {
-        console.error("Failed to parse edgeNodesIndex.json", { error: e, prevEdgeNodeFile });
+        console.error(`Failed to parse ${edgeNodeIndexFile}`, { error: e, prevEdgeNodeFile });
     }
+
     getEdgeNodesIndex.set(Promise.resolve(prevEdgeNodeIndex));
 
     let edgeNodeFiles = await edgeNodeStorage.find("node", { type: "files" });
     let edgeNodeNodeIds = edgeNodeFiles.map(getNodeIdFromPath);
 
-    if (!edgeNodeNodeIds.includes(getOwnNodeId())) {
-        console.log(`Our node was removed as a edgeNode. This is a fatal error. Terminating now.`);
-        await shutdown();
-    }
+    let liveHash = await Querysub.commitSynced(() => {
+        return deploySchema()[getDomain()].deploy.live.hash;
+    });
 
     let diff = !!compareArray(edgeNodeNodeIds.sort(), prevEdgeNodeIndex.edgeNodes.map(x => x.nodeId).sort());
+    if (diff) {
+        console.log(`Detected edgeNodes changed. Updating ${edgeNodeIndexFile}`, { edgeNodeNodeIds, liveHash });
+    }
+    if (liveHash !== prevEdgeNodeIndex.liveHash) {
+        diff = true;
+        console.log(`Detected live hash changed. Updating ${edgeNodeIndexFile}`, { liveHash, prevHash: prevEdgeNodeIndex.liveHash });
+    }
     if (!diff) return;
 
-    console.log("Detected edgeNodes changed. Updating edgeNodesIndex.json", { edgeNodeNodeIds });
+
 
     let newEdgeNodeIndex: EdgeNodesIndex = {
         edgeNodes: [],
+        liveHash,
     };
     for (let nodeFile of edgeNodeFiles) {
         let edgeNodeConfig = await getEdgeNodeConfig(nodeFile);
@@ -255,7 +265,7 @@ async function updateEdgeNodesFile() {
         newEdgeNodeIndex.edgeNodes.push(edgeNodeConfig);
     }
 
-    await edgeNodeStorage.set("edge-nodes-index.json", Buffer.from(JSON.stringify(newEdgeNodeIndex)));
+    await edgeNodeStorage.set(edgeNodeIndexFile, Buffer.from(JSON.stringify(newEdgeNodeIndex)));
 }
 
 export async function preloadUI(hash: string) {
@@ -315,16 +325,6 @@ const EdgeNodeController = SocketFunction.register(
 //      - I think it isn't? But maybe we just need to do-update again
 
 
-//  3) Dynamically watch the live hash, and load new hashes (deploying their services)
-//  - PUSH and making sure we serve the old UI (when not running --local)
-//  - Turning off the preloading in deploy, and ensuring it updates
-//  - ALSO, when the live hash changes, invalidate getCachedConfig?
-
-
-//  5) Write the live hash to the index, and have the client prefer this hash
-//      - And if it can't be found, fallback to the the hash with the highest bootTime
-//          (picking from that pool, not just that single node)
-
 //  7) Client live hash watch code + notify + refresh + flag to ignore the baked in live hash + edge node
 //  - Test by pushing, deploying, and then we should immediately see a notify to refresh