@dxos/phoenix 0.1.58-main.88ec9da → 0.1.58-main.935caa2

package/src/watchdog.ts

@@ -3,31 +3,48 @@
 //
 
 import { ChildProcessWithoutNullStreams, spawn } from 'node:child_process';
-import { existsSync, unlinkSync, writeFileSync } from 'node:fs';
+import { writeFileSync } from 'node:fs';
 import { FileHandle } from 'node:fs/promises';
+import { promisify } from 'node:util';
+import psTree from 'ps-tree';
 
 import { synchronized } from '@dxos/async';
+import { Context } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
+import { LockFile } from '@dxos/lock-file';
 import { log } from '@dxos/log';
 
-import { waitForPidDeletion, waitForPidFileBeingFilledWithInfo } from './utils';
+import { waitForLockAcquisition, waitForLockRelease } from './utils';
+
+export type DaemonInfo = {
+  pid: number;
+  command: string;
+  args: string[];
+  cwd: string;
+  timestamp: number;
+};
 
 export type ProcessInfo = WatchDogParams & {
   pid?: number;
-  started?: number;
+  timestamp?: number;
   restarts?: number;
   running?: boolean;
 };
 
-export type WatchDogParams = {
-  profile?: string; // Human readable process identifier
-  pidFile: string; // Path to PID file
+export type Lock = {
+  lockFile: string; // Path to lock file
+};
 
+export type Logs = {
   //
   // Log files and associated logging options for this instance
   //
   logFile: string; // Path to log output all logs
   errFile: string; // Path to log output from child stderr
+};
+
+export type ChildParams = {
+  uid: string; // Unique identifier for this instance
 
   //
   // Basic configuration options
@@ -39,7 +56,7 @@ export type WatchDogParams = {
   // Command to spawn as well as options and other vars
   // (env, cwd, etc) to pass along
   //
-  command: string; // Binary to run (default: 'node')
+  command?: string; // Binary to run (default: 'node')
   args?: string[] | undefined; // Additional arguments to pass to the script,
 
   //
@@ -51,19 +68,35 @@ export type WatchDogParams = {
   shell?: boolean | undefined;
 };
 
+export type WatchDogParams = ChildParams & Lock & Logs;
+
 export class WatchDog {
   private _lock?: FileHandle;
   private _child?: ChildProcessWithoutNullStreams;
   private _restarts = 0;
+  private _processCtx?: Context;
 
   constructor(private readonly _params: WatchDogParams) {}
 
   @synchronized
   async start() {
+    await this._acquireLock();
+    this._log('Lock acquired.');
     const { cwd, shell, env, command, args } = { cwd: process.cwd(), ...this._params };
+    invariant(command, 'Command is not defined.');
 
-    this._log(`Spawning process \`\`\`${command} ${args?.join(' ')}\`\`\``);
+    this._log(`Spawning process ${command} ${args?.join(' ')}`);
     this._child = spawn(command, args, { cwd, shell, env, stdio: 'pipe' });
+    this._processCtx = new Context();
+
+    const childInfo: ProcessInfo = {
+      pid: process.pid,
+      timestamp: Date.now(),
+      restarts: this._restarts,
+      ...this._params,
+    };
+
+    writeFileSync(this._params.lockFile, JSON.stringify(childInfo, undefined, 2), { encoding: 'utf-8' });
 
     this._child.stdout.on('data', (data: Uint8Array) => {
       this._log(String(data));
@@ -71,27 +104,44 @@ export class WatchDog {
     this._child.stderr.on('data', (data: Uint8Array) => {
       this._err(data);
     });
-    this._child.on('close', async (code: number, signal: number | NodeJS.Signals) => {
-      if (code && code !== 0 && signal !== 'SIGINT' && signal !== 'SIGKILL') {
-        this._err(`Died unexpectedly with exit code ${code} (signal: ${signal}).`);
-        await this.restart();
-      }
+
+    // Setup restart handler.
+    {
+      const restartHandler = async (code: number, signal: number | NodeJS.Signals) => {
+        if (code && code !== 0) {
+          this._err(`Died unexpectedly with exit code ${code} (signal: ${signal}).`);
+          await this.restart();
+        }
+      };
+
+      this._child.on('close', restartHandler);
+
+      // We should unsubscribe from the event when the process is killed by us to not try to restart it.
+      this._processCtx.onDispose(() => {
+        this._child!.off('close', restartHandler);
+      });
+    }
+
+    this._child.on('close', (code: number, signal: number | NodeJS.Signals) => {
       this._log(`Stopped with exit code ${code} (signal: ${signal}).`);
-      if (existsSync(this._params.pidFile)) {
-        unlinkSync(this._params.pidFile);
-      }
     });
 
-    const childInfo: ProcessInfo = {
-      pid: this._child.pid,
-      started: Date.now(),
-      restarts: this._restarts,
-      ...this._params,
-    };
+    invariant(this._child.pid, 'Child process has no pid.');
+    this._log(`Started with pid ${this._child.pid}.`);
+  }
 
-    writeFileSync(this._params.pidFile, JSON.stringify(childInfo, undefined, 2), { encoding: 'utf-8' });
+  /**
+   * Sends SIGINT to the child process and the tree it spawned (if `killTree` param is `true`).
+   */
+  @synchronized
+  async stop() {
+    if (!this._child) {
+      return;
+    }
+
+    await this._killWithSignal('SIGKILL');
 
-    await waitForPidFileBeingFilledWithInfo(this._params.pidFile);
+    await this._releaseLock();
   }
 
   /**
@@ -105,11 +155,7 @@ export class WatchDog {
 
     await this._killWithSignal('SIGKILL');
 
-    if (existsSync(this._params.pidFile)) {
-      unlinkSync(this._params.pidFile);
-    }
-
-    await waitForPidDeletion(this._params.pidFile);
+    await this._releaseLock();
   }
 
   async restart() {
@@ -124,11 +170,45 @@ export class WatchDog {
   }
 
   async _killWithSignal(signal: number | NodeJS.Signals) {
+    invariant(this._processCtx, 'Process context is not defined.');
+    await this._processCtx.dispose();
+
+    // Kill child process tree.
+    if (this._params.killTree) {
+      if (process.platform !== 'win32') {
+        invariant(this._child?.pid, 'Child process has no pid.');
+        const children = await promisify(psTree)(this._child.pid);
+        children
+          .map((p) => p.PID)
+          .forEach((tpid) => {
+            invariant(tpid, 'Process id is not defined.');
+            process.kill(Number(tpid), signal);
+          });
+      }
+    }
+
     invariant(this._child?.pid, 'Child process has no pid.');
     this._child.kill(signal);
     this._child = undefined;
   }
 
+  private async _acquireLock() {
+    if (await LockFile.isLocked(this._params.lockFile)) {
+      throw new Error('Lock file is already locked.');
+    }
+    this._lock = await LockFile.acquire(this._params.lockFile);
+    await waitForLockAcquisition(this._params.lockFile);
+  }
+
+  private async _releaseLock() {
+    invariant(this._lock, 'Lock is not defined.');
+
+    await LockFile.release(this._lock);
+    await waitForLockRelease(this._params.lockFile);
+
+    this._lock = undefined;
+  }
+
   private _log(message: string | Uint8Array) {
     writeFileSync(this._params.logFile, message + '\n', {
       flag: 'a+',

package/dist/types/src/phoenix.d.ts

@@ -1,16 +0,0 @@
-import { ProcessInfo, WatchDogParams } from './watchdog';
-/**
- * Utils to start/stop detached process with errors and logs handling.
- */
-export declare class Phoenix {
-    /**
-     * Starts detached watchdog process which starts and monitors selected command.
-     */
-    static start(params: WatchDogParams): Promise<ProcessInfo>;
-    /**
-     * Stops detached watchdog process by PID info written down in PID file.
-     */
-    static stop(pidFile: string, force?: boolean): Promise<void>;
-    static info(pidFile: string): ProcessInfo;
-}
-//# sourceMappingURL=phoenix.d.ts.map

package/dist/types/src/phoenix.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"phoenix.d.ts","sourceRoot":"","sources":["../../../src/phoenix.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEzD;;GAEG;AACH,qBAAa,OAAO;IAClB;;OAEG;WACU,KAAK,CAAC,MAAM,EAAE,cAAc;IAyCzC;;OAEG;WACU,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,UAAQ;IAwBhD,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW;CAG1C"}

package/dist/types/src/phoenix.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=phoenix.test.d.ts.map

package/dist/types/src/phoenix.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"phoenix.test.d.ts","sourceRoot":"","sources":["../../../src/phoenix.test.ts"],"names":[],"mappings":""}

package/src/phoenix.ts

@@ -1,94 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { fork } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import pkgUp from 'pkg-up';
-
-import { invariant } from '@dxos/invariant';
-import { log } from '@dxos/log';
-
-import { waitForPidDeletion, waitForPidFileBeingFilledWithInfo } from './utils';
-import { ProcessInfo, WatchDogParams } from './watchdog';
-
-/**
- * Utils to start/stop detached process with errors and logs handling.
- */
-export class Phoenix {
-  /**
-   * Starts detached watchdog process which starts and monitors selected command.
-   */
-  static async start(params: WatchDogParams) {
-    {
-      // Clear stale pid file.
-      if (existsSync(params.pidFile)) {
-        await Phoenix.stop(params.pidFile);
-      }
-
-      await waitForPidDeletion(params.pidFile);
-    }
-
-    {
-      // Create log folders.
-      [params.logFile, params.errFile, params.pidFile].forEach((filename) => {
-        if (!existsSync(filename)) {
-          mkdirSync(dirname(filename), { recursive: true });
-          writeFileSync(filename, '', { encoding: 'utf-8' });
-        }
-      });
-    }
-
-    const watchdogPath = join(dirname(pkgUp.sync({ cwd: __dirname })!), 'bin', 'watchdog');
-
-    const watchDog = fork(watchdogPath, [JSON.stringify(params)], {
-      detached: true,
-      cwd: __dirname,
-    });
-
-    watchDog.on('exit', (code, signal) => {
-      if (code && code !== 0) {
-        log.error('Monitor died unexpectedly', { code, signal });
-      }
-    });
-
-    await waitForPidFileBeingFilledWithInfo(params.pidFile);
-
-    watchDog.disconnect();
-    watchDog.unref();
-
-    return Phoenix.info(params.pidFile);
-  }
-
-  /**
-   * Stops detached watchdog process by PID info written down in PID file.
-   */
-  static async stop(pidFile: string, force = false) {
-    if (!existsSync(pidFile)) {
-      throw new Error('PID file does not exist');
-    }
-    const fileContent = readFileSync(pidFile, { encoding: 'utf-8' });
-    if (!fileContent.includes('pid')) {
-      throw new Error('Invalid PID file content');
-    }
-
-    const { pid } = JSON.parse(fileContent);
-    const signal: NodeJS.Signals = force ? 'SIGKILL' : 'SIGINT';
-    try {
-      process.kill(pid, signal);
-    } catch (err) {
-      invariant(err instanceof Error, 'Invalid error type');
-      if (err.message.includes('ESRCH') || err.name.includes('ESRCH')) {
-        // Process is already dead.
-        unlinkSync(pidFile);
-      } else {
-        throw err;
-      }
-    }
-  }
-
-  static info(pidFile: string): ProcessInfo {
-    return JSON.parse(readFileSync(pidFile, { encoding: 'utf-8' }));
-  }
-}