querysub 0.210.0 → 0.212.0

package/package.json

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

@@ -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,43 +84,57 @@ 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...`);
+            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;
@@ -128,9 +143,11 @@ const isScreenRunningProcess = measureWrap(async function isScreenRunningProcess
 const getScreenState = measureWrap(async function getScreenState(): 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))
@@ -251,7 +268,12 @@ const resyncServices = runInSerial(measureWrap(async function resyncServices() {
                     command: config.parameters.command,
                 });
                 await delay(2000);
-                let isRunning = await isScreenRunningProcess(screenName);
+                let newScreens = await getScreenState();
+                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) {
                     let prefix = getTmuxPrefix();
                     let logs = await runPromise(`${prefix}tmux capture-pane -t ${screenName} -p`);

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,