querysub 0.566.0 → 0.568.0

package/appSecrets.ts

@@ -24,7 +24,7 @@ export const getCloudflareCreds = lazy(async (): Promise<{ key: string; email: s
 /** Serves the secret keys sliftutils' getSecret expects, reading them the way querysub already does: backblaze creds off disk (getBackblazePath), cloudflare creds from the keys archives bucket (with its local file fallback). */
 export async function getAppSecret(key: string): Promise<string | undefined> {
     // Import query sub so our logs go to our actual log server. Otherwise we won't know if we get any errors. 
-    //Querysub;
+    Querysub;
     if (key.startsWith("backblaze.json.")) {
         let creds = JSON.parse(fs.readFileSync(getBackblazePath(), "utf8")) as { applicationKeyId?: string; applicationKey?: string };
         if (key === "backblaze.json.applicationKeyId") return creds.applicationKeyId;

package/package.json

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

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, ensureProcessRecord, runScreenCommand, killScreen, streamProcessOutput } from "./processManager";
+import { getScreenName, getFutureScreenName, getRetiringScreenName, getTmuxPrefix, getScreenState, isScreenRunningProcess, getProcessStartTime, ensureProcessRecord, runScreenCommand, killScreen, streamProcessOutput } from "./processManager";
 import { ProcessRecord, syncProcessRecords, writeProcessRecord, listProcessRecords, getProcessLogPath } from "./processLogs";
 
 
@@ -339,11 +339,17 @@ async function takeoverFutureScreen(config: {
     // The rename makes the future name vanish, but the caller's original screen list still has it — mark it used so the unused-screen cleanup doesn't try to kill a nonexistent session
     config.screenNamesUsed.add(futureScreenName);
     if (screenStateMap.has(canonicalScreenName)) {
-        await killScreen({ screenName: canonicalScreenName, skipNodeIdRemoval: true });
+        // The old screen is moved aside rather than waited on: the canonical name is free immediately, and its shutdown (Ctrl+C, then the hard kill) runs on its own without holding up this service or the next one.
+        let retiringScreenName = getRetiringScreenName(canonicalScreenName, Date.now());
+        let prefix = getTmuxPrefix();
+        await runPromise(`${prefix}tmux rename-session -t ${canonicalScreenName} ${retiringScreenName}`);
         screenStateMap.delete(canonicalScreenName);
+        // Kept out of the unused-screen sweep, which would kill it a second time while it is already winding down
+        config.screenNamesUsed.add(retiringScreenName);
+        void killScreen({ screenName: retiringScreenName, skipNodeIdRemoval: true });
         let oldNodeId = takeoverOldNodeIds.get(canonicalScreenName);
         if (oldNodeId) {
-            await forceRemoveNode(oldNodeId);
+            void forceRemoveNode(oldNodeId);
         }
     }
     takeoverOldNodeIds.delete(canonicalScreenName);
@@ -429,7 +435,8 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
         }
     }
 
-    for (let { record, config, releaseTime, overlapTime, killTime, releaseInFlight, isPrepTime, isOverlapTime } of recordStates) {
+    // Services run concurrently: each has its own folders, its own screens and its own records, and yarn install takes a network mutex, so there is nothing for them to serialize behind. One slow service (a git sync, a yarn install, a screen taking its full shutdown grace) no longer delays every service after it.
+    await Promise.all(recordStates.map(async ({ record, config, releaseTime, overlapTime, killTime, releaseInFlight, isPrepTime, isOverlapTime }) => {
         if (releaseInFlight) {
             upcomingReleases.push({ releaseTime, overlapTime });
             console.log(magenta(`Release in flight for ${record.serviceId} (${record.parameters.key}): the new version starts at ${new Date(releaseTime).toLocaleString()}${isOverlapTime && " (overlap running)" || ""}, the old instances are killed at ${new Date(killTime).toLocaleString()}`));
@@ -460,7 +467,7 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                 }
             }
         }
-        if (!config.parameters.deploy) continue;
+        if (!config.parameters.deploy) return;
         let matchedTargets = getMachineTargets(config.parameters).filter(target => target.machineId === machineId);
         for (let i = 0; i < matchedTargets.length; i++) {
             // Each instance runs the command with its own entry's template variables resolved, so the per-instance parameters (written to parameters.json and compared for restarts) carry the resolved command.
@@ -512,13 +519,13 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                 };
 
                 if (releaseInFlight) {
-                    // Tell the running instance when it will be shut down, so it (and everything talking to it) can wind down gracefully. Once the future instance may have started, the folder's nodeId file can belong to the NEW process, so from then on only the stashed old nodeId is safe to notify.
+                    // Tell the running instance when it will be shut down, so it (and everything talking to it) can wind down gracefully. Fire and forget: it is a courtesy to the process, and nothing about taking it down may wait on a call to the process we are taking down. Once the future instance may have started, the folder's nodeId file can belong to the NEW process, so from then on only the stashed old nodeId is safe to notify.
                     if (!isOverlapTime) {
-                        await notifyServiceShutdown(screenName, killTime);
+                        void notifyServiceShutdown(screenName, killTime);
                     } else {
                         let oldNodeId = takeoverOldNodeIds.get(screenName);
                         if (oldNodeId) {
-                            await notifyNodeShutdown(screenName, oldNodeId, killTime);
+                            void notifyNodeShutdown(screenName, oldNodeId, killTime);
                         }
                     }
                 } else {
@@ -690,11 +697,12 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
             lastLaunchedTimePerService.set(config.serviceId, lastLaunchedTime);
             launchesPerService.set(config.serviceId, launchCount);
         }
-    }
+    }));
 
     for (let { screenName } of screenState) {
         if (screenNamesUsed.has(screenName)) continue;
-        await killScreen({
+        // Detached, so a screen that takes its full grace period to go down doesn't hold up the end of the resync
+        void killScreen({
             screenName,
         });
     }

package/src/deployManager/processManager.ts

@@ -24,6 +24,10 @@ const SCREEN_SUFFIX = "-dply";
 export function getScreenName(config: { serviceKey: string; index: number }): string {
     return `${config.serviceKey}-${config.index}${SCREEN_SUFFIX}`.replace(/[^a-zA-Z0-9\-_]/g, "_");
 }
+/** The name an outgoing screen is moved to so the new process can take the canonical name at once, instead of anything waiting for the old process to wind down. Keeps the suffix, so it is still a screen we know about. */
+export function getRetiringScreenName(canonicalScreenName: string, at: number): string {
+    return canonicalScreenName.slice(0, -SCREEN_SUFFIX.length) + `-retiring-${at}` + SCREEN_SUFFIX;
+}
 // The new version's screen during a release, in the SAME folder as the canonical screen: created (just echoing when it will start) shortly before releaseTime, started at releaseTime, and renamed to the canonical screen name once the old screen is killed at releaseTime + overlapTime.
 export function getFutureScreenName(canonicalScreenName: string): string {
     return canonicalScreenName.slice(0, -SCREEN_SUFFIX.length) + "-future" + SCREEN_SUFFIX;