querysub 0.572.0 → 0.573.0

package/package.json

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

@@ -221,6 +221,8 @@ let launchesPerService = new Map<string, number>();
 let lastLaunchedTimePerService = new Map<string, number>();
 
 const LAUNCH_VERIFY_DELAY = 2000;
+// How far a re-read start time may drift from the recorded one and still be the same process. Well under any interval a pid could be reused in, and wide enough for sources that only resolve to the second.
+const START_TIME_TOLERANCE = timeInSecond * 5;
 
 /** Every instance of every service that belongs to this machine, with its config already resolved for that instance - the command has this entry's template variables substituted, and a version with no entry at this index is marked as deploying nothing here. */
 function getMachineInstances(configs: ServiceConfig[], machineId: string): { config: ServiceConfig; index: number }[] {
@@ -497,7 +499,8 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
     await syncProcessRecords({
         isAlive: async record => {
             if (!running.has(record.pid)) return false;
-            return await getProcessStartTime(record.pid) === record.startTime;
+            // Compared with a tolerance rather than exactly: the sources we read a start time from only resolve to the second, and they do not all round the same way, so an exact match would call a live process dead
+            return Math.abs(await getProcessStartTime(record.pid) - record.startTime) <= START_TIME_TOLERANCE;
         },
         now: Date.now(),
     });

package/src/deployManager/processLogs.ts

@@ -99,6 +99,11 @@ export async function readProcessRecord(folder: string, pid: string, startTime:
     return JSON.parse(await fs.promises.readFile(file, "utf8")) as ProcessRecord;
 }
 
+/** The live record for a pid in this folder. The pid is what identifies a process, so a start time that reads back a second off - the sources only resolve to the second - must not make us miss the record and write a duplicate. */
+export async function findProcessRecordByPid(folder: string, pid: string): Promise<ProcessRecord | undefined> {
+    return (await readFolderRecords(folder)).find(x => x.pid === pid && x.deadTime === undefined);
+}
+
 export async function writeProcessRecord(record: ProcessRecord): Promise<void> {
     await fs.promises.mkdir(path.join(record.folder, PROCESS_FOLDER), { recursive: true });
     await fs.promises.writeFile(getRecordPath(record.folder, record.pid, record.startTime), JSON.stringify(record));

package/src/deployManager/processManager.ts

@@ -13,7 +13,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, getLogPipeScript, getLogTailScript, getProcessLogPath, getPipeScriptPath, getTailScriptPath, readProcessRecord, writeProcessRecord } from "./processLogs";
+import { ProcessRecord, getLogPipeScript, getLogTailScript, getProcessLogPath, getPipeScriptPath, getTailScriptPath, findProcessRecordByPid, writeProcessRecord } from "./processLogs";
 import { setPreciseTimeout } from "../misc";
 
 // 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.
@@ -163,11 +163,23 @@ const getAllParentPids = measureWrap(async function getAllParentPids(): Promise<
     let obj = textTableLineToObj(table) as { PID: string; PPID: string }[];
     return new Set(obj.map(x => x.PPID));
 });
-/** The start time the OS reports for a pid, as an epoch time in milliseconds like every other time we store. Asked of the machine rather than remembered, so it stays true across our restarts and catches a reused pid. Returns 0 when the process is gone. */
+/** The start time the OS reports for a pid, as an epoch time in milliseconds like every other time we store. Asked of the machine rather than remembered, so it stays true across our restarts and catches a reused pid. Returns 0 when the process is gone, or when neither source can answer. */
 export const getProcessStartTime = measureWrap(async function getProcessStartTime(pid: string): Promise<number> {
-    // ps only resolves to the second, so this is second-accurate - which is plenty to tell two processes on the same pid apart
-    let started = await runPromise(`date -d "$(ps -o lstart= -p ${pid})" +%s`, { quiet: true });
-    return (parseInt(started.trim()) || 0) * 1000;
+    // /proc/<pid> is created when the process is, so its ctime IS the start time - no date parsing, and nothing to get wrong about locales or ps output formats
+    try {
+        let started = await runPromise(`stat -c %Y /proc/${pid}`, { quiet: true });
+        let seconds = parseInt(started.trim()) || 0;
+        if (seconds) return seconds * 1000;
+    } catch {
+        // No procfs (or the process is gone), so fall through to ps
+    }
+    try {
+        // Second-accurate, which is plenty to tell two processes on the same pid apart
+        let started = await runPromise(`date -d "$(ps -o lstart= -p ${pid})" +%s`, { quiet: true });
+        return (parseInt(started.trim()) || 0) * 1000;
+    } catch {
+        return 0;
+    }
 });
 
 export const isScreenRunningProcess = measureWrap(async function isScreenRunningProcess(pid: string): Promise<boolean> {
@@ -263,9 +275,9 @@ export async function ensureProcessRecord(config: {
     record: Omit<ProcessRecord, "pid" | "startTime" | "folder" | "screenName">;
 }): Promise<void> {
     let pid = config.panePid;
+    // A start time we could not read is still recorded: a process with no record at all is invisible everywhere, which is worse than one whose identity is only its pid
     let startTime = await getProcessStartTime(pid);
-    if (!startTime) return;
-    let existing = await readProcessRecord(config.folder, pid, startTime);
+    let existing = await findProcessRecordByPid(config.folder, pid);
     if (existing) {
         // A takeover renames the session, so the record follows the name it now runs under
         if (existing.screenName === config.screenName) return;
@@ -340,9 +352,7 @@ export async function takeoverScreenLocked(config: {
 
 /** Points a process's record at the session name it now runs under. The pid is the key, so this reads exactly one file. */
 async function renameProcessScreen(config: { folder: string; panePid: string; screenName: string }): Promise<void> {
-    let startTime = await getProcessStartTime(config.panePid);
-    if (!startTime) return;
-    let record = await readProcessRecord(config.folder, config.panePid, startTime);
+    let record = await findProcessRecordByPid(config.folder, config.panePid);
     if (!record || record.screenName === config.screenName) return;
     await writeProcessRecord({ ...record, screenName: config.screenName });
 }