@travetto/worker 7.0.0-rc.1 → 7.0.0-rc.3

package/__index__.ts

@@ -1,2 +1,2 @@
 export * from './src/ipc.ts';
-export * from './src/pool.ts';
+export * from './src/pool.ts';

package/package.json

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

package/src/ipc.ts

@@ -9,20 +9,20 @@ import { ShutdownManager, Util } from '@travetto/runtime';
 export class IpcChannel<V = unknown> {
 
   #emitter = new EventEmitter();
-  proc: NodeJS.Process | ChildProcess;
+  subProcess: NodeJS.Process | ChildProcess;
   parentId: number;
 
-  constructor(proc: NodeJS.Process | ChildProcess = process) {
-    this.proc = proc;
-    this.parentId = proc instanceof ChildProcess ? process.pid : process.ppid;
+  constructor(subProcess: NodeJS.Process | ChildProcess = process) {
+    this.subProcess = subProcess;
+    this.parentId = subProcess instanceof ChildProcess ? process.pid : process.ppid;
 
     // Close on shutdown
     ShutdownManager.onGracefulShutdown(() => this.destroy());
 
-    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);
+    this.subProcess.on('message', (event: { type: string }) => {
+      console.debug('Received', { pid: this.parentId, id: this.id, type: event.type });
+      this.#emitter.emit(event.type, event);
+      this.#emitter.emit('*', event);
     });
   }
 
@@ -30,14 +30,14 @@ export class IpcChannel<V = unknown> {
    * Gets channel unique identifier
    */
   get id(): number | undefined {
-    return this.proc.pid;
+    return this.subProcess.pid;
   }
 
   /**
    * Determines if channel is active
    */
   get active(): boolean {
-    return (this.proc instanceof ChildProcess) ? !this.proc.killed : !!this.proc.connected;
+    return (this.subProcess instanceof ChildProcess) ? !this.subProcess.killed : !!this.subProcess.connected;
   }
 
   /**
@@ -47,17 +47,17 @@ export class IpcChannel<V = unknown> {
     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 }, undefined, undefined, (err) => err && console.error(err));
+    } else if (this.subProcess.send && this.subProcess.connected) {
+      this.subProcess.send({ ...(data ?? {}), type: eventType }, undefined, undefined, (error) => error && console.error(error));
     } else {
-      throw new Error('this.proc.send was not defined');
+      throw new Error('this.subProcess.send was not defined');
     }
   }
 
   /**
    * Listen for a specific message type
    */
-  on(eventType: string, callback: (e: V & { type: string }) => unknown | void): () => void {
+  on(eventType: string, callback: (event: V & { type: string }) => unknown | void): () => void {
     this.#emitter.on(eventType, callback);
     return () => this.off(eventType, callback);
   }
@@ -65,7 +65,7 @@ export class IpcChannel<V = unknown> {
   /**
    * Remove event listener
    */
-  off(eventType: string, callback: (e: V & { type: string }) => unknown | void): void {
+  off(eventType: string, callback: (event: V & { type: string }) => unknown | void): void {
     this.#emitter.off(eventType, callback);
   }
 
@@ -73,7 +73,7 @@ export class IpcChannel<V = unknown> {
    * Listen for a specific message type, once
    */
   once(eventType: string): Promise<V & { type: string }> {
-    return new Promise(res => this.#emitter.once(eventType, res));
+    return new Promise(resolve => this.#emitter.once(eventType, resolve));
   }
 
   /**
@@ -83,9 +83,9 @@ export class IpcChannel<V = unknown> {
     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();
+        if (this.subProcess instanceof ChildProcess) {
+          const complete = new Promise<void>(resolve => this.subProcess.on('close', resolve));
+          this.subProcess.kill();
           await Promise.race([complete, Util.nonBlockingTimeout(1000)]);
         }
       } catch { }
@@ -98,7 +98,7 @@ export class IpcChannel<V = unknown> {
    */
   release(): void {
     console.debug('Released', { pid: this.parentId, id: this.id });
-    this.proc.removeAllListeners();
+    this.subProcess.removeAllListeners();
     this.#emitter.removeAllListeners();
   }
 }

package/src/pool.ts

@@ -3,7 +3,7 @@ import { Options, Pool, createPool } from 'generic-pool';
 
 import { Env, Util, AsyncQueue } from '@travetto/runtime';
 
-type ItrSource<I> = Iterable<I> | AsyncIterable<I>;
+type IterableSource<I> = Iterable<I> | AsyncIterable<I>;
 type WorkerExecutor<I, O> = (input: I, idx: number) => Promise<O>;
 
 /**
@@ -22,11 +22,11 @@ type WorkerFactoryInput<I, O = unknown> = Partial<Worker<I, O>> & { execute: Wor
 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>);
+  onError?(event: Error, input: I, finishIdx: number): (unknown | Promise<unknown>);
   shutdown?: AbortSignal;
 };
 
-const isWorkerFactory = <I, O>(o: WorkerInput<I, O>): o is (() => WorkerFactoryInput<I, O>) => o.length === 0;
+const isWorkerFactory = <I, O>(value: WorkerInput<I, O>): value is (() => WorkerFactoryInput<I, O>) => value.length === 0;
 
 /**
  * Work pool support
@@ -37,10 +37,10 @@ export class WorkPool {
   static DEFAULT_SIZE = Math.max(Math.trunc(WorkPool.MAX_SIZE * .75), 4);
 
   /** Build worker pool */
-  static #buildPool<I, O>(input: WorkerInput<I, O>, opts?: WorkPoolConfig<I, O>): Pool<Worker<I, O>> {
+  static #buildPool<I, O>(input: WorkerInput<I, O>, options?: WorkPoolConfig<I, O>): Pool<Worker<I, O>> {
     let pendingAcquires = 0;
 
-    const trace = /@travetto\/worker/.test(Env.DEBUG.val ?? '');
+    const trace = /@travetto\/worker/.test(Env.DEBUG.value ?? '');
 
     // Create the pool
     const pool = createPool({
@@ -58,22 +58,22 @@ export class WorkPool {
           pendingAcquires -= 1;
         }
       },
-      async destroy(x) {
+      async destroy(worker) {
         if (trace) {
-          console.debug('Destroying', { pid: process.pid, worker: x.id });
+          console.debug('Destroying', { pid: process.pid, worker: worker.id });
         }
-        return x.destroy?.();
+        return worker.destroy?.();
       },
-      validate: async (x: Worker<I, O>) => x.active
+      validate: async (worker: Worker<I, O>) => worker.active
     }, {
       evictionRunIntervalMillis: 5000,
-      ...(opts ?? {}),
-      max: opts?.max ?? WorkPool.DEFAULT_SIZE,
-      min: opts?.min ?? 1,
+      ...(options ?? {}),
+      max: options?.max ?? WorkPool.DEFAULT_SIZE,
+      min: options?.min ?? 1,
     });
 
     // Listen for shutdown
-    opts?.shutdown?.addEventListener('abort', async () => {
+    options?.shutdown?.addEventListener('abort', async () => {
       while (pendingAcquires) {
         await Util.nonBlockingTimeout(10);
       }
@@ -87,17 +87,17 @@ export class WorkPool {
   /**
    * Process a given input source and worker, and fire on completion
    */
-  static async run<I, O>(workerFactory: WorkerInput<I, O>, src: ItrSource<I>, opts: WorkPoolConfig<I, O> = {}): Promise<void> {
+  static async run<I, O>(workerFactory: WorkerInput<I, O>, source: IterableSource<I>, options: WorkPoolConfig<I, O> = {}): Promise<void> {
 
-    const trace = /@travetto\/worker/.test(Env.DEBUG.val ?? '');
+    const trace = /@travetto\/worker/.test(Env.DEBUG.value ?? '');
     const pending = new Set<Promise<unknown>>();
     const errors: Error[] = [];
     let inputIdx = 0;
     let finishIdx = 0;
 
-    const pool = this.#buildPool(workerFactory, opts);
+    const pool = this.#buildPool(workerFactory, options);
 
-    for await (const nextInput of src) {
+    for await (const nextInput of source) {
       const worker = await pool.acquire()!;
 
       if (trace) {
@@ -105,10 +105,10 @@ export class WorkPool {
       }
 
       const completion = worker.execute(nextInput, inputIdx += 1)
-        .then(v => opts.onComplete?.(v, nextInput, finishIdx += 1))
-        .catch(err => {
-          errors.push(err);
-          opts?.onError?.(err, nextInput, finishIdx += 1);
+        .then(output => options.onComplete?.(output, nextInput, finishIdx += 1))
+        .catch(error => {
+          errors.push(error);
+          options?.onError?.(error, nextInput, finishIdx += 1);
         }) // Catch error
         .finally(async () => {
           if (trace) {
@@ -140,36 +140,36 @@ export class WorkPool {
   /**
    * Process a given input source as an async iterable
    */
-  static runStream<I, O>(worker: WorkerInput<I, O>, input: ItrSource<I>, opts?: WorkPoolConfig<I, O>): AsyncIterable<O> {
-    const itr = new AsyncQueue<O>();
+  static runStream<I, O>(worker: WorkerInput<I, O>, input: IterableSource<I>, options?: WorkPoolConfig<I, O>): AsyncIterable<O> {
+    const queue = new AsyncQueue<O>();
     const result = this.run(worker, input, {
-      ...opts,
-      onComplete: (ev, inp, finishIdx) => {
-        itr.add(ev);
-        opts?.onComplete?.(ev, inp, finishIdx);
+      ...options,
+      onComplete: (event, value, finishIdx) => {
+        queue.add(event);
+        options?.onComplete?.(event, value, finishIdx);
       }
     });
-    result.finally(() => itr.close());
-    return itr;
+    result.finally(() => queue.close());
+    return queue;
   }
 
   /**
    * Process a given input source as an async iterable with progress information
    */
-  static runStreamProgress<I, O>(worker: WorkerInput<I, O>, input: ItrSource<I>, total: number, opts?: WorkPoolConfig<I, O>): AsyncIterable<{
+  static runStreamProgress<I, O>(worker: WorkerInput<I, O>, input: IterableSource<I>, total: number, options?: WorkPoolConfig<I, O>): AsyncIterable<{
     idx: number;
     value: O;
     total: number;
   }> {
-    const itr = new AsyncQueue<{ idx: number, value: O, total: number }>();
+    const queue = new AsyncQueue<{ idx: number, value: O, total: number }>();
     const result = this.run(worker, input, {
-      ...opts,
-      onComplete: (ev, inp, finishIdx) => {
-        itr.add({ value: ev, idx: finishIdx, total });
-        opts?.onComplete?.(ev, inp, finishIdx);
+      ...options,
+      onComplete: (event, value, finishIdx) => {
+        queue.add({ value: event, idx: finishIdx, total });
+        options?.onComplete?.(event, value, finishIdx);
       }
     });
-    result.finally(() => itr.close());
-    return itr;
+    result.finally(() => queue.close());
+    return queue;
   }
 }