querysub 0.558.0 → 0.559.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.558.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/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();