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'
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 {
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 */
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, {
++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
* @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]
}
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) {
private checkAndEmitBusy (): void {
if (this.opts.enableEvents === true && this.busy) {
- this.emitter?.emit('busy')
+ this.emitter?.emit(PoolEvents.busy)
}
}
this.opts.enableEvents === true &&
this.full
) {
- this.emitter?.emit('full')
+ this.emitter?.emit(PoolEvents.full)
}
}