FixedClusterPool,
FixedThreadPool,
PoolEvents,
- WorkerChoiceStrategies
+ WorkerChoiceStrategies,
+ PoolTypes,
+ WorkerTypes
} = require('../../../lib')
const { CircularArray } = require('../../../lib/circular-array')
const { Queue } = require('../../../lib/queue')
numberOfWorkers,
'./tests/worker-files/thread/testWorker.js'
)
- expect(pool.opts.enableEvents).toBe(true)
expect(pool.emitter).toBeDefined()
+ expect(pool.opts.enableEvents).toBe(true)
+ expect(pool.opts.restartWorkerOnError).toBe(true)
expect(pool.opts.enableTasksQueue).toBe(false)
expect(pool.opts.tasksQueueOptions).toBeUndefined()
expect(pool.opts.workerChoiceStrategy).toBe(
weights: { 0: 300, 1: 200 }
},
enableEvents: false,
+ restartWorkerOnError: false,
enableTasksQueue: true,
tasksQueueOptions: { concurrency: 2 },
messageHandler: testHandler,
exitHandler: testHandler
}
)
- expect(pool.opts.enableEvents).toBe(false)
expect(pool.emitter).toBeUndefined()
+ expect(pool.opts.enableEvents).toBe(false)
+ expect(pool.opts.restartWorkerOnError).toBe(false)
expect(pool.opts.enableTasksQueue).toBe(true)
expect(pool.opts.tasksQueueOptions).toStrictEqual({ concurrency: 2 })
expect(pool.opts.workerChoiceStrategy).toBe(
})
}
expect(
- pool.workerChoiceStrategyContext.getRequiredStatistics()
+ pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
).toStrictEqual({
runTime: true,
avgRunTime: true,
medRunTime: false,
waitTime: false,
avgWaitTime: false,
- medWaitTime: false
+ medWaitTime: false,
+ elu: false
})
pool.setWorkerChoiceStrategyOptions({ medRunTime: true })
expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
expect(workerChoiceStrategy.opts).toStrictEqual({ medRunTime: true })
}
expect(
- pool.workerChoiceStrategyContext.getRequiredStatistics()
+ pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
).toStrictEqual({
runTime: true,
avgRunTime: false,
medRunTime: true,
waitTime: false,
avgWaitTime: false,
- medWaitTime: false
+ medWaitTime: false,
+ elu: false
})
pool.setWorkerChoiceStrategyOptions({ medRunTime: false })
expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
expect(workerChoiceStrategy.opts).toStrictEqual({ medRunTime: false })
}
expect(
- pool.workerChoiceStrategyContext.getRequiredStatistics()
+ pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
).toStrictEqual({
runTime: true,
avgRunTime: true,
medRunTime: false,
waitTime: false,
avgWaitTime: false,
- medWaitTime: false
+ medWaitTime: false,
+ elu: false
})
await pool.destroy()
})
await pool.destroy()
})
+ it('Verify that pool info is set', async () => {
+ let pool = new FixedThreadPool(
+ numberOfWorkers,
+ './tests/worker-files/thread/testWorker.js'
+ )
+ expect(pool.info).toStrictEqual({
+ type: PoolTypes.fixed,
+ worker: WorkerTypes.thread,
+ minSize: numberOfWorkers,
+ maxSize: numberOfWorkers,
+ workerNodes: numberOfWorkers,
+ idleWorkerNodes: numberOfWorkers,
+ busyWorkerNodes: 0,
+ executedTasks: 0,
+ executingTasks: 0,
+ queuedTasks: 0,
+ maxQueuedTasks: 0,
+ failedTasks: 0
+ })
+ await pool.destroy()
+ pool = new DynamicClusterPool(
+ numberOfWorkers,
+ numberOfWorkers * 2,
+ './tests/worker-files/thread/testWorker.js'
+ )
+ expect(pool.info).toStrictEqual({
+ type: PoolTypes.dynamic,
+ worker: WorkerTypes.cluster,
+ minSize: numberOfWorkers,
+ maxSize: numberOfWorkers * 2,
+ workerNodes: numberOfWorkers,
+ idleWorkerNodes: numberOfWorkers,
+ busyWorkerNodes: 0,
+ executedTasks: 0,
+ executingTasks: 0,
+ queuedTasks: 0,
+ maxQueuedTasks: 0,
+ failedTasks: 0
+ })
+ await pool.destroy()
+ })
+
it('Simulate worker not found', async () => {
const pool = new StubPoolWithRemoveAllWorker(
numberOfWorkers,
'./tests/worker-files/cluster/testWorker.js'
)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: 0,
- running: 0,
- runTime: 0,
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: 0,
- medRunTime: 0,
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: 0,
+ executing: 0,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ elu: undefined
})
}
await pool.destroy()
promises.add(pool.execute())
}
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: 0,
- running: maxMultiplier,
- runTime: 0,
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: 0,
- medRunTime: 0,
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: 0,
+ executing: maxMultiplier,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ elu: undefined
})
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: maxMultiplier,
- running: 0,
- runTime: 0,
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: 0,
- medRunTime: 0,
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: maxMultiplier,
+ executing: 0,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ elu: undefined
})
}
await pool.destroy()
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: expect.any(Number),
- running: 0,
- runTime: 0,
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: 0,
- medRunTime: 0,
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: expect.any(Number),
+ executing: 0,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ elu: undefined
})
- expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
- expect(workerNode.tasksUsage.run).toBeLessThanOrEqual(maxMultiplier)
+ expect(workerNode.workerUsage.tasks.executed).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeLessThanOrEqual(
+ maxMultiplier
+ )
}
pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: 0,
- running: 0,
- runTime: 0,
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: 0,
- medRunTime: 0,
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: 0,
+ executing: 0,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ elu: undefined
})
- expect(workerNode.tasksUsage.runTimeHistory.length).toBe(0)
- expect(workerNode.tasksUsage.waitTimeHistory.length).toBe(0)
+ expect(workerNode.workerUsage.runTime.history.length).toBe(0)
+ expect(workerNode.workerUsage.waitTime.history.length).toBe(0)
}
await pool.destroy()
})
)
const promises = new Set()
let poolFull = 0
- pool.emitter.on(PoolEvents.full, () => ++poolFull)
+ let poolInfo
+ pool.emitter.on(PoolEvents.full, info => {
+ ++poolFull
+ poolInfo = info
+ })
for (let i = 0; i < numberOfWorkers * 2; i++) {
promises.add(pool.execute())
}
// The `full` event is triggered when the number of submitted tasks at once reach the max number of workers in the dynamic pool.
// So in total numberOfWorkers * 2 times for a loop submitting up to numberOfWorkers * 2 tasks to the dynamic pool with min = max = numberOfWorkers.
expect(poolFull).toBe(numberOfWorkers * 2)
+ expect(poolInfo).toStrictEqual({
+ type: PoolTypes.dynamic,
+ worker: WorkerTypes.thread,
+ minSize: expect.any(Number),
+ maxSize: expect.any(Number),
+ workerNodes: expect.any(Number),
+ idleWorkerNodes: expect.any(Number),
+ busyWorkerNodes: expect.any(Number),
+ executedTasks: expect.any(Number),
+ executingTasks: expect.any(Number),
+ queuedTasks: expect.any(Number),
+ maxQueuedTasks: expect.any(Number),
+ failedTasks: expect.any(Number)
+ })
await pool.destroy()
})
)
const promises = new Set()
let poolBusy = 0
- pool.emitter.on(PoolEvents.busy, () => ++poolBusy)
+ let poolInfo
+ pool.emitter.on(PoolEvents.busy, info => {
+ ++poolBusy
+ poolInfo = info
+ })
for (let i = 0; i < numberOfWorkers * 2; i++) {
promises.add(pool.execute())
}
// The `busy` event is triggered when the number of submitted tasks at once reach the number of fixed pool workers.
// So in total numberOfWorkers + 1 times for a loop submitting up to numberOfWorkers * 2 tasks to the fixed pool.
expect(poolBusy).toBe(numberOfWorkers + 1)
+ expect(poolInfo).toStrictEqual({
+ type: PoolTypes.fixed,
+ worker: WorkerTypes.thread,
+ minSize: expect.any(Number),
+ maxSize: expect.any(Number),
+ workerNodes: expect.any(Number),
+ idleWorkerNodes: expect.any(Number),
+ busyWorkerNodes: expect.any(Number),
+ executedTasks: expect.any(Number),
+ executingTasks: expect.any(Number),
+ queuedTasks: expect.any(Number),
+ maxQueuedTasks: expect.any(Number),
+ failedTasks: expect.any(Number)
+ })
await pool.destroy()
})