@travetto/worker 5.0.0 → 5.0.1

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/comm/child.ts#L6) and [ParentCommChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/comm/parent.ts#L10).  Usually [ParentCommChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/comm/parent.ts#L10) indicates it is the owner of the sub process. [ChildCommChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/comm/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/comm/parent.ts#L10) can be destroyed (i.e. killing the subprocess) where a [ChildCommChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/comm/child.ts#L6) can only exit the process, but the channel cannot be destroyed.
+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.

package/__index__.ts

@@ -1,8 +1,5 @@
-export * from './src/comm/channel';
-export * from './src/comm/child';
-export * from './src/comm/parent';
-export * from './src/comm/types';
-export * from './src/support/barrier';
-export * from './src/support/timeout';
-export * from './src/support/error';
+export * from './src/ipc/channel';
+export * from './src/ipc/child';
+export * from './src/ipc/parent';
+export * from './src/ipc/types';
 export * from './src/pool';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/worker",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "description": "Process management utilities, with a focus on inter-process communication",
   "keywords": [
     "exec",
@@ -25,7 +25,7 @@
     "directory": "module/worker"
   },
   "dependencies": {
-    "@travetto/runtime": "^5.0.0",
+    "@travetto/runtime": "^5.0.1",
     "generic-pool": "^3.9.0"
   },
   "travetto": {

package/src/support/barrier.ts

@@ -1,89 +0,0 @@
-import { TimeSpan, Util } from '@travetto/runtime';
-
-import { Timeout } from './timeout';
-
-function canCancel(o: unknown): o is { cancel(): unknown } {
-  return !!o && (typeof o === 'object') && 'cancel' in o && typeof o.cancel === 'function';
-}
-
-/**
- * Build an execution barrier to handle various limitations
- */
-export class Barrier {
-  /**
-   * Listen for an unhandled event, as a promise
-   */
-  static listenForUnhandled(): Promise<unknown> & { cancel?: () => void } {
-    const uncaught = Util.resolvablePromise<Promise<unknown> & { cancel?: () => void }>();
-    const onError = (err: Error): void => { Util.queueMacroTask().then(() => uncaught.reject(err)); };
-    process.on('unhandledRejection', onError).on('uncaughtException', onError);
-    const cancel = (): void => {
-      process.off('unhandledRejection', onError).off('unhandledException', onError);
-      uncaught.resolve(undefined!); // Close the promise
-    };
-    Object.defineProperty(uncaught.promise, 'cancel', { value: cancel });
-    return uncaught.promise;
-  }
-
-  #support: string[] = [];
-  #barriers = new Map<string, Promise<unknown>>([]);
-
-  constructor(
-    timeout?: number | TimeSpan,
-    unhandled?: boolean
-  ) {
-    if (timeout !== undefined) {
-      this.add(new Timeout(timeout).wait(), true);
-    }
-    if (unhandled) {
-      this.add(Barrier.listenForUnhandled());
-    }
-  }
-
-  /**
-   * Add a new barrier
-   */
-  add(p: (() => Promise<unknown>) | Promise<unknown>, support = false): this {
-    if (!('then' in p)) {
-      p = p();
-    }
-    const k = Util.uuid();
-    p = p
-      .finally(() => this.#barriers.delete(k))
-      .catch(err => { this.cleanup(); throw err; });
-
-    if (!support) {
-      p = p.then(() => this.cleanup());
-    } else {
-      this.#support.push(k);
-    }
-
-    this.#barriers.set(k, p);
-    return this;
-  }
-
-  /**
-   * Clean up, and cancel all cancellable barriers
-   */
-  cleanup(): void {
-    for (const k of this.#support) {
-      const el = this.#barriers.get(k);
-      if (canCancel(el)) {
-        el.cancel();
-      }
-    }
-    this.#barriers.clear();
-  }
-
-  /**
-   * Wait for all barriers to clear out
-   */
-  async wait(): Promise<Error | undefined> {
-    let capturedError: Error | undefined;
-    // Wait for all barriers to be satisfied
-    while (this.#barriers.size) {
-      await Promise.race(this.#barriers.values()).catch(err => capturedError ??= err);
-    }
-    return capturedError;
-  }
-}

package/src/support/error.ts

@@ -1,6 +0,0 @@
-import { AppError } from '@travetto/runtime';
-
-/**
- * Represents an execution error
- */
-export class ExecutionError extends AppError { }

package/src/support/timeout.ts

@@ -1,42 +0,0 @@
-import timers from 'node:timers/promises';
-import { TimeSpan, TimeUtil, Util } from '@travetto/runtime';
-import { ExecutionError } from './error';
-
-/**
- * Timeout support, throws self on timeout
- */
-export class Timeout extends ExecutionError {
-
-  #timeout?: AbortController;
-  #resolver = Util.resolvablePromise();
-  #duration: number;
-
-  constructor(duration: number | TimeSpan, op: string = 'Operation') {
-    super(`${op} timed out after ${duration}${typeof duration === 'number' ? 'ms' : ''}`);
-    this.#duration = TimeUtil.asMillis(duration);
-  }
-
-  /**
-   * Stop timeout from firing
-   */
-  cancel(): void {
-    if (this.#timeout) {
-      this.#resolver.resolve();
-      this.#timeout.abort();
-      this.#timeout = undefined;
-    }
-  }
-
-  /**
-   * Wait for timeout as a promise
-   */
-  wait(): Promise<void> {
-    if (!this.#timeout) {
-      this.#timeout = new AbortController();
-      timers.setTimeout(this.#duration, undefined, { ref: false, signal: this.#timeout.signal })
-        .then(() => this.#resolver.reject(this))
-        .catch(() => false);
-    }
-    return this.#resolver.promise;
-  }
-}