somewhat functional daemon

1 files changed, 32 insertions, 17 deletions

diff --git a/src/server/ProcessManager.ts b/src/server/ProcessManager.ts
index 2237f9e1b..671f0a234 100644
--- a/src/server/ProcessManager.ts
+++ b/src/server/ProcessManager.ts
@@ -1,7 +1,9 @@
-import { writeFileSync, unlinkSync, existsSync, mkdirSync } from "fs";
-import { pathFromRoot, log_execution, spawn_detached_process } from './ActionUtilities';
-import { resolve } from "path";
-import { red, yellow } from "colors";
+import { existsSync, mkdirSync, createWriteStream } from "fs";
+import { pathFromRoot, log_execution } from './ActionUtilities';
+import { red, green } from "colors";
+import rimraf = require("rimraf");
+import { ChildProcess, spawn } from "child_process";
+import { Stream } from "stream";
 
 const daemonPath = pathFromRoot("./src/server/daemon/persistence_daemon.ts");
 
@@ -9,22 +11,33 @@ export namespace ProcessManager {
 
     export async function initialize() {
         const logPath = pathFromRoot("./logs");
-        const filePath = resolve(logPath, "./server_pids.txt");
-        const exists = existsSync(logPath);
-        if (exists) {
-            unlinkSync(filePath);
-        } else {
-            mkdirSync(logPath);
+        if (existsSync(logPath)) {
+            if (!process.env.SPAWNED) {
+                await new Promise<any>(resolve => rimraf(logPath, resolve));
+            }
         }
-        const { pid } = process;
-        if (process.env.SPAWNED === "true") {
-            writeFileSync(filePath, `${pid} created at ${new Date().toUTCString()}\n`);
+        mkdirSync(logPath);
+    }
+
+    function generate_log_name(command: string, args?: readonly string[]) {
+        return pathFromRoot(`./logs/${command}-${args?.length}-${new Date().toUTCString()}.log`);
+    }
+
+    export type Sink = "pipe" | "ipc" | "ignore" | "inherit" | Stream | number | null | undefined;
+
+    export async function spawn_detached(command: string, args?: readonly string[], out?: Sink): Promise<ChildProcess> {
+        if (!out) {
+            const logStream = createWriteStream(generate_log_name(command, args));
+            out = await new Promise<number>(resolve => logStream.on("open", resolve));
         }
+        const child = spawn(command, args, { detached: true, stdio: ["ignore", out, out] });
+        child.unref();
+        return child;
     }
 
     let daemonInitialized = false;
     export async function trySpawnDaemon() {
-        if (!daemonInitialized) {
+        if (!process.env.SPAWNED && !daemonInitialized) {
             daemonInitialized = true;
             await log_execution({
                 startMessage: "\ninitializing persistence daemon",
@@ -32,13 +45,15 @@ export namespace ProcessManager {
                     const success = error === null && result !== undefined;
                     if (!success) {
                         console.log(red("failed to initialize the persistance daemon"));
+                        console.log(error);
                         process.exit(0);
                     }
-                    return "persistence daemon process closed";
+                    return "failsafe daemon process successfully spawned";
                 },
-                action: () => spawn_detached_process("npx ts-node", [daemonPath]),
-                color: yellow
+                action: () => spawn_detached('npx', ['ts-node', daemonPath], process.stdout),
+                color: green
             });
+            console.log();
         }
     }