querysub 0.313.0 → 0.314.0

package/package.json

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

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

@@ -28,6 +28,7 @@ import { magenta, yellow } from "socket-function/src/formatting/logColors";
 import { timeInMinute, timeInSecond } from "socket-function/src/misc";
 import { nodeDiscoveryShutdown } from "../-f-node-discovery/NodeDiscovery";
 import { shutdown } from "../diagnostics/periodic";
+import { formatDateTime } from "socket-function/src/formatting/format";
 
 let publicPort = -1;
 
@@ -65,6 +66,8 @@ export async function getSNICerts(config: {
         },
     };
 
+    await publishEdgeDomain();
+
     return certs;
 }
 
@@ -93,7 +96,7 @@ const certUpdateLoop = lazy(() => {
     logErrors((async () => {
         let firstLoop = true;
         while (true) {
-            let curCert = await getCertFromRemote();
+            let curCert = await getHTTPSKeyCert(getDomain());
             if (!curCert) {
                 throw new Error(`Internal error, certUpdateLoop called before lastPromise was set`);
             }
@@ -102,14 +105,9 @@ const certUpdateLoop = lazy(() => {
             let expirationTime = +new Date(certObj.validity.notAfter);
             let createTime = +new Date(certObj.validity.notBefore);
 
-            // If 75% of the lifetime has passed, renew the cert
+            // If 75% of the lifetime has passed, getHTTPSKeyCert should have updated it, so wait until that, then get the new cert, and update our watchers (which should be the servers).
             let renewDate = createTime + (expirationTime - createTime) * 0.75;
             let timeToExpire = renewDate - Date.now();
-            if (timeToExpire < 0) {
-                console.log(`HTTPS certificate is looking too old. Renewing from remote.`);
-                getCertFromRemote = createGetCertFromRemote();
-                continue;
-            }
 
             if (!firstLoop) {
                 for (let callback of callbacks) {
@@ -118,43 +116,19 @@ const certUpdateLoop = lazy(() => {
             }
             firstLoop = false;
 
+            if (timeToExpire < 0) {
+                console.warn(`getHTTPSKeyCert gave as an almost expired. It is not supposed to do this. It should have updated it by now... Expires on ${formatDateTime(expirationTime)}`);
+                timeToExpire = timeInMinute * 15;
+            }
             // Max timeout a signed integer, but lower is fine too
-            timeToExpire = Math.min(timeToExpire, 2 ** 30);
-            console.log(`Certicates up to date, renewing on ${new Date(Date.now() + timeToExpire)}`);
+            timeToExpire = Math.min(Math.floor(timeToExpire), 2 ** 30);
             await delay(timeToExpire);
-            console.log(`Woke up to renew`);
+            console.log(`Woke up to propagate new certs`);
         }
     })());
 });
 
-function createGetCertFromRemote() {
-    return lazy(async () => {
-        return backoffRetryLoop(async () => {
-            // Skip the remote call if we have DNS write permissions, to
-            //  make bootstrapping easier.
-            if (await hasDNSWritePermissions()) {
-                let ip = SocketFunction.mountedIP;
-                if (ip === "0.0.0.0") {
-                    ip = await getExternalIP();
-                }
-                return await getHTTPSKeyCertInner(ip);
-            }
-
-            let edgeNodeId = await getControllerNodeId(EdgeCertController);
-            if (!edgeNodeId) {
-                throw new Error("No EdgeCertController found");
-            }
-            return await EdgeCertController.nodes[edgeNodeId].getHTTPSKeyCert();
-        });
-    });
-}
-let getCertFromRemote = createGetCertFromRemote();
 
-// NOTE: Only works if the machine is already listening. Needed for some special websocket
-//  stuff related to debugging.
-export function debugGetRawEdgeCert() {
-    return getCertFromRemote();
-}
 
 let callbacks: ((newCertPair: { cert: string; key: string }) => void)[] = [];
 async function EdgeCertController_watchHTTPSKeyCert(
@@ -163,7 +137,7 @@ async function EdgeCertController_watchHTTPSKeyCert(
     certUpdateLoop();
 
     callbacks.push(callback);
-    let certPair = await getCertFromRemote();
+    let certPair = await getHTTPSKeyCert(getDomain());
     callback(certPair);
 }
 
@@ -228,24 +202,11 @@ async function checkEdgeDomainsAlive() {
     }
 }
 
-async function getHTTPSKeyCertInner(callerIP: string) {
-    let cert = await getBaseCert();
-    // If the cert is 50% expired generate a new one
-    let certObj = parseCert(cert.cert);
-
-    // Get expiration date
-    let expirationTime = +new Date(certObj.validity.notAfter);
-    let createTime = +new Date(certObj.validity.notBefore);
-
-    // If 50% of the lifetime has passed, renew the cert
-    let renewDate = createTime + (expirationTime - createTime) * 0.5;
-    if (renewDate < Date.now()) {
-        console.log(`HTTPS certificate is looking too old, forcefully renewing`);
-        getHTTPSKeyCert.clear(getDomain());
-        getBaseCert = createGetBaseCert();
-        cert = await getBaseCert();
+async function publishEdgeDomain() {
+    let callerIP = SocketFunction.mountedIP;
+    if (callerIP === "0.0.0.0") {
+        callerIP = await getExternalIP();
     }
-
     // IMPORTANT! We have to set our A record AFTER we create our cert, otherwise we might wait a while
     //  with our A record public while we create our cert.
     runEdgeDomainAliveLoop();
@@ -296,27 +257,5 @@ async function getHTTPSKeyCertInner(callerIP: string) {
             console.error(`Error updating DNS records, continuing without updating them`, e);
         }
     }
-
-    return cert;
 }
 
-class EdgeCertControllerBase {
-    public async getHTTPSKeyCert() {
-        // Ensure the a record is subscribed
-        const caller = SocketFunction.getCaller();
-        let callerIP = getNodeIdIP(caller.nodeId);
-        return await getHTTPSKeyCertInner(callerIP);
-    }
-}
-
-
-const EdgeCertController = SocketFunction.register(
-    "EdgeCertController-694c925b-fb10-4656-aed0-b53a48ded548",
-    new EdgeCertControllerBase(),
-    () => ({
-        getHTTPSKeyCert: {},
-    }),
-    () => ({
-        hooks: [requiresNetworkTrustHook],
-    })
-);

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

@@ -40,6 +40,12 @@ export const getHTTPSKeyCert = cache(async (domain: string): Promise<{ key: stri
             console.log(magenta(`Renewing domain ${domain} (renew target is ${formatDateTime(renewDate)}).`));
             keyCert = undefined;
         }
+        let timeUntilRenew = renewDate - Date.now();
+        setTimeout(() => {
+            console.log(magenta(`Clearing getHTTPSKeyCert to try to renew ${domain} (renew target is ${formatDateTime(renewDate)}).`));
+            getHTTPSKeyCert.clear(domain);
+            void getHTTPSKeyCert(domain);
+        }, Math.min(Math.floor(timeUntilRenew * 1.1), 2 ** 30));
     } else {
         console.log(magenta(`No cert found for domain ${domain}, generating shortly.`));
     }

package/src/deployManager/components/ServiceDetailPage.tsx

@@ -338,7 +338,7 @@ export class ServiceDetailPage extends qreact.Component {
 
                                 <ATag values={[
                                     managementPageURL.getOverride("LogViewer2"),
-                                    filterParam.getOverride(`__nodeId = ${machineId}`),
+                                    filterParam.getOverride(`__machineId = ${machineId}`),
                                 ]}>
                                     Machine Logs
                                 </ATag>

package/src/deployManager/setupMachineMain.ts

@@ -171,7 +171,9 @@ async function main() {
     // Get RAM amount to calculate appropriate swap size
     const memInfo = await runPromise(`ssh ${sshRemote} "free -m | grep Mem"`);
     const ramMB = parseInt(memInfo.split(/\s+/)[1]);
-    if (swapTotal > 0) {
+    if (Number.isNaN(swapTotal) || Number.isNaN(ramMB)) {
+        console.error(`Error getting swap or memory info, swapInfo: ${swapInfo}, memInfo: ${memInfo}`);
+    } else if (swapTotal > 0) {
         console.log(`✅ Swap already configured: ${swapTotal}MB SWAP vs ${ramMB}MB REAL MEMORY`);
     } else {
         // Calculate swap size based on RAM:
@@ -213,6 +215,11 @@ async function main() {
 
     console.log("Setting up machine:", sshRemote);
 
+    // 0. Update apt
+    console.log("Updating apt...");
+    await runPromise(`ssh ${sshRemote} "sudo apt update"`);
+    console.log("✅ Apt updated");
+
     // 1. Copy backblaze file to remote server (~/backblaze.json)
     console.log("Copying backblaze credentials...");
     if (fs.existsSync(backblazePath)) {

package/src/diagnostics/NodeViewer.tsx

@@ -23,7 +23,6 @@ import { ValueAuditController } from "../../src/5-diagnostics/memoryValueAudit";
 import { getExternalIP } from "../../src/misc/networking";
 import dns from "dns";
 import { getNodeIdDomain, getNodeIdIP } from "socket-function/src/nodeCache";
-import { debugGetRawEdgeCert } from "../../src/-e-certs/EdgeCertController";
 import ws from "ws";
 import https from "https";
 import debugbreak from "debugbreak";
@@ -38,6 +37,7 @@ import { ATag } from "../library-components/ATag";
 import { getSyncedController } from "../library-components/SyncedController";
 import child_process from "child_process";
 import { filterParam } from "./logs/FastArchiveViewer";
+import { getHTTPSKeyCert } from "../-e-certs/certAuthority";
 
 
 type NodeData = {
@@ -431,7 +431,7 @@ class NodeViewerControllerBase {
         });
 
         let baseNodeIP = getNodeIdIP(nodeId);
-        let cert = await debugGetRawEdgeCert();
+        let cert = await getHTTPSKeyCert(getDomain());
 
         const child = child_process.spawn("node", [
             "-e",

package/src/diagnostics/logs/FastArchiveAppendable.ts

@@ -110,6 +110,14 @@ export function getFileTimeStamp(path: string): number {
     return new Date(dateStr).getTime();
 }
 
+
+// NOTE: Global, to prevent hot reloading, or redundant FastArchiveAppendable, from breaking things.
+const appendableSerialLock = (globalThis as any).appendableSerialLock ?? runInSerial(async (fnc: () => Promise<void>) => {
+    await fnc();
+});
+(globalThis as any).appendableSerialLock = appendableSerialLock;
+
+
 export class FastArchiveAppendable<Datum> {
     private lastSizeWarningTime = 0;
 
@@ -181,14 +189,10 @@ export class FastArchiveAppendable<Datum> {
         }
     }
 
-    private serialLock = runInSerial(async (fnc: () => Promise<void>) => {
-        await fnc();
-    });
-
     // NOTE: This is disk writing, which should be fast, but if it's slow we might be able to remove the measureWrap (as technically spending 50% of our time writing to the disk is fine, and won't lag anything).
     @measureFnc
     public async flushNow(now = Date.now()) {
-        await this.serialLock(async () => {
+        await appendableSerialLock(async () => {
             // 2025-09-06T07
             let hourFile = new Date(now).toISOString().slice(0, 13) + ".log";
             let localCacheFolder = this.getLocalPathRoot() + getOwnThreadId() + "/";
@@ -259,13 +263,15 @@ export class FastArchiveAppendable<Datum> {
 
     public static getBackblazePath(config: { fileName: string; threadId: string }): string {
         // 2025-09-06T07
-        let [year, month, day, hour] = config.fileName.split(/[-T:]/);
+        let mainName = config.fileName.replace(/\.log$/, "");
+        let [year, month, day, hour] = mainName.split(/[-T:]/);
         return `${year}/${month}/${day}/${hour}/${config.threadId}.log`;
     }
 
     public async moveLogsToBackblaze() {
-        await this.serialLock(async () => {
+        await appendableSerialLock(async () => {
             let rootCacheFolder = this.getLocalPathRoot();
+            console.log(magenta(`Moving old logs to Backblaze from ${rootCacheFolder}`));
 
             let archives = this.getArchives();
             async function moveLogsForFolder(threadId: string) {
@@ -274,22 +280,25 @@ export class FastArchiveAppendable<Datum> {
                 let files = await fs.promises.readdir(threadDir);
                 for (let file of files) {
                     if (file === "heartbeat") continue;
-                    // 2025-09-06T07
                     let fullPath = threadDir + file;
-
-                    // We could use modified time here? Although, this is nice if we move files around, and then manually have them moved, although even then... this could cause problem be tripping while we are copying the file, so... maybe this is just wrong?
-                    let timeStamp = getFileTimeStamp(fullPath);
-                    if (timeStamp > Date.now() - UPLOAD_THRESHOLD) continue;
-
-
-                    // NOTE: Because we use the same target path, if multiple services do this at the same time it's fine. Not great, but... fine.
-                    let backblazePath = FastArchiveAppendable.getBackblazePath({ fileName: file, threadId });
-                    console.log(magenta(`Moving ${fullPath} to Backblaze as ${backblazePath}`));
-                    let data = await measureBlock(async () => fs.promises.readFile(fullPath), "FastArchiveAppendable|readBeforeUploading");
-                    let compressed = await measureBlock(async () => Zip.gzip(data), "FastArchiveAppendable|compress");
-                    console.log(`Uploading ${formatNumber(data.length)}B (compressed to ${formatNumber(compressed.length)}B) logs to ${backblazePath} from ${fullPath}`);
-                    await archives.set(backblazePath, compressed);
-                    await fs.promises.unlink(fullPath);
+                    try {
+                        // We could use modified time here? Although, this is nice if we move files around, and then manually have them moved, although even then... this could cause problem be tripping while we are copying the file, so... maybe this is just wrong?
+                        let timeStamp = getFileTimeStamp(fullPath);
+                        if (timeStamp > Date.now() - UPLOAD_THRESHOLD) continue;
+
+                        // NOTE: Because we use the same target path, if multiple services do this at the same time it's fine. Not great, but... fine.
+                        let backblazePath = FastArchiveAppendable.getBackblazePath({ fileName: file, threadId });
+                        console.log(magenta(`Moving ${fullPath} to Backblaze as ${backblazePath}`));
+
+                        let data = await measureBlock(async () => fs.promises.readFile(fullPath), "FastArchiveAppendable|readBeforeUploading");
+                        let compressed = await measureBlock(async () => Zip.gzip(data), "FastArchiveAppendable|compress");
+                        console.log(`Uploading ${formatNumber(data.length)}B (compressed to ${formatNumber(compressed.length)}B) logs to ${backblazePath} from ${fullPath}`);
+                        await archives.set(backblazePath, compressed);
+                        await fs.promises.unlink(fullPath);
+                    } catch (e: any) {
+                        // Just skip it, if the first file in the directory is broken we don't want to never move any files
+                        console.error(`Error moving log file ${fullPath}: ${e.stack}`);
+                    }
                 }
             }
 

package/src/diagnostics/logs/FastArchiveViewer.tsx

@@ -553,7 +553,7 @@ export class FastArchiveViewer<T> extends qreact.Component<{
                     </div>
                 </div>
 
-                <div className={css.vbox(12).fillWidth}>
+                <div className={css.vbox(12).fillWidth.paddingBottom(20)}>
                     <InputLabelURL
                         label={
                             <div className={css.hbox(10)}>

package/src/diagnostics/logs/lifeCycleAnalysis/spec.md

@@ -6,7 +6,9 @@ Very small amount of data
 
 
 4) Setup new hetnzer server
-    yarn setup-machine 176.9.2.136
+
+yarn setup-machine 176.9.2.136
+
 5) Update all services, and move them to that machine
 5) Verify the hezner server can run the site well
 6) Take down our digital ocean server