querysub 0.211.0 → 0.213.0

package/package.json

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

@@ -18,7 +18,7 @@ import os from "os";
 import fs from "fs";
 import { lazy } from "socket-function/src/caching";
 import { setGitRef } from "../4-deploy/git";
-import { blue, magenta } from "socket-function/src/formatting/logColors";
+import { blue, green, magenta } from "socket-function/src/formatting/logColors";
 import { shutdown } from "../diagnostics/periodic";
 
 const getLiveMachineInfo = measureWrap(async function getLiveMachineInfo() {
@@ -51,20 +51,21 @@ const getTmuxPrefix = lazy(() => {
     }
     return "";
 });
-function textTableLineToObj(text: string): Record<string, string> {
+function textTableLineToObj(text: string): Record<string, string>[] {
     /*
       PID    PPID    PGID     WINPID   TTY         UID    STIME COMMAND
      1312    1284    1312      56996  pty2      197609 09:24:47 /usr/bin/bash
+     1313    1284    1313      56997  pty3      197609 09:24:48 /usr/bin/vim
     =>
-    { PID: "1312", PPID: "1284", ...}
+    [{ PID: "1312", PPID: "1284", ...}, { PID: "1313", PPID: "1284", ...}]
     */
     let lines = text.trim().split("\n").filter(line => line.trim().length > 0);
     if (lines.length < 2) {
-        return {};
+        return [];
     }
 
     let headerLine = lines[0];
-    let dataLine = lines[1];
+    let dataLines = lines.slice(1);
 
     // Parse column positions from header
     let columns: { name: string; start: number; end: number }[] = [];
@@ -83,55 +84,70 @@ function textTableLineToObj(text: string): Record<string, string> {
         currentPos = start + word.length;
     }
 
-    // Extract values from data line
-    let result: Record<string, string> = {};
-    for (let column of columns) {
-        let value = dataLine.substring(column.start, column.end).trim();
-        result[column.name] = value;
+    // Extract values from all data lines
+    let results: Record<string, string>[] = [];
+    for (let dataLine of dataLines) {
+        let result: Record<string, string> = {};
+        for (let column of columns) {
+            let value = dataLine.substring(column.start, column.end).trim();
+            result[column.name] = value;
+        }
+        results.push(result);
     }
 
-    return result;
+    return results;
 }
-async function getTmuxProcessInfo(pid: string) {
+async function getLinuxProcessInfo(pid: string) {
     try {
-        let psInfo = await runPromise(`ps -p ${pid}`);
-        let obj = textTableLineToObj(psInfo) as { PPID: string; CMD: string };
+        let extraArgs = os.platform() !== "win32" && " -o ppid,cmd" || "";
+        let psInfo = await runPromise(`ps -p ${pid}${extraArgs}`);
+        let results = textTableLineToObj(psInfo);
+        let obj = results[0] as { PPID: string; CMD: string };
         return obj;
     } catch (e: any) {
         console.warn(`Error getting tmux process info for ${pid}: ${e.stack}`);
         return undefined;
     }
 }
-async function getTmuxPPID(pid: string) {
-    try {
-        let psInfo = await runPromise(`ps -p ${pid}`);
-        let obj = textTableLineToObj(psInfo) as { PPID: string };
-        return obj.PPID;
-    } catch (e: any) {
-        console.warn(`Error getting ppid for ${pid}: ${e.stack}`);
-        return "0";
+const getLinuxChildPids = measureWrap(async function getLinuxChildPids(pid: string): Promise<{ PID: string; PPID: string; CMD: string }[]> {
+    let prefix = getTmuxPrefix();
+    if (os.platform() === "win32") {
+        let table = await runPromise(`${prefix}ps`);
+        let obj = textTableLineToObj(table) as { PID: string; PPID: string; CMD: string }[];
+        return obj.filter(x => x.PPID === pid);
+    } else {
+        let table = await runPromise(`ps -eo pid,ppid,cmd`);
+        let obj = textTableLineToObj(table) as { PPID: string; PID: string; CMD: string }[];
+        return obj.filter(x => x.PPID === pid);
     }
-}
+});
 const isScreenRunningProcess = measureWrap(async function isScreenRunningProcess(pid: string): Promise<boolean> {
     try {
-        let ppid = (await getTmuxProcessInfo(pid))?.PPID;
-        if (!ppid) return false;
-        let parentCommand = (await getTmuxProcessInfo(ppid))?.CMD;
-        let execName = parentCommand?.split("/").at(-1);
-        console.log(`Screen for pid ${pid} is running ${execName}`);
-        return execName !== "tmux";
+        let childPids = await getLinuxChildPids(pid);
+        let bashPid = childPids.find(x => x.CMD.includes("bash"));
+        if (!bashPid) {
+            console.error(`Screen pid ${pid} isn't even running bash? What? We can't check if it's running the process or not, so returning true, which disables crash detection... is running ${JSON.stringify(childPids)}`);
+            return true;
+        }
+        let bashChildPids = await getLinuxChildPids(bashPid.PID);
+        for (let childPid of bashChildPids) {
+            console.log(`Screen pid ${pid} is running ${childPid.CMD}`);
+            return true;
+        }
+        return false;
     } catch (e: any) {
         console.warn(`Error checking if screen is running for ${pid}: ${e.stack}`);
         return false;
     }
 });
-const getScreenState = measureWrap(async function getScreenState(): Promise<{
+const getScreenState = measureWrap(async function getScreenState(populateIsProcessRunning: boolean = true): Promise<{
     screenName: string;
     isProcessRunning: boolean;
     pid: string;
 }[]> {
     const prefix = getTmuxPrefix();
     const delimit = "::::";
+    // tmux list-panes -a -F "#{session_name}::::#{pane_pid}"
     let screenList = (await runPromise(`${prefix}tmux list-panes -a -F "#{session_name}${delimit}#{pane_pid}"`))
         .split("\n")
         .filter(x => x.includes(delimit))
@@ -143,9 +159,11 @@ const getScreenState = measureWrap(async function getScreenState(): Promise<{
         .filter(x => x.screenName.endsWith(SCREEN_SUFFIX))
         ;
 
-    await Promise.all(screenList.map(async x => {
-        x.isProcessRunning = await isScreenRunningProcess(x.pid);
-    }));
+    if (populateIsProcessRunning) {
+        await Promise.all(screenList.map(async x => {
+            x.isProcessRunning = await isScreenRunningProcess(x.pid);
+        }));
+    }
 
     return screenList;
 });
@@ -241,7 +259,10 @@ const resyncServices = runInSerial(measureWrap(async function resyncServices() {
                 let sameParameters = prevParameters === newParametersString;
                 let screenIsRunning = screenStateMap.get(screenName)?.isProcessRunning;
 
-                if (sameParameters && screenIsRunning) continue;
+                if (sameParameters && screenIsRunning) {
+                    console.log(green(`Verified ${magenta(config.serviceId)} is running`));
+                    continue;
+                }
 
                 console.log(`Resyncing service ${magenta(config.serviceId)}`);
 
@@ -252,20 +273,18 @@ const resyncServices = runInSerial(measureWrap(async function resyncServices() {
                     command: config.parameters.command,
                 });
                 await delay(2000);
-                let newScreens = await getScreenState();
+                let newScreens = await getScreenState(false);
                 let foundScreen = newScreens.find(x => x.screenName === screenName);
                 if (!foundScreen) {
                     console.error(`Just created screen ${screenName}, but it's not in the list of screens!`);
                 }
                 let isRunning = foundScreen && await isScreenRunningProcess(foundScreen.pid);
-                if (!isRunning) {
-                    console.error(`Screen ${screenName} is not running, but it's in the list of screens`);
-                }
                 if (!isRunning) {
                     let prefix = getTmuxPrefix();
                     let logs = await runPromise(`${prefix}tmux capture-pane -t ${screenName} -p`);
                     throw new Error(`${logs}\n\nService ${magenta(config.serviceId)} is not running after starting. Trying again in ${formatTime(MACHINE_RESYNC_INTERVAL)}, or on next change. Last logs above.`);
                 }
+                console.log(green(`Service ${magenta(config.serviceId)} is verified to be running after starting.`));
 
                 machineInfo.services[config.serviceId] = {
                     lastLaunchedTime: Date.now(),

package/src/deployManager/spec.txt

@@ -21,6 +21,7 @@
 
 5) OH! Also setup swap usage on the machine, as it isn't by default often?
 
+6) Test again on a new server... I think something might be blocking on user input? Hmm...
 
 
 

package/src/functional/runCommand.ts

@@ -1,6 +1,6 @@
 import child_process from "child_process";
 import path from "path";
-import { red } from "socket-function/src/formatting/logColors";
+import { blue, red } from "socket-function/src/formatting/logColors";
 
 export const runAsync = runPromise;
 export async function runPromise(command: string, config?: {
@@ -10,6 +10,7 @@ export async function runPromise(command: string, config?: {
     nothrow?: boolean;
 }) {
     return new Promise<string>((resolve, reject) => {
+        console.log(">" + blue(command));
         const childProc = child_process.spawn(command, {
             shell: true,
             cwd: config?.cwd,