querysub 0.557.0 → 0.559.0

package/appSecrets.ts

@@ -1,62 +1,11 @@
 import fs from "fs";
-import os from "os";
-import { isNode } from "socket-function/src/misc";
 import { lazy } from "socket-function/src/caching";
 import { ArchivesBackblaze } from "sliftutils/storage/backblaze";
-import { parseArgsFactory } from "./src/misc/rawParams";
+import { STORAGE_DIR, getDomain, getBackblazePath } from "./src/misc/appPaths";
 import { Querysub } from "./src/4-querysub/Querysub";
 
-// getSecret always imports us relative to the process cwd, so the cwd is the repo root and this matches what getStorageDir would resolve
-const STORAGE_DIR = "./database-storage/";
-
-// querysubConfig and getDomain are copied verbatim from src/config.ts, so this file has no dependencies on our own application (parseArgsFactory is fine to import, as it has no dependencies of its own)
-
-let yargObj = parseArgsFactory()
-    .option("domain", { type: "string", desc: `Sets the domain` })
-    .argv
-    ;
-
-type QuerysubConfig = {
-    domain?: string;
-    emaildomain?: string;
-    notifyemails?: string[];
-};
-let querysubConfig = lazy((): QuerysubConfig => {
-    if (!isNode()) throw new Error("querysubConfig is only available on the server");
-    const path = "./querysub.json";
-    if (!fs.existsSync(path)) {
-        return {};
-    }
-    try {
-        return JSON.parse(fs.readFileSync(path, "utf8"));
-    } catch (e) {
-        console.error("Error parsing querysub.json", e);
-        return {};
-    }
-});
-
-export function getDomain() {
-    if (!isNode()) {
-        return location.hostname.split(".").slice(-2).join(".");
-    }
-    return yargObj.domain || querysubConfig().domain || "querysub.com";
-}
-
 const keysArchives = lazy(() => new ArchivesBackblaze({ bucketName: getDomain() }));
 
