beforeAll(async () => {
await specHelper.connect()
await specHelper.cleanup()
queue = new NodeResque.Queue({connection: specHelper.cleanConnectionDetails(), queue: specHelper.queue}, jobs)
scheduler = new NodeResque.Scheduler({connection: specHelper.cleanConnectionDetails(), timeout: specHelper.timeout})
await scheduler.connect()
scheduler.start()
await queue.connect()
})
beforeEach(async () => {
await specHelper.cleanup()
scheduler = new NodeResque.Scheduler({
connection: specHelper.connectionDetails,
timeout: specHelper.timeout,
stuckWorkerTimeout: 1000
})
queue = new NodeResque.Queue({connection: specHelper.connectionDetails, queue: specHelper.queue})
await scheduler.connect()
await queue.connect()
})
beforeAll(async () => {
await specHelper.connect()
queue = new NodeResque.Queue({connection: specHelper.cleanConnectionDetails(), queue: specHelper.queue})
await queue.connect()
multiWorker = new NodeResque.MultiWorker({
connection: specHelper.cleanConnectionDetails(),
timeout: specHelper.timeout,
checkTimeout: checkTimeout,
minTaskProcessors: minTaskProcessors,
maxTaskProcessors: maxTaskProcessors,
queues: [specHelper.queue]
}, jobs)
await multiWorker.end()
multiWorker.on('error', (error) => { throw error })
})
async function boot () {
// ////////////////////////
// SET UP THE CONNECTION //
// ////////////////////////
const connectionDetails = {
pkg: 'ioredis',
host: '127.0.0.1',
password: null,
port: 6379,
database: 0
// namespace: 'resque',
// looping: true,
// options: {password: '******'},
}
// ///////////////////////////
// DEFINE YOUR WORKER TASKS //
// ///////////////////////////
const jobs = {
'stuck': {
perform: async function () {
console.log(`${this.name} is starting stuck job...`)
await new Promise((resolve) => {
clearTimeout(this.pingTimer)// stop the worker from checkin in, like the process crashed
setTimeout(resolve, 60 * 60 * 1000) // 1 hour job
})
}
}
}
// /////////////////
// START A WORKER //
// /////////////////
const worker = new NodeResque.Worker({connection: connectionDetails, queues: ['stuckJobs']}, jobs)
await worker.connect()
worker.start()
// ////////////////////
// START A SCHEDULER //
// ////////////////////
const scheduler = new NodeResque.Scheduler({
stuckWorkerTimeout: (10 * 1000),
connection: connectionDetails
})
await scheduler.connect()
scheduler.start()
// //////////////////////
// REGESTER FOR EVENTS //
// //////////////////////
worker.on('start', () => { console.log('worker started') })
worker.on('end', () => { console.log('worker ended') })
worker.on('cleaning_worker', (worker, pid) => { console.log(`cleaning old worker ${worker}`) })
worker.on('poll', (queue) => { console.log(`worker polling ${queue}`) })
worker.on('ping', (time) => { console.log(`worker check in @ ${time}`) })
worker.on('job', (queue, job) => { console.log(`working job ${queue} ${JSON.stringify(job)}`) })
worker.on('reEnqueue', (queue, job, plugin) => { console.log(`reEnqueue job (${plugin}) ${queue} ${JSON.stringify(job)}`) })
worker.on('success', (queue, job, result) => { console.log(`job success ${queue} ${JSON.stringify(job)} >> ${result}`) })
worker.on('failure', (queue, job, failure) => { console.log(`job failure ${queue} ${JSON.stringify(job)} >> ${failure}`) })
worker.on('error', (error, queue, job) => { console.log(`error ${queue} ${JSON.stringify(job)} >> ${error}`) })
worker.on('pause', () => { console.log('worker paused') })
scheduler.on('start', () => { console.log('scheduler started') })
scheduler.on('end', () => { console.log('scheduler ended') })
scheduler.on('poll', () => { console.log('scheduler polling') })
scheduler.on('master', (state) => { console.log('scheduler became master') })
scheduler.on('error', (error) => { console.log(`scheduler error >> ${error}`) })
scheduler.on('workingTimestamp', (timestamp) => { console.log(`scheduler working timestamp ${timestamp}`) })
scheduler.on('transferredJob', (timestamp, job) => { console.log(`scheduler enquing job ${timestamp} >> ${JSON.stringify(job)}`) })
scheduler.on('cleanStuckWorker', (workerName, errorPayload, delta) => {
console.log(`failing ${workerName} (stuck for ${delta}s) and failing job: ${JSON.stringify(errorPayload)}`)
process.exit()
})
// //////////////////////
// CONNECT TO A QUEUE //
// //////////////////////
const queue = new NodeResque.Queue({connection: connectionDetails}, jobs)
queue.on('error', function (error) { console.log(error) })
await queue.connect()
await queue.enqueue('stuckJobs', 'stuck', ['oh no'])
}
beforeAll(async () => {
await specHelper.connect()
await specHelper.cleanup()
queue = new NodeResque.Queue({connection: specHelper.cleanConnectionDetails(), queue: specHelper.queue}, jobs)
await queue.connect()
})
async function boot () {
// //////////////
// DEFINE JOBS //
// //////////////
const blockingSleep = function (naptime) {
var sleeping = true
var now = new Date()
var alarm
var startingMSeconds = now.getTime()
while (sleeping) {
alarm = new Date()
var alarmMSeconds = alarm.getTime()
if (alarmMSeconds - startingMSeconds > naptime) { sleeping = false }
}
}
const jobs = {
'slowSleepJob': {
plugins: [],
pluginOptions: {},
perform: async () => {
let start = new Date().getTime()
await new Promise((resolve) => { setTimeout(resolve, 1000) })
return (new Date().getTime() - start)
}
},
'slowCPUJob': {
plugins: [],
pluginOptions: {},
perform: async () => {
let start = new Date().getTime()
blockingSleep(1000)
return (new Date().getTime() - start)
}
}
}
// ////////////////
// ENQUEUE TASKS //
// ////////////////
const queue = new NodeResque.Queue({connection: connectionDetails}, jobs)
await queue.connect()
var i
i = 0
while (i < 10) {
await queue.enqueue('slowQueue', 'slowCPUJob', [])
i++
}
i = 0
while (i < 100) {
await queue.enqueue('slowQueue', 'slowSleepJob', [])
i++
}
// ///////
// WORK //
// ///////
const multiWorker = new NodeResque.MultiWorker({
connection: connectionDetails,
queues: ['slowQueue']
}, jobs)
// normal worker emitters
multiWorker.on('start', (workerId) => { console.log(`worker[${workerId}] started`) })
multiWorker.on('end', (workerId) => { console.log(`worker[${workerId}] ended`) })
multiWorker.on('cleaning_worker', (workerId, worker, pid) => { console.log('cleaning old worker ' + worker) })
multiWorker.on('poll', (workerId, queue) => { console.log(`worker[${workerId}] polling ${queue}`) })
multiWorker.on('job', (workerId, queue, job) => { console.log(`worker[${workerId}] working job ${queue} ${JSON.stringify(job)}`) })
multiWorker.on('reEnqueue', (workerId, queue, job, plugin) => { console.log(`worker[${workerId}] reEnqueue job (${plugin}) ${queue} ${JSON.stringify(job)}`) })
multiWorker.on('success', (workerId, queue, job, result) => { console.log(`worker[${workerId}] job success ${queue} ${JSON.stringify(job)} >> ${result}`) })
multiWorker.on('failure', (workerId, queue, job, failure) => { console.log(`worker[${workerId}] job failure ${queue} ${JSON.stringify(job)} >> ${failure}`) })
multiWorker.on('error', (error, workerId, queue, job) => { console.log(`worker[${workerId}] error #{queue} ${JSON.stringify(job)} >> ${error}`) })
multiWorker.on('pause', (workerId) => { console.log(`worker[${workerId}] paused`) })
// multiWorker emitters
multiWorker.on('internalError', (error) => { console.log(error) })
multiWorker.on('multiWorkerAction', (verb, delay) => { console.log(`*** checked for worker status: ${verb} (event loop delay: ${delay}ms)`) })
multiWorker.start()
process.on('SIGINT', async () => {
await multiWorker.stop()
console.log('*** ALL STOPPED ***')
process.exit()
})
}