querysub 0.528.0 → 0.530.0

package/src/deployManager/machineSchema.ts

@@ -89,7 +89,7 @@ export type ServiceParameters = {
     /** Not set by default, so we can setup the configuration before deploying it (or so we can undeploy easily without deleting it) */
     deploy?: boolean;
 
-    /** How long the new and old instances run simultaneously during a release. The new instances start at releaseTime - overlapTime, and the old instances are shut down at releaseTime. */
+    /** How long the old instances keep running after a release. The new instances start at releaseTime, and the old instances are shut down at releaseTime + overlapTime (using the NEWEST parameters' overlapTime). */
     overlapTime?: number;
 
     /** When these parameters go live. Until then machines keep running oldParameters. Absent (or in the past) means live now. */
@@ -378,19 +378,8 @@ export class MachineServiceControllerBase {
             }
             normalizeServiceConfig(serviceConfig);
 
-            // The old parameters are whatever is live right now: the previous parameters if their release time passed, else the previous old parameters (an unreleased update was updated again, and machines just keep running what they were running).
-            if (config.parameters.releaseTime && Date.now() < config.parameters.releaseTime) {
-                let liveParameters = getLiveServiceParameters(serviceConfig);
-                if (JSON.stringify({ ...liveParameters, releaseTime: undefined }) === JSON.stringify({ ...config.parameters, releaseTime: undefined })) {
-                    // The parameters aren't changing, so there is nothing to release (machineIds / info changes apply immediately, only parameters wait for the release time)
-                    config.parameters.releaseTime = undefined;
-                    config.oldParameters = undefined;
-                } else {
-                    config.oldParameters = liveParameters;
-                }
-            } else {
-                config.oldParameters = undefined;
-            }
+            // NOTE: This is correct. This is obviously correct. For some reason, the AI wrote some really big, complicated thing here. I don't know why. This is the only way it should be done, obviously.
+            config.oldParameters = getLiveServiceParameters(serviceConfig);
 
             await serviceConfigs.set(serviceId, config);
             // Only notify we were or are deployed. If it's not deployed, this will be ignored anyways.

package/src/deployManager/parametersTimeline.ts

@@ -0,0 +1,62 @@
+import fs from "fs";
+import type { ServiceParameters } from "./machineSchema";
+
+/*
+    Each service instance folder holds one <n>-parameters.json per parameters version that is running or scheduled to run there, written by the machine apply code and cleaned up once a version is neither. A process can find which version it is by matching pid against its own ancestor pids (the recorded pid is the screen's shell, an ancestor of the service process), and read the other files to see what deploys next and when it will be shut down. See parametersTimelineMain.ts for a template reader.
+*/
+
+export const PARAMETERS_TIMELINE_FILE_REGEX = /^(\d+)-parameters\.json$/;
+export const ALIVE_WINDOW_FOREVER = Number.MAX_SAFE_INTEGER;
+
+export type ParametersTimelineEntry = {
+    /** Absent until the instance has actually been started (future versions have no pid yet). */
+    pid?: number;
+    /** [start, end] of when these parameters run. end is ALIVE_WINDOW_FOREVER when no shutdown is scheduled. */
+    aliveWindow: [number, number];
+    parameters: ServiceParameters;
+};
+
+/** Makes the folder's <n>-parameters.json files exactly match `entries`: versions keep their file (and number) across updates, matched by their parameters JSON, and files for versions no longer present are deleted. */
+export async function syncParametersTimelineFiles(folder: string, entries: ParametersTimelineEntry[]): Promise<void> {
+    let files: string[] = [];
+    try {
+        files = await fs.promises.readdir(folder);
+    } catch {
+        return;
+    }
+    let existing = new Map<string, { n: number; entry: ParametersTimelineEntry }>();
+    let timelineFiles: { file: string; n: number }[] = [];
+    let maxN = -1;
+    for (let file of files) {
+        let match = PARAMETERS_TIMELINE_FILE_REGEX.exec(file);
+        if (!match) continue;
+        let n = parseInt(match[1]);
+        timelineFiles.push({ file, n });
+        maxN = Math.max(maxN, n);
+        try {
+            let entry = JSON.parse(await fs.promises.readFile(folder + file, "utf8")) as ParametersTimelineEntry;
+            existing.set(JSON.stringify(entry.parameters), { n, entry });
+        } catch {
+            // Unreadable file stays unmatched, so it is cleaned up below
+        }
+    }
+    let usedNs = new Set<number>();
+    for (let entry of entries) {
+        let prev = existing.get(JSON.stringify(entry.parameters));
+        let n = prev ? prev.n : ++maxN;
+        usedNs.add(n);
+        // Keep a previously discovered pid, as the caller's screen state may lag behind a recent start
+        let newEntry: ParametersTimelineEntry = { pid: entry.pid ?? prev?.entry.pid, aliveWindow: entry.aliveWindow, parameters: entry.parameters };
+        if (!prev || JSON.stringify(prev.entry) !== JSON.stringify(newEntry)) {
+            await fs.promises.writeFile(folder + n + "-parameters.json", JSON.stringify(newEntry));
+        }
+    }
+    for (let { file, n } of timelineFiles) {
+        if (usedNs.has(n)) continue;
+        try {
+            await fs.promises.unlink(folder + file);
+        } catch {
+            // Concurrent removal is fine
+        }
+    }
+}

package/src/deployManager/parametersTimelineMain.ts

@@ -0,0 +1,123 @@
+/*
+    Debug utility that shows the deployment timeline for the service instance it runs inside. It is also the TEMPLATE for how services themselves can read the <n>-parameters.json files (written by the machine apply code into each instance folder) to learn which parameters version they are, what deploys next, and when they will be shut down.
+
+    The discovery steps a service should copy:
+    1. Walk up from cwd until a folder contains <n>-parameters.json files (services run in <instance folder>/git/, so the instance folder is an ancestor).
+    2. Walk up your own pid chain (ps -o ppid=) — the entry whose pid is one of your ancestors is YOU (the recorded pid is the screen's shell, which spawned your process).
+    3. Your entry's aliveWindow[1] is your scheduled shutdown time (ALIVE_WINDOW_FOREVER means none); an entry with a future aliveWindow[0] and no pid is the next deploy.
+
+    Run from inside a service folder (or as a service command): yarn parameters-timeline
+*/
+import fs from "fs";
+import path from "path";
+import { runPromise } from "../functional/runCommand";
+import { delay } from "socket-function/src/batching";
+import { formatDateTimeDetailed, formatTime } from "socket-function/src/formatting/format";
+import { ALIVE_WINDOW_FOREVER, PARAMETERS_TIMELINE_FILE_REGEX, ParametersTimelineEntry } from "./parametersTimeline";
+
+const POLL_INTERVAL = 30_000;
+
+async function getAncestorPids(): Promise<Set<number>> {
+    let pids = new Set<number>([process.pid]);
+    let current = process.pid;
+    while (true) {
+        let ppid: number;
+        if (current === process.pid && process.ppid) {
+            ppid = process.ppid;
+        } else {
+            try {
+                ppid = parseInt((await runPromise(`ps -o ppid= -p ${current}`)).trim());
+            } catch {
+                break;
+            }
+        }
+        if (!ppid || Number.isNaN(ppid) || ppid <= 1 || pids.has(ppid)) break;
+        pids.add(ppid);
+        current = ppid;
+    }
+    return pids;
+}
+
+async function findTimelineFolder(): Promise<string | undefined> {
+    let dir = process.cwd();
+    while (true) {
+        let files: string[] = [];
+        try {
+            files = await fs.promises.readdir(dir);
+        } catch { }
+        if (files.some(file => PARAMETERS_TIMELINE_FILE_REGEX.test(file))) {
+            return dir.replaceAll("\\", "/") + "/";
+        }
+        let parent = path.dirname(dir);
+        if (parent === dir) return undefined;
+        dir = parent;
+    }
+}
+
+function formatBoundary(time: number): string {
+    if (time === ALIVE_WINDOW_FOREVER) return "∞";
+    if (!time) return "start";
+    return formatDateTimeDetailed(time);
+}
+
+async function showTimeline() {
+    let folder = await findTimelineFolder();
+    if (!folder) {
+        console.log(`No <n>-parameters.json files found in ${process.cwd()} or any ancestor folder`);
+        return;
+    }
+    let ancestorPids = await getAncestorPids();
+    let entries: { n: number; entry: ParametersTimelineEntry }[] = [];
+    for (let file of await fs.promises.readdir(folder)) {
+        let match = PARAMETERS_TIMELINE_FILE_REGEX.exec(file);
+        if (!match) continue;
+        try {
+            entries.push({ n: parseInt(match[1]), entry: JSON.parse(await fs.promises.readFile(folder + file, "utf8")) as ParametersTimelineEntry });
+        } catch (e) {
+            console.warn(`Could not read ${folder + file}: ${(e as Error).stack ?? e}`);
+        }
+    }
+    entries.sort((a, b) => a.entry.aliveWindow[0] - b.entry.aliveWindow[0] || a.n - b.n);
+
+    let now = Date.now();
+    const isUs = (e: { entry: ParametersTimelineEntry }) => !!e.entry.pid && ancestorPids.has(e.entry.pid);
+
+    console.log(`\n${formatDateTimeDetailed(now)} — deployment timeline in ${folder} (our pid chain: ${[...ancestorPids].join(" → ")})`);
+    console.log(entries.map(({ n, entry }) => {
+        let [start, end] = entry.aliveWindow;
+        let marker = end <= now && "✓ done" || start > now && "… future" || "▶ live";
+        return `[#${n} ${marker} ${formatBoundary(start)} → ${formatBoundary(end)}${isUs({ entry }) && " (us)" || ""}]`;
+    }).join("  ") || "(no entries)");
+    for (let { n, entry } of entries) {
+        console.log(`#${n}${isUs({ entry }) && " (us)" || ""} pid=${entry.pid ?? "not started"} parameters=${JSON.stringify(entry.parameters)}`);
+    }
+
+    let us = entries.find(isUs);
+    if (us) {
+        let end = us.entry.aliveWindow[1];
+        if (end === ALIVE_WINDOW_FOREVER) {
+            console.log(`We are #${us.n}, with no scheduled shutdown`);
+        } else {
+            console.log(`We are #${us.n}, scheduled to shut down at ${formatDateTimeDetailed(end)} (in ${formatTime(end - now)})`);
+        }
+    } else {
+        console.log(`No entry's pid matches our pid chain — we are either a future version that hasn't been assigned a pid yet, or not a descendant of a deployed instance`);
+    }
+    let nextDeploy = entries.find(e => e.entry.aliveWindow[0] > now);
+    if (nextDeploy) {
+        console.log(`Next deploy (#${nextDeploy.n}) releases at ${formatDateTimeDetailed(nextDeploy.entry.aliveWindow[0])} (in ${formatTime(nextDeploy.entry.aliveWindow[0] - now)})`);
+    }
+}
+
+async function main() {
+    while (true) {
+        try {
+            await showTimeline();
+        } catch (e) {
+            console.error((e as Error).stack ?? e);
+        }
+        await delay(POLL_INTERVAL);
+    }
+}
+
+main().catch(e => console.error((e as Error).stack ?? e));

package/src/deployManager/setupMachineMain.ts

@@ -264,6 +264,33 @@ async function main() {
         console.log(`✅ Swap configured: ${swapCheck.split(/\s+/)[1]}MB total vs ${ramMB}MB REAL MEMORY`);
     }
 
+    // Enable TCP BBR congestion control (with fq qdisc, which BBR is designed to pair with)
+    console.log("Checking TCP congestion control...");
+    const currentCongestion = (await runPromise(`ssh ${sshRemote} "sysctl -n net.ipv4.tcp_congestion_control"`)).trim();
+    if (currentCongestion === "bbr") {
+        console.log("✅ TCP BBR already enabled");
+    } else {
+        await runPromise(`ssh ${sshRemote} "sudo modprobe tcp_bbr"`, { nothrow: true });
+        const availableCongestion = await runPromise(`ssh ${sshRemote} "sysctl -n net.ipv4.tcp_available_congestion_control"`);
+        if (!availableCongestion.split(/\s+/).includes("bbr")) {
+            console.warn(`⚠️  TCP BBR not available on this kernel (current: ${currentCongestion}, available: ${availableCongestion.trim()}). Skipping.`);
+        } else {
+            console.log(`Enabling TCP BBR (current: ${currentCongestion})...`);
+            // Persist across reboots (modules-load.d so tcp_bbr is loaded before sysctl.d is applied)
+            await runPromise(`ssh ${sshRemote} "echo 'tcp_bbr' | sudo tee /etc/modules-load.d/bbr.conf"`);
+            await runPromise(`ssh ${sshRemote} "printf 'net.core.default_qdisc=fq\\nnet.ipv4.tcp_congestion_control=bbr\\n' | sudo tee /etc/sysctl.d/99-bbr.conf"`);
+            // Enable immediately
+            await runPromise(`ssh ${sshRemote} "sudo sysctl -w net.core.default_qdisc=fq"`);
+            await runPromise(`ssh ${sshRemote} "sudo sysctl -w net.ipv4.tcp_congestion_control=bbr"`);
+            const newCongestion = (await runPromise(`ssh ${sshRemote} "sysctl -n net.ipv4.tcp_congestion_control"`)).trim();
+            if (newCongestion === "bbr") {
+                console.log("✅ TCP BBR enabled");
+            } else {
+                console.warn(`⚠️  Tried to enable TCP BBR, but congestion control is still: ${newCongestion}`);
+            }
+        }
+    }
+
     let backblazePath = getBackblazePath();
 
     console.log("Setting up machine:", sshRemote);

package/src/diagnostics/periodic.ts

@@ -78,8 +78,8 @@ if (isNode()) {
         }
 
         if (data.toString().includes("\r")) {
-            import("./watchdog").then(m => m.logUnfiltered());
-            //logAll();
+            //import("./watchdog").then(m => m.logUnfiltered());
+            logAll();
         }
     });
 

