querysub 0.562.0 → 0.563.0

package/package.json

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

@@ -642,8 +642,11 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                     time: Date.now(),
                 });
 
+                // Every launch goes through the future screen and a rename, releases and plain restarts alike. The new process is up before the old one is touched, so nothing waits on a shutdown, and the pane it runs in is always new - which is what makes it a distinct process with its own log.
+                let launchScreenName = getFutureScreenName(screenName);
                 let launchId = await runScreenCommand({
-                    screenName,
+                    screenName: launchScreenName,
+                    folder,
                     command: instanceParameters.command,
                     record: {
                         serviceId: config.serviceId,
@@ -655,16 +658,21 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                 });
                 await delay(2000);
                 let newScreens = await getScreenState(false);
-                let foundScreen = newScreens.find(x => x.screenName === screenName);
+                let foundScreen = newScreens.find(x => x.screenName === launchScreenName);
                 if (!foundScreen) {
-                    console.error(`Just created screen ${screenName}, but it's not in the list of screens!`);
+                    console.error(`Just created screen ${launchScreenName}, but it's not in the list of screens!`);
                 }
                 let isRunning = foundScreen && await isScreenRunningProcess(foundScreen.pid);
                 if (!isRunning) {
                     let prefix = getTmuxPrefix();
-                    let logs = await runPromise(`${prefix}tmux capture-pane -t ${screenName} -p`);
-                    throw new Error(`${logs}\n\nService ${magenta(screenName)} is not running after starting. Trying again in ${formatTime(MACHINE_RESYNC_INTERVAL)}, or on next change. Last logs above.`);
+                    let logs = await runPromise(`${prefix}tmux capture-pane -t ${launchScreenName} -p`);
+                    throw new Error(`${logs}\n\nService ${magenta(launchScreenName)} is not running after starting. Trying again in ${formatTime(MACHINE_RESYNC_INTERVAL)}, or on next change. Last logs above.`);
+                }
+                // Up and verified, so the old process can go now
+                if (foundScreen) {
+                    screenStateMap.set(launchScreenName, foundScreen);
                 }
+                await takeoverFutureScreen({ canonicalScreenName: screenName, screenNamesUsed, screenStateMap });
                 console.log(green(`Service ${magenta(screenName)} is verified to be running after starting (process ${launchId})`));
                 await syncTimeline(foundScreen?.pid);
 

package/src/deployManager/processManager.ts

@@ -183,9 +183,11 @@ export const runScreenCommand = measureWrap(async function runScreenCommand(conf
     let prefix = getTmuxPrefix();
     let screenName = config.screenName;
 
-    // A launch is ALWAYS a new session, never a new command in the old one. Reusing the session kept the pane, and the pane's pid and start time are what identify the process - so the "new" process was indistinguishable from the one before it and appended to its log. Every path goes through this, including an immediate zero-overlap deploy: a special case for that would be a second flow to get wrong.
+    // A launch is ALWAYS a brand new session. Callers launch into the "-future" name and rename it over the canonical one once the new process is up, so starting a replacement never waits on the old process going away. Nothing is killed here.
+    // A leftover session under this name is from a launch that died before its takeover, so it is dead weight rather than something we are replacing.
     if ((await getScreenState(false)).some(x => x.screenName === screenName)) {
-        await killScreen({ screenName, skipNodeIdRemoval: true });
+        console.log(red(`Removing the leftover session ${screenName} from a launch that never completed`));
+        await runPromise(`${prefix}tmux kill-session -t ${screenName}`);
     }
     await runPromise(`${prefix}tmux new -s ${screenName} -d`);