X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fpools%2Fabstract-pool.ts;h=9ac81ce56558ec76fbd66d7789b2399e910a2e69;hb=9eae7f2bf8939eaa61474e358835c1b2f13a754c;hp=ad21effb3bbb9837977a54c2f8c159c85af6b3c8;hpb=b1989cfdf9af9f2c5e01b9a3f7c81b8c3ed78cb4;p=poolifier.git

diff --git a/src/pools/abstract-pool.ts b/src/pools/abstract-pool.ts
index ad21effb..9ac81ce5 100644
--- a/src/pools/abstract-pool.ts
+++ b/src/pools/abstract-pool.ts
@@ -2,7 +2,7 @@ import crypto from 'node:crypto'
 import type { MessageValue, PromiseResponseWrapper } from '../utility-types'
 import { EMPTY_FUNCTION } from '../utils'
 import { KillBehaviors, isKillBehavior } from '../worker/worker-options'
-import type { PoolOptions } from './pool'
+import { PoolEvents, type PoolOptions } from './pool'
 import { PoolEmitter } from './pool'
 import type { IPoolInternal, TasksUsage, WorkerType } from './pool-internal'
 import { PoolType } from './pool-internal'
@@ -25,10 +25,10 @@ export abstract class AbstractPool<
   Data = unknown,
   Response = unknown
 > implements IPoolInternal<Worker, Data, Response> {
-  /** {@inheritDoc} */
+  /** @inheritDoc */
   public readonly workers: Array<WorkerType<Worker>> = []
 
-  /** {@inheritDoc} */
+  /** @inheritDoc */
   public readonly emitter?: PoolEmitter
 
   /**
@@ -93,23 +93,7 @@ export abstract class AbstractPool<
     Worker,
     Data,
     Response
-    >(
-      this,
-      () => {
-        const createdWorker = this.createAndSetupWorker()
-        this.registerWorkerMessageListener(createdWorker, message => {
-          if (
-            isKillBehavior(KillBehaviors.HARD, message.kill) ||
-            this.getWorkerTasksUsage(createdWorker)?.running === 0
-          ) {
-            // Kill received from the worker, means that no new tasks are submitted to that worker for a while ( > maxInactiveTime)
-            void this.destroyWorker(createdWorker)
-          }
-        })
-        return this.getWorkerKey(createdWorker)
-      },
-      this.opts.workerChoiceStrategy
-    )
+    >(this, this.opts.workerChoiceStrategy)
   }
 
   private checkFilePath (filePath: string): void {
@@ -142,19 +126,21 @@ export abstract class AbstractPool<
   private checkPoolOptions (opts: PoolOptions<Worker>): void {
     this.opts.workerChoiceStrategy =
       opts.workerChoiceStrategy ?? WorkerChoiceStrategies.ROUND_ROBIN
-    if (
-      !Object.values(WorkerChoiceStrategies).includes(
-        this.opts.workerChoiceStrategy
-      )
-    ) {
+    this.checkValidWorkerChoiceStrategy(this.opts.workerChoiceStrategy)
+    this.opts.enableEvents = opts.enableEvents ?? true
+  }
+
+  private checkValidWorkerChoiceStrategy (
+    workerChoiceStrategy: WorkerChoiceStrategy
+  ): void {
+    if (!Object.values(WorkerChoiceStrategies).includes(workerChoiceStrategy)) {
       throw new Error(
-        `Invalid worker choice strategy '${this.opts.workerChoiceStrategy}'`
+        `Invalid worker choice strategy '${workerChoiceStrategy}'`
       )
     }
-    this.opts.enableEvents = opts.enableEvents ?? true
   }
 
-  /** {@inheritDoc} */
+  /** @inheritDoc */
   public abstract get type (): PoolType
 
   /**
@@ -174,10 +160,11 @@ export abstract class AbstractPool<
     return this.workers.findIndex(workerItem => workerItem.worker === worker)
   }
 
-  /** {@inheritDoc} */
+  /** @inheritDoc */
   public setWorkerChoiceStrategy (
     workerChoiceStrategy: WorkerChoiceStrategy
   ): void {
+    this.checkValidWorkerChoiceStrategy(workerChoiceStrategy)
     this.opts.workerChoiceStrategy = workerChoiceStrategy
     for (const [index, workerItem] of this.workers.entries()) {
       this.setWorker(index, workerItem.worker, {
@@ -193,10 +180,10 @@ export abstract class AbstractPool<
     )
   }
 
-  /** {@inheritDoc} */
+  /** @inheritDoc */
   public abstract get full (): boolean
 
-  /** {@inheritDoc} */
+  /** @inheritDoc */
   public abstract get busy (): boolean
 
   protected internalBusy (): boolean {
@@ -206,14 +193,14 @@ export abstract class AbstractPool<
     )
   }
 
-  /** {@inheritDoc} */
+  /** @inheritDoc */
   public findFreeWorkerKey (): number {
     return this.workers.findIndex(workerItem => {
       return workerItem.tasksUsage.running === 0
     })
   }
 
-  /** {@inheritDoc} */
+  /** @inheritDoc */
   public async execute (data: Data): Promise<Response> {
     const [workerKey, worker] = this.chooseWorker()
     const messageId = crypto.randomUUID()
@@ -229,7 +216,7 @@ export abstract class AbstractPool<
     return res
   }
 
-  /** {@inheritDoc} */
+  /** @inheritDoc */
   public async destroy (): Promise<void> {
     await Promise.all(
       this.workers.map(async workerItem => {
@@ -239,7 +226,7 @@ export abstract class AbstractPool<
   }
 
   /**
-   * Shutdowns given worker.
+   * Shutdowns given worker in the pool.
    *
    * @param worker - A worker within `workers`.
    */
@@ -248,9 +235,12 @@ export abstract class AbstractPool<
   /**
    * Setup hook that can be overridden by a Poolifier pool implementation
    * to run code before workers are created in the abstract constructor.
+   * Can be overridden
+   *
+   * @virtual
    */
   protected setupHook (): void {
-    // Can be overridden
+    // Intentionally empty
   }
 
   /**
@@ -286,7 +276,7 @@ export abstract class AbstractPool<
       ++workerTasksUsage.error
     }
     if (this.workerChoiceStrategyContext.getRequiredStatistics().runTime) {
-      workerTasksUsage.runTime += message.taskRunTime ?? 0
+      workerTasksUsage.runTime += message.runTime ?? 0
       if (
         this.workerChoiceStrategyContext.getRequiredStatistics().avgRunTime &&
         workerTasksUsage.run !== 0
@@ -305,7 +295,27 @@ export abstract class AbstractPool<
    * @returns [worker key, worker].
    */
   protected chooseWorker (): [number, Worker] {
-    const workerKey = this.workerChoiceStrategyContext.execute()
+    let workerKey: number
+    if (
+      this.type === PoolType.DYNAMIC &&
+      !this.full &&
+      this.findFreeWorkerKey() === -1
+    ) {
+      const createdWorker = this.createAndSetupWorker()
+      this.registerWorkerMessageListener(createdWorker, message => {
+        if (
+          isKillBehavior(KillBehaviors.HARD, message.kill) ||
+          (message.kill != null &&
+            this.getWorkerTasksUsage(createdWorker)?.running === 0)
+        ) {
+          // Kill message received from the worker, means that no new tasks are submitted to that worker for a while ( > maxInactiveTime)
+          void this.destroyWorker(createdWorker)
+        }
+      })
+      workerKey = this.getWorkerKey(createdWorker)
+    } else {
+      workerKey = this.workerChoiceStrategyContext.execute()
+    }
     return [workerKey, this.workers[workerKey].worker]
   }
 
@@ -341,6 +351,7 @@ export abstract class AbstractPool<
    * Can be used to update the `maxListeners` or binding the `main-worker`\<-\>`worker` connection if not bind by default.
    *
    * @param worker - The newly created worker.
+   * @virtual
    */
   protected abstract afterWorkerSetup (worker: Worker): void
 
@@ -381,6 +392,7 @@ export abstract class AbstractPool<
   protected workerListener (): (message: MessageValue<Response>) => void {
     return message => {
       if (message.id != null) {
+        // Task response received
         const promiseResponse = this.promiseResponseMap.get(message.id)
         if (promiseResponse != null) {
           if (message.error != null) {
@@ -408,7 +420,7 @@ export abstract class AbstractPool<
 
   private checkAndEmitBusy (): void {
     if (this.opts.enableEvents === true && this.busy) {
-      this.emitter?.emit('busy')
+      this.emitter?.emit(PoolEvents.busy)
     }
   }
 
@@ -418,12 +430,12 @@ export abstract class AbstractPool<
       this.opts.enableEvents === true &&
       this.full
     ) {
-      this.emitter?.emit('full')
+      this.emitter?.emit(PoolEvents.full)
     }
   }
 
   /**
-   * Gets worker tasks usage.
+   * Gets the given worker tasks usage in the pool.
    *
    * @param worker - The worker.
    * @returns The worker tasks usage.