querysub 0.612.0 → 0.614.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.612.0",
+  "version": "0.614.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -75,7 +75,7 @@
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
     "peggy": "^5.0.6",
-    "sliftutils": "^1.7.85",
+    "sliftutils": "^1.7.86",
     "socket-function": "^1.2.30",
     "terser": "^5.31.0",
     "typenode": "^6.6.1",

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

@@ -73,7 +73,7 @@ function archiveBuilder(bucket: string, overrides: Partial<RemoteConfigBase>) {
     ]);
 
     return createArchives({
-        version: 20,
+        version: 21,
         sources,
     });
 }

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, getRetiringKillTime, retireScreen, retireCurrentScreen, getTmuxPrefix, getScreenState, isScreenRunningProcess, getProcessStartTime, getScreenPanePid, ensureProcessRecord, runScreenCommand, killScreen, readServiceNodeId, removeServiceNode, killScreenNow, withScreenLock } from "./processManager";
+import { getScreenName, getRetiringKillTime, getCanonicalScreenName, retireScreen, retireScreenWithMaxKillTime, retireCurrentScreen, getTmuxPrefix, getScreenState, isScreenRunningProcess, getProcessStartTime, getScreenPanePid, ensureProcessRecord, runScreenCommand, killScreen, readServiceNodeId, removeServiceNode, killScreenNow, withScreenLock } from "./processManager";
 import { ProcessRecord, syncProcessRecords, listProcessRecords } from "./processLogs";
 
 
@@ -261,6 +261,17 @@ function getMachineInstances(configs: ServiceConfig[], machineId: string): { con
     return instances;
 }
 
