X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fpools%2Fabstract-pool.ts;h=6b12c2f99b6b986d822668c2648e0ff0ec59bd33;hb=d15211d4a844f29140004fc2814316e62547aee0;hp=abbf7638c0b325fbd1534ec44a14eb5d6260d579;hpb=e336fea695672f35acebb522feac62b665b0b3a5;p=poolifier.git

diff --git a/src/pools/abstract-pool.ts b/src/pools/abstract-pool.ts
index abbf7638..6b12c2f9 100644
--- a/src/pools/abstract-pool.ts
+++ b/src/pools/abstract-pool.ts
@@ -2,7 +2,7 @@ import type {
   MessageValue,
   PromiseWorkerResponseWrapper
 } from '../utility-types'
-import { EMPTY_FUNCTION } from '../utils'
+import { EMPTY_FUNCTION, EMPTY_LITERAL } from '../utils'
 import { isKillBehavior, KillBehaviors } from '../worker/worker-options'
 import type { PoolOptions } from './pool'
 import { PoolEmitter } from './pool'
@@ -32,16 +32,13 @@ export abstract class AbstractPool<
 
   /** @inheritDoc */
   public readonly workersTasksUsage: Map<Worker, TasksUsage> = new Map<
-    Worker,
-    TasksUsage
+  Worker,
+  TasksUsage
   >()
 
   /** @inheritDoc */
   public readonly emitter?: PoolEmitter
 
-  /** @inheritDoc */
-  public readonly max?: number
-
   /**
    * The promise map.
    *
@@ -51,8 +48,8 @@ export abstract class AbstractPool<
    * When we receive a message from the worker we get a map entry and resolve/reject the promise based on the message.
    */
   protected promiseMap: Map<
-    number,
-    PromiseWorkerResponseWrapper<Worker, Response>
+  number,
+  PromiseWorkerResponseWrapper<Worker, Response>
   > = new Map<number, PromiseWorkerResponseWrapper<Worker, Response>>()
 
   /**
@@ -66,9 +63,9 @@ export abstract class AbstractPool<
    * Default to a strategy implementing a round robin algorithm.
    */
   protected workerChoiceStrategyContext: WorkerChoiceStrategyContext<
-    Worker,
-    Data,
-    Response
+  Worker,
+  Data,
+  Response
   >
 
   /**
@@ -83,7 +80,7 @@ export abstract class AbstractPool<
     public readonly filePath: string,
     public readonly opts: PoolOptions<Worker>
   ) {
-    if (this.isMain() === false) {
+    if (!this.isMain()) {
       throw new Error('Cannot start a pool from a worker!')
     }
     this.checkNumberOfWorkers(this.numberOfWorkers)
@@ -108,7 +105,7 @@ export abstract class AbstractPool<
             this.getWorkerRunningTasks(workerCreated) === 0
           ) {
             // Kill received from the worker, means that no new tasks are submitted to that worker for a while ( > maxInactiveTime)
-            this.destroyWorker(workerCreated) as void
+            void (this.destroyWorker(workerCreated) as Promise<void>)
           }
         })
         return workerCreated
@@ -118,7 +115,7 @@ export abstract class AbstractPool<
   }
 
   private checkFilePath (filePath: string): void {
-    if (!filePath) {
+    if (filePath == null || filePath.length === 0) {
       throw new Error('Please specify a file with a worker implementation')
     }
   }
@@ -128,12 +125,12 @@ export abstract class AbstractPool<
       throw new Error(
         'Cannot instantiate a pool without specifying the number of workers'
       )
-    } else if (Number.isSafeInteger(numberOfWorkers) === false) {
-      throw new Error(
+    } else if (!Number.isSafeInteger(numberOfWorkers)) {
+      throw new TypeError(
         'Cannot instantiate a pool with a non integer number of workers'
       )
     } else if (numberOfWorkers < 0) {
-      throw new Error(
+      throw new RangeError(
         'Cannot instantiate a pool with a negative number of workers'
       )
     } else if (this.type === PoolType.FIXED && numberOfWorkers === 0) {
@@ -205,16 +202,17 @@ export abstract class AbstractPool<
   }
 
   /** @inheritDoc */