-export function getBackblazePath() {
-    let testPaths = [
-        STORAGE_DIR + "backblaze.json",
-        os.homedir() + "/backblaze.json",
-    ];
-    for (let path of testPaths) {
-        if (fs.existsSync(path)) {
-            return path;
-        }
-    }
-    return testPaths[0];
-}
-
 export const getCloudflareCreds = lazy(async (): Promise<{ key: string; email: string }> => {
     let archives = keysArchives();
     let credsJSON = await archives.get("keys/cloudflare.json");

package/package.json

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

@@ -3,7 +3,7 @@ import { Archives } from "./archives";
 import fs from "fs";
 import { isNode, timeInMinute } from "socket-function/src/misc";
 import { isLogBackblaze } from "../config";
-import { getBackblazePath } from "../../appSecrets";
+import { getBackblazePath } from "../misc/appPaths";
 import { ArchivesBackblaze as ArchivesBackblazeBase } from "sliftutils/storage/backblaze";
 import type { IArchives, ArchivesConfig } from "sliftutils/storage/IArchives";
 

package/src/4-querysub/Querysub.ts

@@ -50,7 +50,6 @@ import yargs, { check } from "yargs";
 import { parseArgsFactory } from "../misc/rawParams";
 
 import * as typesafecss from "typesafecss";
-import "../library-components/urlResetGroups";
 import { createLocalSchema } from "./schemaHelpers";
 
 setTimeout(() => import("./FunctionRunnerTracking"));

package/src/deployManager/components/RouteConfigView.tsx

@@ -5,6 +5,7 @@ import { css } from "typesafecss";
 import { sort } from "socket-function/src/misc";
 import { formatNumber, formatDateTime, formatTime, formatDateTimeDetailed } from "socket-function/src/formatting/format";
 import { parseHostedUrl, parseBackblazeUrl } from "sliftutils/storage/remoteStorage/remoteConfig";
+import { resolveIntermediateSources, getIntermediateSources } from "sliftutils/storage/remoteStorage/intermediateSources";
 import { SocketFunction } from "socket-function/SocketFunction";
 import { FULL_VALID_WINDOW, FULL_ROUTE } from "sliftutils/storage/IArchives";
 import type { RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig } from "sliftutils/storage/IArchives";
@@ -20,6 +21,7 @@ type Source = HostedConfig | BackblazeConfig;
 const DEFAULT_HTTPS_PORT = 443;
 const TAG_COLOR = { h: 210, s: 45, l: 88 };
 const WARNING_COLOR = { h: 35, s: 90, l: 85 };
+const NOTICE_COLOR = { h: 205, s: 70, l: 88 };
 const SOURCE_BORDER_COLOR = { h: 0, s: 0, l: 75 };
 const ACTIVE_COLOR = { h: 130, s: 55, l: 85 };
 const PAST_COLOR = { h: 0, s: 0, l: 90 };
@@ -454,10 +456,29 @@ class WindowRanges extends qreact.Component<{ sources: Source[]; ownBucketName:
     }
 }
 
+/** Two configs that differ only by switchover windows are not really in conflict - resolving those away is exactly what a client does before using the config, so if the remainder matches, every server is working from the same underlying configuration. The version is ignored: a config gains a version purely by having an intermediate written into it. */
+function getIntermediateOnlyDifference(consensus: RemoteConfig, other: RemoteConfig, now: number): {
+    intermediateOnly: boolean;
+    /** Undefined when nothing is pending; otherwise when the last switchover window still in the future ends */
+    expiresAt?: number;
+} {
+    let sourcesOf = (config: RemoteConfig) => JSON.stringify(resolveIntermediateSources(config).sources);
+    let intermediateOnly = sourcesOf(consensus) === sourcesOf(other);
+    let ends = [...getIntermediateSources(consensus), ...getIntermediateSources(other)].map(x => x.validWindow[1]);
+    let pending = ends.filter(end => end > now);
+    return {
+        intermediateOnly,
+        expiresAt: pending.length && Math.max(...pending) || undefined,
+    };
+}
+
 class ConflictWarning extends qreact.Component<{ consensus: ConfigVariant; conflict: ConfigConflict }> {
     render() {
         let { consensus, conflict } = this.props;
         let { bucketName, variant } = conflict;
+        let now = Querysub.timeDelayed(TIME_REFRESH_INTERVAL);
+        let { intermediateOnly, expiresAt } = getIntermediateOnlyDifference(consensus.rawConfig, variant.rawConfig, now);
+        let color = intermediateOnly && NOTICE_COLOR || WARNING_COLOR;
         let consensusKeys = new Set(consensus.sources.map(x => getSourceKey(x, bucketName)));
         let conflictKeys = new Set(variant.sources.map(x => getSourceKey(x, bucketName)));
         let extra = variant.sources.filter(x => !consensusKeys.has(getSourceKey(x, bucketName)));
@@ -469,10 +490,15 @@ class ConflictWarning extends qreact.Component<{ consensus: ConfigVariant; confl
                 route {(source.route || FULL_ROUTE).join(" – ")}, valid {formatWindowTime(source.validWindow[0])} → {formatWindowTime(source.validWindow[1])}
             </div>
         </div>;
-        return <div className={css.vbox(6).pad2(10, 8).hsl(WARNING_COLOR.h, WARNING_COLOR.s, WARNING_COLOR.l).bord2(WARNING_COLOR.h, WARNING_COLOR.s, WARNING_COLOR.l - 25)}>
+        return <div className={css.vbox(6).pad2(10, 8).hsl(color.h, color.s, color.l).bord2(color.h, color.s, color.l - 25)}>
             <div className={css.boldStyle}>
-                ⚠ {bucketName}: {variant.servers.length} server{variant.servers.length === 1 && "" || "s"} report a different routing config (version {String(variant.version ?? "none")}, consensus is version {String(consensus.version ?? "none")})
+                {intermediateOnly && "ℹ" || "⚠"} {bucketName}: {variant.servers.length} server{variant.servers.length === 1 && "" || "s"} report a different routing config (version {String(variant.version ?? "none")}, consensus is version {String(consensus.version ?? "none")})
             </div>
+            {intermediateOnly && <div>
+                Only the switchover windows differ - with those resolved away, every server is working from the same configuration.
+                {expiresAt === undefined && " They are all in the past, so this shouldn't break anything."}
+                {expiresAt !== undefined && ` The sources become consistent again once the last one expires, ${formatTime(expiresAt - now)} from now (${formatWindowTimeDetailed(expiresAt)}).`}
+            </div>}
             <div className={css.vbox(2).fontSize(TAG_FONT_SIZE)}>
                 {variant.servers.map(server => <div key={server}>{server}</div>)}
             </div>

package/src/deployManager/machineApplyMainCode.ts

@@ -26,7 +26,7 @@ import { PromiseObj } from "../promise";
 import path from "path";
 import { fsExistsAsync } from "../fs";
 import { ALIVE_WINDOW_FOREVER, ParametersTimelineEntry, syncParametersTimelineFiles } from "./parametersTimeline";
-import { getScreenName, getFutureScreenName, getTmuxPrefix, getScreenState, isScreenRunningProcess, getProcessStartTime, runScreenCommand, killScreen, streamProcessOutput } from "./processManager";
+import { getScreenName, getFutureScreenName, getTmuxPrefix, getScreenState, isScreenRunningProcess, getProcessStartTime, ensureProcessRecord, runScreenCommand, killScreen, streamProcessOutput } from "./processManager";
 import { ProcessRecord, syncProcessRecords, writeProcessRecord, listProcessRecords, getProcessLogPath } from "./processLogs";
 
 
@@ -288,6 +288,19 @@ async function ensureFutureStarted(config: FutureConfig) {
     let existing = config.screenStateMap.get(futureScreenName);
     if (existing?.isProcessRunning) {
         config.screenNamesUsed.add(futureScreenName);
+        // Started before we restarted, so record it rather than only ever recording processes we launched ourselves
+        await ensureProcessRecord({
+            screenName: futureScreenName,
+            folder: os.homedir() + "/" + SERVICE_FOLDER + canonicalScreenName + "/",
+            panePid: existing.pid,
+            record: {
+                serviceId: config.serviceId,
+                serviceKey: config.next.key,
+                index: config.index,
+                machineId: config.machineId,
+                parameters: config.next,
+            },
+        });
         console.log(green(`Verified future instance ${magenta(futureScreenName)} is running`));
         return;
     }
@@ -515,6 +528,22 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                 if (isPrepTime) {
                     // From prep time on, the canonical (old) screen is left completely untouched — the folder holds the NEW code and parameters by now, so the normal compare/sync logic below must not run against the old process
                     if (screenStateMap.get(screenName)?.isProcessRunning) {
+                        // The old instance keeps running untouched through the overlap, but it still needs a record - it may have been launched before we restarted
+                        let panePid = screenStateMap.get(screenName)?.pid;
+                        if (panePid) {
+                            await ensureProcessRecord({
+                                screenName,
+                                folder,
+                                panePid,
+                                record: {
+                                    serviceId: config.serviceId,
+                                    serviceKey: config.parameters.key,
+                                    index: i,
+                                    machineId,
+                                    parameters: instanceParameters,
+                                },
+                            });
+                        }
                         await syncTimeline(screenStateMap.get(screenName)?.pid);
                         let nodePathId = folder + SERVICE_NODE_FILE_NAME;
                         if (await fsExistsAsync(nodePathId)) {
@@ -573,6 +602,22 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                     if (prevParameters !== newParametersString) {
                         await fs.promises.writeFile(parameterPath, newParametersString);
                     }
+                    // We did not launch this process (we restarted, or it predates process records), so make sure it is recorded before we leave it alone
+                    let panePid = screenStateMap.get(screenName)?.pid;
+                    if (panePid) {
+                        await ensureProcessRecord({
+                            screenName,
+                            folder,
+                            panePid,
+                            record: {
+                                serviceId: config.serviceId,
+                                serviceKey: config.parameters.key,
+                                index: i,
+                                machineId,
+                                parameters: instanceParameters,
+                            },
+                        });
+                    }
                     await syncTimeline(screenStateMap.get(screenName)?.pid);
                     console.log(green(`Verified ${magenta(screenName)} is running`));
                     continue;

package/src/deployManager/processManager.ts

@@ -11,7 +11,7 @@ import { forceRemoveNode } from "../-f-node-discovery/NodeDiscovery";
 import { fsExistsAsync } from "../fs";
 import { PromiseObj } from "../promise";
 import { SERVICE_FOLDER, SERVICE_NODE_FILE_NAME } from "./machineSchema";
-import { ProcessRecord, createLaunchId, getLogPipeScript, getLogTailScript, getProcessLogPath, getPipeScriptPath, getTailScriptPath, writeProcessRecord } from "./processLogs";
+import { ProcessRecord, createLaunchId, getLogPipeScript, getLogTailScript, getProcessLogPath, getPipeScriptPath, getTailScriptPath, listProcessRecords, writeProcessRecord } from "./processLogs";
 
 // Running, inspecting and killing the tmux screens services run in. This layer only knows "here is a configuration, run it" - which version should be running when is the deploy logic's problem.
 
@@ -244,6 +244,38 @@ ${config.command}
     return launchId;
 });
 
+/** Links an already-running screen to a process record, creating one when this process has never been recorded - it was launched before we restarted, or before process records existed at all. Idempotent: a process we already know about is left alone, so the pipe is only attached the first time we adopt it.
+ *
+ * The screen identifies itself (pane pid + the start time the OS reports for it), so adoption is just naming what is already there - there is nothing to reconcile and nothing to guess. */
+export async function ensureProcessRecord(config: {
+    screenName: string;
+    folder: string;
+    panePid: string;
+    record: Omit<ProcessRecord, "launchId" | "folder" | "screenName" | "startTime" | "pid">;
+}): Promise<void> {
+    let startTime = await getProcessStartTime(config.panePid);
+    if (!startTime) return;
+    let launchId = createLaunchId(config.panePid, startTime);
+    let existing = (await listProcessRecords()).find(x => x.launchId === launchId && x.folder === config.folder);
+    if (existing) {
+        // A takeover renames the session, so the record follows the name it now runs under
+        if (existing.screenName === config.screenName) return;
+        await writeProcessRecord({ ...existing, screenName: config.screenName });
+        return;
+    }
+    console.log(`Adopting already-running process ${launchId} on screen ${config.screenName}, which has no record yet`);
+    await writeProcessRecord({
+        ...config.record,
+        launchId,
+        folder: config.folder,
+        screenName: config.screenName,
+        pid: parseInt(config.panePid) || undefined,
+        startTime,
+    });
+    // Its output was going to whatever the previous incarnation pointed at (or nowhere), so point it at its own log from here on
+    await setupPipePane({ screenName: config.screenName, folder: config.folder, launchId });
+}
+
 // Points the screen's pipe-pane at this launch's own log file.
 async function setupPipePane(config: { screenName: string; folder: string; launchId: string }) {
     let prefix = getTmuxPrefix();

package/src/deployManager/setupMachineMain.ts

@@ -1,4 +1,4 @@
-import { getBackblazePath } from "../../appSecrets";
+import { getBackblazePath } from "../misc/appPaths";
 import { getGitURLLive, getGitRefLive } from "../4-deploy/git";
 import { Querysub } from "../4-querysub/Querysub";
 import { runPromise } from "../functional/runCommand";

package/src/library-components/URLParam.ts

@@ -170,6 +170,12 @@ export function createURLSync<T>(urlKey: string, defaultValue: T, config?: URLPa
     return param;
 }
 
+if (!syncSchema) {
+    debugger;
+    require("debugbreak")(2);
+    debugger;
+}
+
 // TODO: Support pathname keys (ex /name-value)
 const { data } = syncSchema<{
     params: {

package/src/misc/appPaths.ts

@@ -0,0 +1,56 @@
+import fs from "fs";
+import os from "os";
+import { isNode } from "socket-function/src/misc";
+import { lazy } from "socket-function/src/caching";
+import { parseArgsFactory } from "./rawParams";
+
+// Where the machine's own configuration and credentials live on disk. Deliberately dependency-free (beyond rawParams, which has no dependencies of its own): the storage layer needs these paths, and it sits far below the application - routing this through appSecrets.ts made the lowest-level archives code depend on Querysub.
+
+// getSecret always imports appSecrets relative to the process cwd, so the cwd is the repo root and this matches what getStorageDir would resolve
+export const STORAGE_DIR = "./database-storage/";
+
+// querysubConfig and getDomain are copied verbatim from src/config.ts, so this file has no dependencies on our own application
+
+let yargObj = parseArgsFactory()
+    .option("domain", { type: "string", desc: `Sets the domain` })
+    .argv
+    ;
+
+type QuerysubConfig = {
+    domain?: string;
+    emaildomain?: string;
+    notifyemails?: string[];
+};
+let querysubConfig = lazy((): QuerysubConfig => {
+    if (!isNode()) throw new Error("querysubConfig is only available on the server");
+    const path = "./querysub.json";
+    if (!fs.existsSync(path)) {
+        return {};
+    }
+    try {
+        return JSON.parse(fs.readFileSync(path, "utf8"));
+    } catch (e) {
+        console.error("Error parsing querysub.json", e);
+        return {};
+    }
+});
+
+export function getDomain() {
+    if (!isNode()) {
+        return location.hostname.split(".").slice(-2).join(".");
+    }
+    return yargObj.domain || querysubConfig().domain || "querysub.com";
+}
+
+export function getBackblazePath() {
+    let testPaths = [
+        STORAGE_DIR + "backblaze.json",
+        os.homedir() + "/backblaze.json",
+    ];
+    for (let path of testPaths) {
+        if (fs.existsSync(path)) {
+            return path;
+        }
+    }
+    return testPaths[0];
+}