querysub 0.280.0 → 0.282.0

package/package.json

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

package/src/-a-archives/archivesBackBlaze.ts

@@ -403,8 +403,8 @@ export class ArchivesBackblaze {
         }
 
         let desiredCorsRules = this.config.public ? [{
-            corsRuleName: "onlyCurrentOrigin",
-            allowedOrigins: ["*"],
+            corsRuleName: "allowAll",
+            allowedOrigins: ["https"],
             allowedOperations: ["b2_download_file_by_id", "b2_download_file_by_name"],
             allowedHeaders: ["range"],
             exposeHeaders: ["x-bz-content-sha1"],

package/src/-e-certs/EdgeCertController.ts

@@ -21,7 +21,7 @@ import { addRecord, deleteRecord, getRecords, hasDNSWritePermissions, setRecord
 import { SocketServerConfig } from "socket-function/src/webSocketServer";
 import debugbreak from "debugbreak";
 import { delay, runInfinitePoll, runInfinitePollCallAtStart } from "socket-function/src/batching";
-import { getDomain, isNoNetwork, isPublic } from "../config";
+import { getDomain, isBootstrapOnly, isNoNetwork, isPublic } from "../config";
 import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
 import { getExternalIP, testTCPIsListening } from "../misc/networking";
 import { magenta, yellow } from "socket-function/src/formatting/logColors";
@@ -250,7 +250,7 @@ async function getHTTPSKeyCertInner(callerIP: string) {
     //  with our A record public while we create our cert.
     runEdgeDomainAliveLoop();
     const edgeDomain = getDomain();
-    if (callerIP) {
+    if (callerIP && !isBootstrapOnly()) {
         try {
             let promises: Promise<void>[] = [];
             let existingIPs = await getRecords("A", edgeDomain);

package/src/4-deploy/edgeClientWatcher.tsx

@@ -29,6 +29,18 @@ export function startEdgeNotifier() {
         }
         void notifyClients(liveHash, refreshThresholdTime);
     });
+    (async () => {
+        await delay(1);
+        let { watchOnRollingUpdate } = await import("../deployManager/machineController");
+        watchOnRollingUpdate({
+            callback: (time) => {
+                let duration = Date.now() - time;
+                // Refresh 10% earlier, as we don't want clients to refresh RIGHT when the server shutsdown...
+                time = Date.now() + duration * 0.9;
+                void notifyClients(lastHashServer, time);
+            }
+        });
+    })();
 }
 
 let watchingClientNodes = new Set<string>();

package/src/4-querysub/Querysub.ts

@@ -773,7 +773,7 @@ export class Querysub {
             }
         }
 
-        await SocketFunction.mount({
+        let mountedNodeId = await SocketFunction.mount({
             public: isPublic(),
             port: config.port,
             autoForwardPort: true,
@@ -785,42 +785,15 @@ export class Querysub {
             },
             allowHostnames,
         });
+        let port = getNodeIdLocation(mountedNodeId)?.port;
 
         let { ip, ipDomain } = await publishMachineARecords();
 
         if (!isBootstrapOnly()) {
             await registerEdgeNode({
-                host: ipDomain + ":" + config.port,
+                host: ipDomain + ":" + port,
                 entryPaths,
             });
-        } else {
-            // bootstraponly mode. Setup cloudflare proxy. If they are developing (localhost), we can't proxy, so don't (but still setup domain). Using the cloudflare proxy should prevent the site from entirely breaking if the bootstrapper goes down.
-            let ip = await getHostedIP();
-            let existingRecords = await getRecords("A", getDomain());
-            if (ip !== "127.0.0.1") {
-                let validRecords: string[] = [];
-                // Ignore ourself, we want OTHER records.
-                existingRecords = existingRecords.filter(x => x !== ip);
-                await Promise.all(existingRecords.map(async (record) => {
-                    let isListening = await timeoutToUndefined(timeInSecond * 10, testTCPIsListening(record, 443));
-                    if (isListening) {
-                        validRecords.push(record);
-                    }
-                }));
-                // It's hard to manage multiple bootstrappers, so... just don't.
-                if (validRecords.length > 0) {
-                    console.error(`Found existing bootstrapper at ${JSON.stringify(validRecords)}, so why are we even running? Terminating shortly`);
-                    // Give logs time to write
-                    await shutdown();
-                }
-                await setRecord("A", getDomain(), ip, "proxied");
-            } else {
-                if (existingRecords.length === 0) {
-                    await setRecord("A", ip, getDomain());
-                } else {
-                    console.log(`Not clobbering existing A record for ${getDomain()} of ${JSON.stringify(existingRecords)}`);
-                }
-            }
         }
     }
     private static async addSourceMapCheck(config: {
@@ -1319,4 +1292,5 @@ import { blue } from "socket-function/src/formatting/logColors";
 import { MachineController } from "../deployManager/machineController";
 import { getRecords, setRecord } from "../-b-authorities/dnsAuthority";
 import { testTCPIsListening } from "socket-function/src/networking";
+import { getNodeId, getNodeIdLocation } from "socket-function/src/nodeCache";
 

package/src/deployManager/machineController.ts

@@ -12,6 +12,7 @@ import { getGitURLLive, setGitRef } from "../4-deploy/git";
 import os from "os";
 import { runPromise } from "../functional/runCommand";
 import { getSyncedController } from "../library-components/SyncedController";
+import { logErrors } from "../errors";
 
 const POLL_INTERVAL = timeInMinute * 15;
 
@@ -35,16 +36,35 @@ export function onServiceConfigChange(callback: () => Promise<void>): () => void
         serviceConfigChangeWatchers.delete(callback);
     };
 }
+
+
+let rollingUpdateWatchers = new Set<(time: number) => void>();
+export function watchOnRollingUpdate(config: {
+    callback: (time: number) => void;
+}) {
+    rollingUpdateWatchers.add(config.callback);
+}
 class OnServiceChangeBase {
     public async onServiceConfigChange() {
         await triggerServiceConfigChangeCallbacks();
     }
+
+    public async onRollingUpdate(time: number) {
+        for (let callback of rollingUpdateWatchers) {
+            try {
+                callback(time);
+            } catch (e) {
+                logErrors(e);
+            }
+        }
+    }
 }
 export const OnServiceChange = SocketFunction.register(
     "on-service-change-aa6b4aaa-c325-4112-b2a8-f81c180016a0",
     () => new OnServiceChangeBase(),
     () => ({
         onServiceConfigChange: {},
+        onRollingUpdate: {},
     }),
     () => ({
         hooks: [requiresNetworkTrustHook],
@@ -52,6 +72,8 @@ export const OnServiceChange = SocketFunction.register(
 );
 
 
+
+
 class MachineControllerBase {
     // NOTE: We don't need to worry about escaping commands here. YES, the user CAN inject code into the key. But this system is literally for running arbitrary commands, so they could just write a serviceConfig and run anything they want, on all the machines...
     public async streamScreenOutput(config: {

package/src/deployManager/spec.txt

@@ -1,3 +1,9 @@
+OH! the bootstrap root index file has CORS issues
+    - We didn't notice this before because the cached value always worked?
+
+The actual http registration isn't working? And our edgeNode file is so messy it's hard to see if it's there or not... ugh...
+
+
 8) Use a special service for the HTTP bootstrapper, and then have 2 others that are on other ports
     --bootstraponly is added, and should work?
 
@@ -17,8 +23,9 @@
         - Tracked per serviceId
         - Update the rolling time, so if we remove the rolling window we kill the old service immediately
     - Notify when servers are outdated
-        - In HTTP server, notify users, in the same way we notify for hash updates, that they will need to switch servers
+        - After min(5 minute, 10% of rolling window size)
         - Use the node registration to know the nodeId to talk to, and allow servers to register to get told when they are outdated (and how long before they are shutdown).
+        - In HTTP server, notify users, in the same way we notify for hash updates, that they will need to switch servers
         - Verify this update works with a relatively low rolling update window, ensuring it force refreshes before the server actually restarts.
 
 10) Add RAM total, ram % used, cpu count, CPU %, disk size, disk % used to machine info