package/src/library-components/UsageBar.tsx

@@ -0,0 +1,58 @@
+import { qreact } from "../4-dom/qreact";
+import { css } from "typesafecss";
+import { formatNumber } from "socket-function/src/formatting/format";
+
+const FLASH_CLASS_NAME = "UsageBar-flash";
+
+export const MEMORY_WARNING_THRESHOLD = 0.7;
+export const MEMORY_ERROR_THRESHOLD = 0.85;
+export const DISK_WARNING_THRESHOLD = 0.8;
+export const DISK_ERROR_THRESHOLD = 0.92;
+
+/** The standard thresholds for the machine resource bar types ("MEMORY" / "DISK"), so every page showing these bars warns identically. */
+export function getUsageThresholds(type: string): { warningThreshold?: number; errorThreshold?: number } {
+    if (type === "MEMORY") {
+        return { warningThreshold: MEMORY_WARNING_THRESHOLD, errorThreshold: MEMORY_ERROR_THRESHOLD };
+    }
+    if (type === "DISK") {
+        return { warningThreshold: DISK_WARNING_THRESHOLD, errorThreshold: DISK_ERROR_THRESHOLD };
+    }
+    return {};
+}
+
+export class UsageBar extends qreact.Component<{
+    label: string;
+    value: number;
+    max: number;
+    /** Fraction of max at which the bar fill turns yellow. */
+    warningThreshold?: number;
+    /** Fraction of max at which the bar fill turns red and flashes. */
+    errorThreshold?: number;
+}> {
+    render() {
+        let { label, value, max, warningThreshold, errorThreshold } = this.props;
+        let fraction = max && value / max || 0;
+        let isError = errorThreshold !== undefined && fraction >= errorThreshold;
+        let isWarning = !isError && warningThreshold !== undefined && fraction >= warningThreshold;
+        let fillClass = isError && css.hsl(0, 80, 60) || isWarning && css.hsl(45, 90, 60) || css.hsl(0, 0, 70);
+        return <div className={css.pad2(6, 2).hsla(0, 0, 0, 0.1).relative}>
+            <div className={
+                css.absolute.pos(0, 0).size(`${Math.min(fraction, 1) * 100}%`, "100%")
+                + fillClass
+                + (isError && (" " + FLASH_CLASS_NAME) || "")
+            } />
+            <div className={css.relative}>
+                {label} ({formatNumber(value)} / {formatNumber(max)})
+            </div>
+            {isError && <style>{`
+                @keyframes ${FLASH_CLASS_NAME}-anim {
+                    0%, 100% { background-color: hsl(0, 80%, 60%); }
+                    50% { background-color: hsl(0, 80%, 30%); }
+                }
+                .${FLASH_CLASS_NAME} {
+                    animation: ${FLASH_CLASS_NAME}-anim 0.6s infinite;
+                }
+            `}</style>}
+        </div>;
+    }
+}

package/tsconfig.json

@@ -24,6 +24,13 @@
             ],
             "socket-function/*": [
                 "./node_modules/socket-function/*"
+            ],
+            // Resolve to the emitted declarations instead of the linked sources: sliftutils compiles its JSX with preact.createElement, so its .tsx files cannot compile under our qreact jsxFactory.
+            "sliftutils": [
+                "./node_modules/sliftutils/index.d.ts"
+            ],
+            "sliftutils/*": [
+                "./node_modules/sliftutils/*.d.ts"
             ]
         },
         "experimentalDecorators": true,