X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fworker%2Fabstract-worker.ts;h=b16c886b26c933c77aeee5ff32a3c9a61272aab3;hb=79e68dbfc6bfa1de92849134b10bb6e909fab422;hp=7aa626f1610a3cd4f4e30ca23232b640a1eca410;hpb=5c4d16da7677746e563fdcfe7f82cbb842d1c9e6;p=poolifier.git

diff --git a/src/worker/abstract-worker.ts b/src/worker/abstract-worker.ts
index 7aa626f1..b16c886b 100644
--- a/src/worker/abstract-worker.ts
+++ b/src/worker/abstract-worker.ts
@@ -58,9 +58,9 @@ export abstract class AbstractWorker<
    */
   protected statistics!: WorkerStatistics
   /**
-   * Handler id of the `aliveInterval` worker alive check.
+   * Handler id of the `activeInterval` worker activity check.
    */
-  protected aliveInterval?: NodeJS.Timeout
+  protected activeInterval?: NodeJS.Timeout
   /**
    * Constructs a new poolifier worker.
    *
@@ -83,7 +83,7 @@ export abstract class AbstractWorker<
        */
       killBehavior: DEFAULT_KILL_BEHAVIOR,
       /**
-       * The maximum time to keep this worker alive while idle.
+       * The maximum time to keep this worker active while idle.
        * The pool automatically checks and terminates this worker when the time expires.
        */
       maxInactiveTime: DEFAULT_MAX_INACTIVE_TIME
@@ -123,6 +123,11 @@ export abstract class AbstractWorker<
     } else if (isPlainObject(taskFunctions)) {
       let firstEntry = true
       for (const [name, fn] of Object.entries(taskFunctions)) {
+        if (typeof name !== 'string') {
+          throw new TypeError(
+            'A taskFunctions parameter object key is not a string'
+          )
+        }
         if (typeof fn !== 'function') {
           throw new TypeError(
             'A taskFunctions parameter object value is not a function'
@@ -266,60 +271,59 @@ export abstract class AbstractWorker<
   /**
    * Worker message listener.
    *
-   * @param message - Message received.
+   * @param message - The received message.
    */
   protected messageListener (message: MessageValue<Data, Data>): void {
     if (message.workerId === this.id) {
       if (message.ready != null) {
         // Startup message received
-        this.workerReady()
+        this.sendReadyResponse()
       } else if (message.statistics != null) {
         // Statistics message received
         this.statistics = message.statistics
-      } else if (message.checkAlive != null) {
-        // Check alive message received
-        message.checkAlive ? this.startCheckAlive() : this.stopCheckAlive()
+      } else if (message.checkActive != null) {
+        // Check active message received
+        message.checkActive ? this.startCheckActive() : this.stopCheckActive()
       } else if (message.id != null && message.data != null) {
         // Task message received
         this.run(message)
       } else if (message.kill === true) {
         // Kill message received
-        this.stopCheckAlive()
+        this.stopCheckActive()
         this.emitDestroy()
       }
     }
   }
 
   /**
-   * Notifies the main worker that this worker is ready to process tasks.
+   * Sends to the main worker the ready response.
    */
-  protected workerReady (): void {
+  protected sendReadyResponse (): void {
     !this.isMain && this.sendToMainWorker({ ready: true, workerId: this.id })
   }
 
   /**
-   * Starts the worker alive check interval.
+   * Starts the worker check active interval.
    */
-  private startCheckAlive (): void {
+  private startCheckActive (): void {
     this.lastTaskTimestamp = performance.now()
-    this.aliveInterval = setInterval(
-      this.checkAlive.bind(this),
+    this.activeInterval = setInterval(
+      this.checkActive.bind(this),
       (this.opts.maxInactiveTime ?? DEFAULT_MAX_INACTIVE_TIME) / 2
     )
-    this.checkAlive.bind(this)()
   }
 
   /**
-   * Stops the worker alive check interval.
+   * Stops the worker check active interval.
    */
-  private stopCheckAlive (): void {
-    this.aliveInterval != null && clearInterval(this.aliveInterval)
+  private stopCheckActive (): void {
+    this.activeInterval != null && clearInterval(this.activeInterval)
   }
 
   /**
    * Checks if the worker should be terminated, because its living too long.
    */
-  private checkAlive (): void {
+  private checkActive (): void {
     if (
       performance.now() - this.lastTaskTimestamp >
       (this.opts.maxInactiveTime ?? DEFAULT_MAX_INACTIVE_TIME)
@@ -375,7 +379,7 @@ export abstract class AbstractWorker<
   }
 
   /**
-   * Runs the given function synchronously.
+   * Runs the given task function synchronously.
    *
    * @param fn - Task function that will be executed.
    * @param task - Input data for the task function.
@@ -406,14 +410,14 @@ export abstract class AbstractWorker<
         id: task.id
       })
     } finally {
-      if (!this.isMain && this.aliveInterval != null) {
+      if (!this.isMain && this.activeInterval != null) {
         this.lastTaskTimestamp = performance.now()
       }
     }
   }
 
   /**
-   * Runs the given function asynchronously.
+   * Runs the given task function asynchronously.
    *
    * @param fn - Task function that will be executed.
    * @param task - Input data for the task function.
@@ -447,7 +451,7 @@ export abstract class AbstractWorker<
         })
       })
       .finally(() => {
-        if (!this.isMain && this.aliveInterval != null) {
+        if (!this.isMain && this.activeInterval != null) {
           this.lastTaskTimestamp = performance.now()
         }
       })