+// A version being replaced is renamed aside and given until this before it is taken down, which is the only thing an overlap is. Anchored to the release, not to whenever this resync happened to run, so every machine's old process goes at the same moment however staggered the resyncs are. Uses the NEWEST parameters' overlapTime, so shortening the overlap pulls the deadline in even for versions already retiring.
+function getInstanceKillTime(parameters: ServiceParameters): number {
+    return (parameters.releaseTime || Date.now()) + (parameters.overlapTime ?? DEFAULT_OVERLAP_TIME);
+}
+/** The canonical screen name of one instance - the version that should be running there. Single source of truth for the name, so the retiring-screen sweep derives it the same way ensureScreen does. */
+function getInstanceScreenName(config: ServiceConfig, index: number): string {
+    let live = getLiveServiceParameters(config);
+    let serviceKey = (live.deploy ? live : config.parameters).key;
+    return getScreenName({ serviceKey, index });
+}
+
 /** Puts one instance of a service into the state its configuration describes: the folder synced, the process running what it should be, and the records and timeline saying so. Returns the screen it is using, so anything nobody claimed can be killed. Everything about the screen happens under its lock, so two passes can never interleave. */
 async function ensureScreen(config: {
     config: ServiceConfig;
@@ -272,13 +283,12 @@ async function ensureScreen(config: {
     let serviceId = config.config.serviceId;
     let serviceConfig = config.config;
 
-    // A version being replaced is renamed aside and given until this before it is taken down, which is the only thing an overlap is. Anchored to the release, not to whenever this resync happened to run, so every machine's old process goes at the same moment however staggered the resyncs are.
-    let killTime = (serviceConfig.parameters.releaseTime || Date.now()) + (serviceConfig.parameters.overlapTime ?? DEFAULT_OVERLAP_TIME);
+    let killTime = getInstanceKillTime(serviceConfig.parameters);
 
     // The screen name means one thing: the version that should be running. There is no second name to reason about - anything it replaced is already renamed aside and carries its own deadline.
     let parameters: ServiceParameters | undefined = getLiveServiceParameters(serviceConfig);
     if (!parameters.deploy) parameters = undefined;
-    let screenName = getScreenName({ serviceKey: (parameters || serviceConfig.parameters).key, index });
+    let screenName = getInstanceScreenName(serviceConfig, index);
     let folder = os.homedir() + "/" + SERVICE_FOLDER + screenName + "/";
     // Returned even when the work below throws, so a transient failure never makes the sweep kill a screen we still want
     let usedScreenNames = [screenName];
@@ -500,6 +510,12 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
     // The fast-path results are memoized per resync, so a folder shared by two instances is only traversed once
     gitFastPathChecks.clear();
 
+    // The kill time each instance's overlap now wants, keyed by the canonical screen name its retiring predecessor was renamed from. Lets the sweep cap an already-retiring screen's deadline against the newest overlap instead of the (possibly longer) one baked into its name.
+    let killTimeByScreen = new Map<string, number>();
+    for (let { config, index } of instances) {
+        killTimeByScreen.set(getInstanceScreenName(config, index), getInstanceKillTime(config.parameters));
+    }
+
     // Every instance converges concurrently. Each has its own folder, its own records and its own lock, and yarn install takes a network mutex, so there is nothing to serialize behind - one slow git sync or shutdown no longer delays everything after it.
     let usedScreenNames = new Set((await Promise.all(instances.map(instance => ensureScreen({ ...instance, machineInfo })))).flat());
 
@@ -508,7 +524,14 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
         if (usedScreenNames.has(screenName)) continue;
         // A retiring screen is not unclaimed - it is a version that was replaced, and its name says when it is due to go. Cached per name, so seeing it on every resync only ever starts one, and a restart picks it up again from the name alone.
         if (getRetiringKillTime(screenName) !== undefined) {
-            void retireScreen(screenName);
+            let canonicalScreenName = getCanonicalScreenName(screenName);
+            // Capped against the newest overlap when we still have that instance's config, so a shortened overlap pulls the deadline in (down to now, killing it) rather than letting it wait out the time baked into its name. Without a matching config we cannot know the new overlap, so we honor the name.
+            let maxKillTime = canonicalScreenName !== undefined ? killTimeByScreen.get(canonicalScreenName) : undefined;
+            if (maxKillTime !== undefined && canonicalScreenName !== undefined) {
+                void retireScreenWithMaxKillTime({ screenName, folder: root + canonicalScreenName + "/", maxKillTime });
+            } else {
+                void retireScreen(screenName);
+            }
             continue;
         }
         // Detached, so a screen that takes its full grace period to go down doesn't hold up the end of the resync

package/src/deployManager/processManager.ts

@@ -356,6 +356,47 @@ export async function retireCurrentScreen(config: {
     void retireScreen(retiringScreenName);
 }
 
+/** The canonical name a retiring screen was renamed from - the inverse of getRetiringScreenName. Undefined for a name that is not a retiring screen. */
+export function getCanonicalScreenName(screenName: string): string | undefined {
+    let marker = screenName.lastIndexOf(RETIRING_MARKER);
+    if (marker === -1) return undefined;
+    return screenName.slice(0, marker) + SCREEN_SUFFIX;
+}
+
+/** Schedules a retiring screen's takedown, capped at maxKillTime: a shortened overlap can leave a screen scheduled to go later than it now should, and since the deadline lives in the name, the only way to move it is to rename the screen. When the cap is earlier than the time baked into the name, this renames it to carry the earlier time (down to now, which retireScreen then acts on immediately, killing it) and re-arms against the new name. When nothing needs pulling in, it just re-arms the existing timer, so it is safe to call every sweep. */
+export async function retireScreenWithMaxKillTime(config: { screenName: string; folder: string; maxKillTime: number }): Promise<void> {
+    let { screenName, folder } = config;
+    let maxKillTime = Math.round(config.maxKillTime);
+    let currentKillTime = getRetiringKillTime(screenName);
+    if (currentKillTime === undefined) return;
+    let canonicalScreenName = getCanonicalScreenName(screenName);
+    if (canonicalScreenName !== undefined && maxKillTime < currentKillTime) {
+        let newScreenName = getRetiringScreenName(canonicalScreenName, maxKillTime);
+        if (newScreenName !== screenName) {
+            console.log(green(`Pulling in retiring ${screenName} to ${newScreenName} (kill time ${new Date(currentKillTime).toISOString()} -> ${new Date(maxKillTime).toISOString()})`));
+            let pid = await getScreenPanePid(screenName);
+            // The pending timer is waiting on the OLD, later deadline; drop it so a fresh one runs against the new name's earlier deadline.
+            retireScreen.clear(screenName);
+            try {
+                await runPromise(`${getTmuxPrefix()}tmux rename-session -t ${screenName} ${newScreenName}`);
+            } catch (e) {
+                // Another pass may have already renamed or killed it
+                console.log(`Could not rename retiring ${screenName} to ${newScreenName} (already renamed or gone?): ${(e as Error).stack ?? e}`);
+                return;
+            }
+            if (pid) {
+                let record = await findProcessRecordByPid(folder, pid);
+                if (record) {
+                    await writeProcessRecord({ ...record, screenName: newScreenName });
+                }
+            }
+            void retireScreen(newScreenName);
+            return;
+        }
+    }
+    void retireScreen(screenName);
+}
+
 /** Ends a session at once, with no notice - for a screen that should not exist at all, so there is nothing to wind down gracefully. Finding one is always a surprise, so the reason it was not supposed to be there is logged. */
 export async function killScreenNow(screenName: string, reason: string): Promise<void> {
     let panePid = await getScreenPanePid(screenName);