querysub 0.128.0 → 0.129.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.128.0",
+  "version": "0.129.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/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

@@ -49,14 +49,19 @@ function getNodeIdFromPath(path: string) {
 const getEdgeNodesIndex = lazy(async (): Promise<EdgeNodesIndex> => {
     await startUpdateLoop();
     let edgeNodesIndex = await edgeNodeStorage.get("edgeNodesIndex.json");
+    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 +96,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 +112,7 @@ export async function registerEdgeNode(config: {
             });
         });
     } else {
+        let gitHash = getGitRef();
 
         let nodeId = getOwnNodeId();
         let machineId = getOwnMachineId();
@@ -180,6 +177,8 @@ const loadEntryPointsByHash = runInSerial(async function loadEntryPointsByHash(c
 
     SocketFunction.expose(EdgeNodeController);
 
+    await updateEdgeNodesFile();
+
     onEdgeNodesChanged();
 });
 
@@ -221,8 +220,12 @@ async function runEdgeNodesAliveCheck() {
 }
 async function updateEdgeNodesFile() {
     let prevEdgeNodeFile = await edgeNodeStorage.get("edgeNodesIndex.json");
+    let liveHash = await Querysub.commitSynced(() => {
+        return deploySchema()[getDomain()].deploy.live.hash;
+    });
     let prevEdgeNodeIndex: EdgeNodesIndex = {
         edgeNodes: [],
+        liveHash: "",
     };
     try {
         if (prevEdgeNodeFile) {
@@ -242,12 +245,16 @@ async function updateEdgeNodesFile() {
     }
 
     let diff = !!compareArray(edgeNodeNodeIds.sort(), prevEdgeNodeIndex.edgeNodes.map(x => x.nodeId).sort());
+    if (liveHash !== prevEdgeNodeIndex.liveHash) {
+        diff = true;
+    }
     if (!diff) return;
 
-    console.log("Detected edgeNodes changed. Updating edgeNodesIndex.json", { edgeNodeNodeIds });
+    console.log("Detected edgeNodes changed. Updating edgeNodesIndex.json", { edgeNodeNodeIds, liveHash });
 
     let newEdgeNodeIndex: EdgeNodesIndex = {
         edgeNodes: [],
+        liveHash,
     };
     for (let nodeFile of edgeNodeFiles) {
         let edgeNodeConfig = await getEdgeNodeConfig(nodeFile);
@@ -315,16 +322,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