@travetto/worker 5.0.11 → 5.0.13

package/README.md

@@ -19,4 +19,4 @@ This module provides the necessary primitives for handling dependent workers.  A
 With respect to managing multiple executions, [WorkPool](https://github.com/travetto/travetto/tree/main/module/worker/src/pool.ts#L32) is provided to allow for concurrent operation, and processing of jobs concurrently.  To manage the flow of jobs, [AsyncQueue](https://github.com/travetto/travetto/tree/main/module/runtime/src/queue.ts#L6) is used to support a wide range of use cases. [AsyncQueue](https://github.com/travetto/travetto/tree/main/module/runtime/src/queue.ts#L6) allows for manual control of iteration, which is useful for event driven work loads. 
 
 ## IPC Support
-Within the `comm` package, there is support for two primary communication elements: [ChildCommChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/ipc/child.ts#L6) and [ParentCommChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/ipc/parent.ts#L10).  Usually [ParentCommChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/ipc/parent.ts#L10) indicates it is the owner of the sub process. [ChildCommChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/ipc/child.ts#L6) indicates that it has been created/spawned/forked by the parent and will communicate back to it's parent. This generally means that a [ParentCommChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/ipc/parent.ts#L10) can be destroyed (i.e. killing the subprocess) where a [ChildCommChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/ipc/child.ts#L6) can only exit the process, but the channel cannot be destroyed.
+To handle communication between processes, [IpcChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/ipc.ts#L8) is provided. This class abstracts the underlying IPC mechanism and provides a simple interface for sending and receiving messages. It also includes event management capabilities, allowing for easy handling of different message types. By default the class assumes it is running in a child process, but it can also be used in a parent process (by passing in the child process) to communicate with child processes.

package/__index__.ts

@@ -1,5 +1,2 @@
-export * from './src/ipc/channel';
-export * from './src/ipc/child';
-export * from './src/ipc/parent';
-export * from './src/ipc/types';
-export * from './src/pool';
+export * from './src/ipc';
+export * from './src/pool';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/worker",
-  "version": "5.0.11",
+  "version": "5.0.13",
   "description": "Process management utilities, with a focus on inter-process communication",
   "keywords": [
     "exec",

package/src/ipc.ts

@@ -0,0 +1,106 @@
+import { ChildProcess } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+
+import { ShutdownManager, Util } from '@travetto/runtime';
+
+/**
+ * Channel that represents ipc communication
+ */
+export class IpcChannel<V = unknown> {
+
+  #emitter = new EventEmitter();
+  proc: NodeJS.Process | ChildProcess;
+  parentId: number;
+
+  constructor(proc: NodeJS.Process | ChildProcess = process) {
+    this.proc = proc;
+    this.parentId = proc instanceof ChildProcess ? process.pid : process.ppid;
+
+    // Close on shutdown
+    ShutdownManager.onGracefulShutdown(() => this.destroy(), this);
+
+    this.proc.on('message', (ev: { type: string }) => {
+      console.debug('Received', { pid: this.parentId, id: this.id, type: ev.type });
+      this.#emitter.emit(ev.type, ev);
+      this.#emitter.emit('*', ev);
+    });
+  }
+
+  /**
+   * Gets channel unique identifier
+   */
+  get id(): number | undefined {
+    return this.proc.pid;
+  }
+
+  /**
+   * Determines if channel is active
+   */
+  get active(): boolean {
+    return (this.proc instanceof ChildProcess) ? !this.proc.killed : !!this.proc.connected;
+  }
+
+  /**
+   * Send data to the parent
+   */
+  send(eventType: string, data?: Record<string, unknown>): void {
+    console.debug('Sending', { pid: this.parentId, id: this.id, eventType });
+    if (!this.active) {
+      throw new Error('Cannot send message to inactive process');
+    } else if (this.proc.send && this.proc.connected) {
+      this.proc.send({ ...(data ?? {}), type: eventType }, (err) => err && console.error(err));
+    } else {
+      throw new Error('this.proc.send was not defined');
+    }
+  }
+
+  /**
+   * Listen for a specific message type
+   */
+  on(eventType: string, callback: (e: V & { type: string }) => unknown | void): () => void {
+    this.#emitter.on(eventType, callback);
+    return () => this.off(eventType, callback);
+  }
+
+  /**
+   * Remove event listener
+   */
+  off(eventType: string, callback: (e: V & { type: string }) => unknown | void): void {
+    this.#emitter.off(eventType, callback);
+  }
+
+  /**
+   * Listen for a specific message type, once
+   */
+  once(eventType: string): Promise<V & { type: string }> {
+    return new Promise(res => this.#emitter.once(eventType, res));
+  }
+
+  /**
+   * Destroy self
+   */
+  async destroy(): Promise<void> {
+    if (this.active) {
+      try {
+        console.debug('Killing', { pid: this.parentId, id: this.id });
+        if (this.proc instanceof ChildProcess) {
+          const complete = new Promise<void>(r => this.proc.on('close', r));
+          this.proc.kill();
+          await Promise.race([complete, Util.nonBlockingTimeout(1000)]);
+        } else {
+          this.proc.disconnect();
+        }
+      } catch { }
+    }
+    this.release();
+  }
+
+  /**
+   * Remove all listeners, but do not destroy
+   */
+  release(): void {
+    console.debug('Released', { pid: this.parentId, id: this.id });
+    this.proc.removeAllListeners();
+    this.#emitter.removeAllListeners();
+  }
+}

package/src/ipc/channel.ts

@@ -1,107 +0,0 @@
-import { ChildProcess } from 'node:child_process';
-import { EventEmitter } from 'node:events';
-
-/**
- * Channel that represents communication between parent/child
- */
-export class ProcessCommChannel<T extends NodeJS.Process | ChildProcess, V = unknown, U extends { type: string } = V & { type: string }> {
-
-  #proc: T | undefined;
-  #emitter = new EventEmitter();
-
-  constructor(proc: T) {
-    this.#proc = proc;
-    console.debug('Constructed Execution', { pid: this.id });
-    this.#proc.on('message', this.#handleMessage.bind(this));
-  }
-
-  get #parentId(): number {
-    return process.pid;
-  }
-
-  #handleMessage(ev: { type: string }): void {
-    console.debug('Received', { pid: this.#parentId, id: this.id, type: ev.type });
-    this.#emitter.emit(ev.type, ev);
-    this.#emitter.emit('*', ev);
-  }
-
-  get proc(): T | undefined {
-    return this.#proc;
-  }
-
-  set proc(proc: T | undefined) {
-    this.#proc = proc;
-  }
-
-  /**
-   * Gets channel unique identifier
-   */
-  get id(): number | undefined {
-    return this.#proc && this.#proc.pid;
-  }
-
-  /**
-   * Determines if channel is active
-   */
-  get active(): boolean {
-    return !!this.#proc;
-  }
-
-  /**
-   * Send data to the parent
-   */
-  send(eventType: string, data?: Record<string, unknown>): void {
-    console.debug('Sending', { pid: this.#parentId, id: this.id, eventType });
-    if (!this.#proc) {
-      throw new Error('this.proc was not defined');
-    } else if (this.#proc.send && this.#proc.connected) {
-      this.#proc.send({ ...(data ?? {}), type: eventType }, (err) => err && console.error(err));
-    } else {
-      throw new Error('this.proc.send was not defined');
-    }
-  }
-
-  /**
-   * Listen for a specific message type
-   */
-  on(eventType: string, callback: (e: U) => unknown | void): () => void {
-    this.#emitter.on(eventType, callback);
-    return () => this.off(eventType, callback);
-  }
-
-  /**
-   * Remove event listener
-   */
-  off(eventType: string, callback: (e: U) => unknown | void): void {
-    this.#emitter.off(eventType, callback);
-  }
-
-  /**
-   * Listen for a specific message type, once
-   */
-  once(eventType: string): Promise<U> {
-    return new Promise<U>(res => this.#emitter.once(eventType, res));
-  }
-
-  /**
-   * Destroy self
-   */
-  async destroy(): Promise<void> {
-    if (this.#proc) {
-      console.debug('Killing', { pid: this.#parentId, id: this.id });
-      if (!('argv' in this.#proc)) {
-        this.#proc.kill();
-      }
-      this.#proc = undefined;
-    }
-    this.release();
-  }
-
-  /**
-   * Remove all listeners, but do not destroy
-   */
-  release(): void {
-    console.debug('Released', { pid: this.#parentId, id: this.id });
-    this.#emitter.removeAllListeners();
-  }
-}

package/src/ipc/child.ts

@@ -1,10 +0,0 @@
-import { ProcessCommChannel } from './channel';
-
-/**
- * Child channel, communicates only to parent
- */
-export class ChildCommChannel<U = unknown> extends ProcessCommChannel<NodeJS.Process, U> {
-  constructor() {
-    super(process);
-  }
-}

package/src/ipc/parent.ts

@@ -1,28 +0,0 @@
-import { ChildProcess } from 'node:child_process';
-
-import { ShutdownManager } from '@travetto/runtime';
-
-import { ProcessCommChannel } from './channel';
-
-/**
- * Parent channel
- */
-export class ParentCommChannel<U = unknown> extends ProcessCommChannel<ChildProcess, U> {
-
-  #complete: Promise<void>;
-
-  constructor(proc: ChildProcess) {
-    super(proc);
-    ShutdownManager.onGracefulShutdown(() => this.destroy(), this);
-    this.#complete = new Promise<void>(r => proc.on('close', r)).finally(() => { this.proc = undefined; });
-  }
-
-  /**
-   * Kill self and child
-   */
-  override async destroy(): Promise<void> {
-    const res = super.destroy();
-    await this.#complete;
-    return await res;
-  }
-}

package/src/ipc/types.ts

@@ -1,9 +0,0 @@
-/**
- * Process status
- */
-export type Status = 'init' | 'release' | 'destroy';
-
-/**
- * Listen for changes in status
- */
-export type StatusChangeHandler = (status: Status) => unknown;