-  public execute (data: Data): Promise<Response> {
+  public async execute (data: Data): Promise<Response> {
     // Configure worker to handle message with the specified task
     const worker = this.chooseWorker()
     const res = this.internalExecute(worker, this.nextMessageId)
     this.checkAndEmitBusy()
     this.sendToWorker(worker, {
-      data: data ?? ({} as Data),
+      data: data ?? (EMPTY_LITERAL as Data),
       id: this.nextMessageId
     })
     ++this.nextMessageId
+    // eslint-disable-next-line @typescript-eslint/return-await
     return res
   }
 
@@ -310,17 +308,7 @@ export abstract class AbstractPool<
    */
   protected abstract registerWorkerMessageListener<
     Message extends Data | Response
-  > (worker: Worker, listener: (message: MessageValue<Message>) => void): void
-
-  protected internalExecute (
-    worker: Worker,
-    messageId: number
-  ): Promise<Response> {
-    this.beforePromiseWorkerResponseHook(worker)
-    return new Promise<Response>((resolve, reject) => {
-      this.promiseMap.set(messageId, { resolve, reject, worker })
-    })
-  }
+  >(worker: Worker, listener: (message: MessageValue<Message>) => void): void
 
   /**
    * Returns a newly created worker.
@@ -370,7 +358,7 @@ export abstract class AbstractPool<
       if (message.id !== undefined) {
         const promise = this.promiseMap.get(message.id)
         if (promise !== undefined) {
-          if (message.error) {
+          if (message.error != null) {
             promise.reject(message.error)
           } else {
             promise.resolve(message.data as Response)
@@ -382,8 +370,18 @@ export abstract class AbstractPool<
     }
   }
 
+  private async internalExecute (
+    worker: Worker,
+    messageId: number
+  ): Promise<Response> {
+    this.beforePromiseWorkerResponseHook(worker)
+    return await new Promise<Response>((resolve, reject) => {
+      this.promiseMap.set(messageId, { resolve, reject, worker })
+    })
+  }
+
   private checkAndEmitBusy (): void {
-    if (this.opts.enableEvents === true && this.busy === true) {
+    if (this.opts.enableEvents === true && this.busy) {
       this.emitter?.emit('busy')
     }
   }
@@ -413,7 +411,7 @@ export abstract class AbstractPool<
    * @param step Number of running tasks step.
    */
   private stepWorkerRunningTasks (worker: Worker, step: number): void {
-    if (this.checkWorkerTasksUsage(worker) === true) {
+    if (this.checkWorkerTasksUsage(worker)) {
       const tasksUsage = this.workersTasksUsage.get(worker) as TasksUsage
       tasksUsage.running = tasksUsage.running + step
       this.workersTasksUsage.set(worker, tasksUsage)
@@ -427,7 +425,7 @@ export abstract class AbstractPool<
    * @param step Number of run tasks step.
    */
   private stepWorkerRunTasks (worker: Worker, step: number): void {
-    if (this.checkWorkerTasksUsage(worker) === true) {
+    if (this.checkWorkerTasksUsage(worker)) {
       const tasksUsage = this.workersTasksUsage.get(worker) as TasksUsage
       tasksUsage.run = tasksUsage.run + step
       this.workersTasksUsage.set(worker, tasksUsage)
@@ -446,8 +444,8 @@ export abstract class AbstractPool<
   ): void {
     if (
       this.workerChoiceStrategyContext.getWorkerChoiceStrategy()
-        .requiredStatistics.runTime === true &&
-      this.checkWorkerTasksUsage(worker) === true
+        .requiredStatistics.runTime &&
+      this.checkWorkerTasksUsage(worker)
     ) {
       const tasksUsage = this.workersTasksUsage.get(worker) as TasksUsage
       tasksUsage.runTime += taskRunTime ?? 0
@@ -466,7 +464,7 @@ export abstract class AbstractPool<
    */
   private checkWorkerTasksUsage (worker: Worker): boolean {
     const hasTasksUsage = this.workersTasksUsage.has(worker)
-    if (hasTasksUsage === false) {
+    if (!hasTasksUsage) {
       throw new Error('Worker could not be found in workers tasks usage map')
     }
     return hasTasksUsage