1 import { forever, queue } from 'async'
2 import * as Sequelize from 'sequelize'
4 import { database as db } from '../../initializers/database'
6 JOBS_FETCHING_INTERVAL,
7 JOBS_FETCH_LIMIT_PER_CYCLE,
9 } from '../../initializers'
10 import { logger } from '../../helpers'
11 import { JobInstance } from '../../models'
12 import { JobHandler, jobHandlers } from './handlers'
14 type JobQueueCallback = (err: Error) => void
18 private static instance: JobScheduler
20 private constructor () { }
22 static get Instance () {
23 return this.instance || (this.instance = new this())
27 const limit = JOBS_FETCH_LIMIT_PER_CYCLE
29 logger.info('Jobs scheduler activated.')
31 const jobsQueue = queue<JobInstance, JobQueueCallback>(this.processJob.bind(this))
33 // Finish processing jobs from a previous start
34 const state = JOB_STATES.PROCESSING
35 db.Job.listWithLimit(limit, state, (err, jobs) => {
36 this.enqueueJobs(err, jobsQueue, jobs)
40 if (jobsQueue.length() !== 0) {
41 // Finish processing the queue first
42 return setTimeout(next, JOBS_FETCHING_INTERVAL)
45 const state = JOB_STATES.PENDING
46 db.Job.listWithLimit(limit, state, (err, jobs) => {
48 logger.error('Cannot list pending jobs.', { error: err })
55 // Optimization: we could use "drain" from queue object
56 return setTimeout(next, JOBS_FETCHING_INTERVAL)
60 err => { logger.error('Error in job scheduler queue.', { error: err }) }
65 createJob (transaction: Sequelize.Transaction, handlerName: string, handlerInputData: object, callback: (err: Error) => void) {
67 state: JOB_STATES.PENDING,
71 const options = { transaction }
73 db.Job.create(createQuery, options).asCallback(callback)
76 private enqueueJobs (err: Error, jobsQueue: AsyncQueue<JobInstance>, jobs: JobInstance[]) {
78 logger.error('Cannot list pending jobs.', { error: err })
86 private processJob (job: JobInstance, callback: (err: Error) => void) {
87 const jobHandler = jobHandlers[job.handlerName]
89 logger.info('Processing job %d with handler %s.', job.id, job.handlerName)
91 job.state = JOB_STATES.PROCESSING
92 job.save().asCallback(err => {
93 if (err) return this.cannotSaveJobError(err, callback)
95 if (jobHandler === undefined) {
96 logger.error('Unknown job handler for job %s.', job.handlerName)
100 return jobHandler.process(job.handlerInputData, (err, result) => {
102 logger.error('Error in job handler %s.', job.handlerName, { error: err })
103 return this.onJobError(jobHandler, job, result, callback)
106 return this.onJobSuccess(jobHandler, job, result, callback)
111 private onJobError (jobHandler: JobHandler<any>, job: JobInstance, jobResult: any, callback: (err: Error) => void) {
112 job.state = JOB_STATES.ERROR
114 job.save().asCallback(err => {
115 if (err) return this.cannotSaveJobError(err, callback)
117 return jobHandler.onError(err, job.id, jobResult, callback)
121 private onJobSuccess (jobHandler: JobHandler<any>, job: JobInstance, jobResult: any, callback: (err: Error) => void) {
122 job.state = JOB_STATES.SUCCESS
124 job.save().asCallback(err => {
125 if (err) return this.cannotSaveJobError(err, callback)
127 return jobHandler.onSuccess(err, job.id, jobResult, callback)
131 private cannotSaveJobError (err: Error, callback: (err: Error) => void) {
132 logger.error('Cannot save new job state.', { error: err })
137 // ---------------------------------------------------------------------------