src/pools/pool.ts

   1 import EventEmitter from 'node:events'
   2 import type {
   3   ErrorHandler,
   4   ExitHandler,
   5   IWorker,
   6   MessageHandler,
   7   OnlineHandler,
   8   WorkerNode
   9 } from './worker'
  10 import type {
  11   WorkerChoiceStrategy,
  12   WorkerChoiceStrategyOptions
  13 } from './selection-strategies/selection-strategies-types'
  14
  15 /**
  16  * Pool types.
  17  *
  18  * @enum
  19  * @internal
  20  */
  21 export enum PoolType {
  22   /**
  23    * Fixed pool type.
  24    */
  25   FIXED = 'fixed',
  26   /**
  27    * Dynamic pool type.
  28    */
  29   DYNAMIC = 'dynamic'
  30 }
  31
  32 /**
  33  * Pool events emitter.
  34  */
  35 export class PoolEmitter extends EventEmitter {}
  36
  37 /**
  38  * Enumeration of pool events.
  39  */
  40 export const PoolEvents = Object.freeze({
  41   full: 'full',
  42   busy: 'busy'
  43 } as const)
  44
  45 /**
  46  * Pool event.
  47  */
  48 export type PoolEvent = keyof typeof PoolEvents
  49
  50 /**
  51  * Worker tasks queue options.
  52  */
  53 export interface TasksQueueOptions {
  54   /**
  55    * Maximum number of tasks that can be executed concurrently on a worker.
  56    *
  57    * @defaultValue 1
  58    */
  59   concurrency?: number
  60 }
  61
  62 /**
  63  * Options for a poolifier pool.
  64  *
  65  * @typeParam Worker - Type of worker.
  66  */
  67 export interface PoolOptions<Worker extends IWorker> {
  68   /**
  69    * A function that will listen for message event on each worker.
  70    */
  71   messageHandler?: MessageHandler<Worker>
  72   /**
  73    * A function that will listen for error event on each worker.
  74    */
  75   errorHandler?: ErrorHandler<Worker>
  76   /**
  77    * A function that will listen for online event on each worker.
  78    */
  79   onlineHandler?: OnlineHandler<Worker>
  80   /**
  81    * A function that will listen for exit event on each worker.
  82    */
  83   exitHandler?: ExitHandler<Worker>
  84   /**
  85    * The worker choice strategy to use in this pool.
  86    *
  87    * @defaultValue WorkerChoiceStrategies.ROUND_ROBIN
  88    */
  89   workerChoiceStrategy?: WorkerChoiceStrategy
  90   /**
  91    * The worker choice strategy options.
  92    */
  93   workerChoiceStrategyOptions?: WorkerChoiceStrategyOptions
  94   /**
  95    * Pool events emission.
  96    *
  97    * @defaultValue true
  98    */
  99   enableEvents?: boolean
 100   /**
 101    * Pool worker tasks queue.
 102    *
 103    * @defaultValue false
 104    */
 105   enableTasksQueue?: boolean
 106   /**
 107    * Pool worker tasks queue options.
 108    */
 109   tasksQueueOptions?: TasksQueueOptions
 110 }
 111
 112 /**
 113  * Contract definition for a poolifier pool.
 114  *
 115  * @typeParam Worker - Type of worker which manages this pool.
 116  * @typeParam Data - Type of data sent to the worker. This can only be serializable data.
 117  * @typeParam Response - Type of execution response. This can only be serializable data.
 118  */
 119 export interface IPool<
 120   Worker extends IWorker,
 121   Data = unknown,
 122   Response = unknown
 123 > {
 124   /**
 125    * Pool type.
 126    *
 127    * If it is `'dynamic'`, it provides the `max` property.
 128    */
 129   readonly type: PoolType
 130   /**
 131    * Pool worker nodes.
 132    */
 133   readonly workerNodes: Array<WorkerNode<Worker, Data>>
 134   /**
 135    * Emitter on which events can be listened to.
 136    *
 137    * Events that can currently be listened to:
 138    *
 139    * - `'full'`: Emitted when the pool is dynamic and full.
 140    * - `'busy'`: Emitted when the pool is busy.
 141    */
 142   readonly emitter?: PoolEmitter
 143   /**
 144    * Finds a free worker node key based on the number of tasks the worker has applied.
 145    *
 146    * If a worker is found with `0` running tasks, it is detected as free and its worker node key is returned.
 147    *
 148    * If no free worker is found, `-1` is returned.
 149    *
 150    * @returns A worker node key if there is one, `-1` otherwise.
 151    */
 152   findFreeWorkerNodeKey: () => number
 153   /**
 154    * Executes the function specified in the worker constructor with the task data input parameter.
 155    *
 156    * @param data - The task input data for the specified worker function. This can only be serializable data.
 157    * @returns Promise that will be fulfilled when the task is completed.
 158    */
 159   execute: (data?: Data) => Promise<Response>
 160   /**
 161    * Shutdowns every current worker in this pool.
 162    */
 163   destroy: () => Promise<void>
 164   /**
 165    * Sets the worker choice strategy in this pool.
 166    *
 167    * @param workerChoiceStrategy - The worker choice strategy.
 168    * @param workerChoiceStrategyOptions - The worker choice strategy options.
 169    */
 170   setWorkerChoiceStrategy: (
 171     workerChoiceStrategy: WorkerChoiceStrategy,
 172     workerChoiceStrategyOptions?: WorkerChoiceStrategyOptions
 173   ) => void
 174   /**
 175    * Sets the worker choice strategy options in this pool.
 176    *
 177    * @param workerChoiceStrategyOptions - The worker choice strategy options.
 178    */
 179   setWorkerChoiceStrategyOptions: (
 180     workerChoiceStrategyOptions: WorkerChoiceStrategyOptions
 181   ) => void
 182   /**
 183    * Enables/disables the worker tasks queue in this pool.
 184    *
 185    * @param enable - Whether to enable or disable the worker tasks queue.
 186    * @param tasksQueueOptions - The worker tasks queue options.
 187    */
 188   enableTasksQueue: (
 189     enable: boolean,
 190     tasksQueueOptions?: TasksQueueOptions
 191   ) => void
 192   /**
 193    * Sets the worker tasks queue options in this pool.
 194    *
 195    * @param tasksQueueOptions - The worker tasks queue options.
 196    */
 197   setTasksQueueOptions: (tasksQueueOptions: TasksQueueOptions) => void
 198 }