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(
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,
+ runningTasks: 0,
+ queuedTasks: 0,
+ maxQueuedTasks: 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,
+ runningTasks: 0,
+ queuedTasks: 0,
+ maxQueuedTasks: 0
+ })
+ await pool.destroy()
+ })
+
it('Simulate worker not found', async () => {
const pool = new StubPoolWithRemoveAllWorker(
numberOfWorkers,
)
for (const workerNode of pool.workerNodes) {
expect(workerNode.tasksUsage).toStrictEqual({
- run: 0,
+ ran: 0,
running: 0,
runTime: 0,
runTimeHistory: expect.any(CircularArray),
}
for (const workerNode of pool.workerNodes) {
expect(workerNode.tasksUsage).toStrictEqual({
- run: 0,
+ ran: 0,
running: maxMultiplier,
runTime: 0,
runTimeHistory: expect.any(CircularArray),
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
expect(workerNode.tasksUsage).toStrictEqual({
- run: maxMultiplier,
+ ran: maxMultiplier,
running: 0,
runTime: 0,
runTimeHistory: expect.any(CircularArray),
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
expect(workerNode.tasksUsage).toStrictEqual({
- run: expect.any(Number),
+ ran: expect.any(Number),
running: 0,
runTime: 0,
runTimeHistory: expect.any(CircularArray),
medWaitTime: 0,
error: 0
})
- expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
- expect(workerNode.tasksUsage.run).toBeLessThanOrEqual(maxMultiplier)
+ expect(workerNode.tasksUsage.ran).toBeGreaterThan(0)
+ expect(workerNode.tasksUsage.ran).toBeLessThanOrEqual(maxMultiplier)
}
pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE)
for (const workerNode of pool.workerNodes) {
expect(workerNode.tasksUsage).toStrictEqual({
- run: 0,
+ ran: 0,
running: 0,
runTime: 0,
runTimeHistory: expect.any(CircularArray),
let poolFull = 0
pool.emitter.on(PoolEvents.full, () => ++poolFull)
for (let i = 0; i < numberOfWorkers * 2; i++) {
- promises.push(pool.execute())
+ promises.add(pool.execute())
}
await Promise.all(promises)
// The `full` event is triggered when the number of submitted tasks at once reach the max number of workers in the dynamic pool.
let poolBusy = 0
pool.emitter.on(PoolEvents.busy, () => ++poolBusy)
for (let i = 0; i < numberOfWorkers * 2; i++) {
- promises.push(pool.execute())
+ promises.add(pool.execute())
}
await Promise.all(promises)
// The `busy` event is triggered when the number of submitted tasks at once reach the number of fixed pool workers.