@travetto/worker 5.0.15 → 5.0.17

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 ArcSine Technologies
+Copyright (c) 2020 ArcSine Technologies
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -16,7 +16,7 @@ yarn add @travetto/worker
 This module provides the necessary primitives for handling dependent workers.  A worker can be an individual actor or could be a pool of workers. Node provides ipc (inter-process communication) functionality out of the box. This module builds upon that by providing enhanced event management, richer process management, as well as constructs for orchestrating a conversation between two processes.
 
 ## Execution Pools
-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. 
+With respect to managing multiple executions, [WorkPool](https://github.com/travetto/travetto/tree/main/module/worker/src/pool.ts#L34) 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
 To handle communication between processes, [IpcChannel](https://github.com/travetto/travetto/tree/main/module/worker/src/ipc.ts#L9) 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/worker",
-  "version": "5.0.15",
+  "version": "5.0.17",
   "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.13",
+    "@travetto/runtime": "^5.0.15",
     "generic-pool": "^3.9.0"
   },
   "travetto": {

package/src/ipc.ts

@@ -87,8 +87,6 @@ export class IpcChannel<V = unknown> {
           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 { }
     }

package/src/pool.ts

@@ -4,27 +4,29 @@ import { Options, Pool, createPool } from 'generic-pool';
 import { Env, Util, AsyncQueue } from '@travetto/runtime';
 
 type ItrSource<I> = Iterable<I> | AsyncIterable<I>;
+type WorkerExecutor<I, O> = (input: I, idx: number) => Promise<O>;
 
 /**
  * Worker definition
  */
 export interface Worker<I, O = unknown> {
-  active?: boolean;
-  id?: unknown;
+  active: boolean;
+  id: unknown;
   init?(): Promise<unknown>;
-  execute(input: I, idx: number): Promise<O>;
+  execute: WorkerExecutor<I, O>;
   destroy?(): Promise<void>;
   release?(): unknown;
 }
 
-type WorkerInput<I, O> = (() => Worker<I, O>) | ((input: I, inputIdx: number) => Promise<O>);
+type WorkerFactoryInput<I, O = unknown> = Partial<Worker<I, O>> & { execute: WorkerExecutor<I, O> };
+type WorkerInput<I, O> = (() => WorkerFactoryInput<I, O>) | WorkerExecutor<I, O>;
 type WorkPoolConfig<I, O> = Options & {
   onComplete?: (output: O, input: I, finishIdx: number) => void;
   onError?(ev: Error, input: I, finishIdx: number): (unknown | Promise<unknown>);
   shutdown?: AbortSignal;
 };
 
-const isWorkerFactory = <I, O>(o: WorkerInput<I, O>): o is (() => Worker<I, O>) => o.length === 0;
+const isWorkerFactory = <I, O>(o: WorkerInput<I, O>): o is (() => WorkerFactoryInput<I, O>) => o.length === 0;
 
 /**
  * Work pool support
@@ -32,7 +34,7 @@ const isWorkerFactory = <I, O>(o: WorkerInput<I, O>): o is (() => Worker<I, O>)
 export class WorkPool {
 
   static MAX_SIZE = os.availableParallelism();
-  static DEFAULT_SIZE = Math.min(WorkPool.MAX_SIZE, 4);
+  static DEFAULT_SIZE = Math.max(Math.trunc(WorkPool.MAX_SIZE * .75), 4);
 
   /** Build worker pool */
   static #buildPool<I, O>(worker: WorkerInput<I, O>, opts?: WorkPoolConfig<I, O>): Pool<Worker<I, O>> {
@@ -45,13 +47,12 @@ export class WorkPool {
       async create() {
         try {
           pendingAcquires += 1;
-          const res = isWorkerFactory(worker) ? await worker() : { execute: worker };
-          res.id ??= Util.uuid();
-
-          if (res.init) {
-            await res.init();
-          }
-
+          const res: Worker<I, O> = {
+            id: Util.uuid(),
+            active: true,
+            ...isWorkerFactory(worker) ? await worker() : { execute: worker }
+          };
+          await res.init?.();
           return res;
         } finally {
           pendingAcquires -= 1;
@@ -63,7 +64,7 @@ export class WorkPool {
         }
         return x.destroy?.();
       },
-      validate: async (x: Worker<I, O>) => x.active ?? true
+      validate: async (x: Worker<I, O>) => x.active
     }, {
       evictionRunIntervalMillis: 5000,
       ...(opts ?? {}),
@@ -71,7 +72,6 @@ export class WorkPool {
       min: opts?.min ?? 1,
     });
 
-
     // Listen for shutdown
     opts?.shutdown?.addEventListener('abort', async () => {
       while (pendingAcquires) {
@@ -115,7 +115,7 @@ export class WorkPool {
             console.debug('Releasing', { pid: process.pid, worker: worker.id });
           }
           try {
-            if (worker.active ?? true) {
+            if (worker.active) {
               try {
                 await worker.release?.();
               } catch { }