mirror of https://github.com/IoTcat/FDC.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
657 lines
16 KiB
657 lines
16 KiB
|
|
'use strict'; |
|
|
|
/* |
|
node-schedule |
|
A cron-like and not-cron-like job scheduler for Node. |
|
*/ |
|
|
|
var events = require('events'), |
|
util = require('util'), |
|
cronParser = require('cron-parser'), |
|
CronDate = require('cron-parser/lib/date'), |
|
lt = require('long-timeout'), |
|
sorted = require('sorted-array-functions'); |
|
|
|
/* Job object */ |
|
var anonJobCounter = 0; |
|
var scheduledJobs = {}; |
|
|
|
function isValidDate(date) { |
|
// Taken from http://stackoverflow.com/a/12372720/1562178 |
|
// If getTime() returns NaN it'll return false anyway |
|
return date.getTime() === date.getTime(); |
|
} |
|
|
|
function Job(name, job, callback) { |
|
// setup a private pendingInvocations variable |
|
var pendingInvocations = []; |
|
|
|
//setup a private number of invocations variable |
|
var triggeredJobs = 0; |
|
|
|
// Set scope vars |
|
var jobName = name && typeof name === 'string' ? name : '<Anonymous Job ' + (++anonJobCounter) + '>'; |
|
this.job = name && typeof name === 'function' ? name : job; |
|
|
|
// Make sure callback is actually a callback |
|
if (this.job === name) { |
|
// Name wasn't provided and maybe a callback is there |
|
this.callback = typeof job === 'function' ? job : false; |
|
} else { |
|
// Name was provided, and maybe a callback is there |
|
this.callback = typeof callback === 'function' ? callback : false; |
|
} |
|
|
|
// Check for generator |
|
if (typeof this.job === 'function' && |
|
this.job.prototype && |
|
this.job.prototype.next) { |
|
this.job = function() { |
|
return this.next().value; |
|
}.bind(this.job.call(this)); |
|
} |
|
|
|
// define properties |
|
Object.defineProperty(this, 'name', { |
|
value: jobName, |
|
writable: false, |
|
enumerable: true |
|
}); |
|
|
|
// method that require private access |
|
this.trackInvocation = function(invocation) { |
|
// add to our invocation list |
|
sorted.add(pendingInvocations, invocation, sorter); |
|
return true; |
|
}; |
|
this.stopTrackingInvocation = function(invocation) { |
|
var invIdx = pendingInvocations.indexOf(invocation); |
|
if (invIdx > -1) { |
|
pendingInvocations.splice(invIdx, 1); |
|
return true; |
|
} |
|
|
|
return false; |
|
}; |
|
this.triggeredJobs = function() { |
|
return triggeredJobs; |
|
}; |
|
this.setTriggeredJobs = function(triggeredJob) { |
|
triggeredJobs = triggeredJob; |
|
}; |
|
this.cancel = function(reschedule) { |
|
reschedule = (typeof reschedule == 'boolean') ? reschedule : false; |
|
|
|
var inv, newInv; |
|
var newInvs = []; |
|
for (var j = 0; j < pendingInvocations.length; j++) { |
|
inv = pendingInvocations[j]; |
|
|
|
cancelInvocation(inv); |
|
|
|
if (reschedule && (inv.recurrenceRule.recurs || inv.recurrenceRule.next)) { |
|
newInv = scheduleNextRecurrence(inv.recurrenceRule, this, inv.fireDate, inv.endDate); |
|
if (newInv !== null) { |
|
newInvs.push(newInv); |
|
} |
|
} |
|
} |
|
|
|
pendingInvocations = []; |
|
|
|
for (var k = 0; k < newInvs.length; k++) { |
|
this.trackInvocation(newInvs[k]); |
|
} |
|
|
|
// remove from scheduledJobs if reschedule === false |
|
if (!reschedule) { |
|
if (this.name) { |
|
delete scheduledJobs[this.name]; |
|
} |
|
} |
|
|
|
return true; |
|
}; |
|
this.cancelNext = function(reschedule) { |
|
reschedule = (typeof reschedule == 'boolean') ? reschedule : true; |
|
|
|
if (!pendingInvocations.length) { |
|
return false; |
|
} |
|
|
|
var newInv; |
|
var nextInv = pendingInvocations.shift(); |
|
|
|
cancelInvocation(nextInv); |
|
|
|
if (reschedule && (nextInv.recurrenceRule.recurs || nextInv.recurrenceRule.next)) { |
|
newInv = scheduleNextRecurrence(nextInv.recurrenceRule, this, nextInv.fireDate, nextInv.endDate); |
|
if (newInv !== null) { |
|
this.trackInvocation(newInv); |
|
} |
|
} |
|
|
|
return true; |
|
}; |
|
this.reschedule = function(spec) { |
|
var inv; |
|
var cInvs = pendingInvocations.slice(); |
|
|
|
for (var j = 0; j < cInvs.length; j++) { |
|
inv = cInvs[j]; |
|
|
|
cancelInvocation(inv); |
|
} |
|
|
|
pendingInvocations = []; |
|
|
|
if (this.schedule(spec)) { |
|
this.setTriggeredJobs(0); |
|
return true; |
|
} else { |
|
pendingInvocations = cInvs; |
|
return false; |
|
} |
|
}; |
|
this.nextInvocation = function() { |
|
if (!pendingInvocations.length) { |
|
return null; |
|
} |
|
return pendingInvocations[0].fireDate; |
|
}; |
|
this.pendingInvocations = function() { |
|
return pendingInvocations; |
|
}; |
|
} |
|
|
|
util.inherits(Job, events.EventEmitter); |
|
|
|
Job.prototype.invoke = function(fireDate) { |
|
if (typeof this.job == 'function') { |
|
this.setTriggeredJobs(this.triggeredJobs() + 1); |
|
this.job(fireDate); |
|
} else { |
|
this.job.execute(fireDate); |
|
} |
|
}; |
|
|
|
Job.prototype.runOnDate = function(date) { |
|
return this.schedule(date); |
|
}; |
|
|
|
Job.prototype.schedule = function(spec) { |
|
var self = this; |
|
var success = false; |
|
var inv; |
|
var start; |
|
var end; |
|
var tz; |
|
|
|
// save passed-in value before 'spec' is replaced |
|
if (typeof spec === 'object' && 'tz' in spec) { |
|
tz = spec.tz; |
|
} |
|
|
|
if (typeof spec === 'object' && spec.rule) { |
|
start = spec.start || undefined; |
|
end = spec.end || undefined; |
|
spec = spec.rule; |
|
|
|
if (start) { |
|
if (!(start instanceof Date)) { |
|
start = new Date(start); |
|
} |
|
|
|
start = new CronDate(start, tz); |
|
if (!isValidDate(start) || start.getTime() < Date.now()) { |
|
start = undefined; |
|
} |
|
} |
|
|
|
if (end && !(end instanceof Date) && !isValidDate(end = new Date(end))) { |
|
end = undefined; |
|
} |
|
|
|
if (end) { |
|
end = new CronDate(end, tz); |
|
} |
|
} |
|
|
|
try { |
|
var res = cronParser.parseExpression(spec, { currentDate: start, tz: tz }); |
|
inv = scheduleNextRecurrence(res, self, start, end); |
|
if (inv !== null) { |
|
success = self.trackInvocation(inv); |
|
} |
|
} catch (err) { |
|
var type = typeof spec; |
|
if ((type === 'string') || (type === 'number')) { |
|
spec = new Date(spec); |
|
} |
|
|
|
if ((spec instanceof Date) && (isValidDate(spec))) { |
|
spec = new CronDate(spec); |
|
if (spec.getTime() >= Date.now()) { |
|
inv = new Invocation(self, spec); |
|
scheduleInvocation(inv); |
|
success = self.trackInvocation(inv); |
|
} |
|
} else if (type === 'object') { |
|
if (!(spec instanceof RecurrenceRule)) { |
|
var r = new RecurrenceRule(); |
|
if ('year' in spec) { |
|
r.year = spec.year; |
|
} |
|
if ('month' in spec) { |
|
r.month = spec.month; |
|
} |
|
if ('date' in spec) { |
|
r.date = spec.date; |
|
} |
|
if ('dayOfWeek' in spec) { |
|
r.dayOfWeek = spec.dayOfWeek; |
|
} |
|
if ('hour' in spec) { |
|
r.hour = spec.hour; |
|
} |
|
if ('minute' in spec) { |
|
r.minute = spec.minute; |
|
} |
|
if ('second' in spec) { |
|
r.second = spec.second; |
|
} |
|
|
|
spec = r; |
|
} |
|
|
|
spec.tz = tz; |
|
inv = scheduleNextRecurrence(spec, self, start, end); |
|
if (inv !== null) { |
|
success = self.trackInvocation(inv); |
|
} |
|
} |
|
} |
|
|
|
scheduledJobs[this.name] = this; |
|
return success; |
|
}; |
|
|
|
/* API |
|
invoke() |
|
runOnDate(date) |
|
schedule(date || recurrenceRule || cronstring) |
|
cancel(reschedule = false) |
|
cancelNext(reschedule = true) |
|
|
|
Property constraints |
|
name: readonly |
|
job: readwrite |
|
*/ |
|
|
|
/* DoesntRecur rule */ |
|
var DoesntRecur = new RecurrenceRule(); |
|
DoesntRecur.recurs = false; |
|
|
|
/* Invocation object */ |
|
function Invocation(job, fireDate, recurrenceRule, endDate) { |
|
this.job = job; |
|
this.fireDate = fireDate; |
|
this.endDate = endDate; |
|
this.recurrenceRule = recurrenceRule || DoesntRecur; |
|
|
|
this.timerID = null; |
|
} |
|
|
|
function sorter(a, b) { |
|
return (a.fireDate.getTime() - b.fireDate.getTime()); |
|
} |
|
|
|
/* Range object */ |
|
function Range(start, end, step) { |
|
this.start = start || 0; |
|
this.end = end || 60; |
|
this.step = step || 1; |
|
} |
|
|
|
Range.prototype.contains = function(val) { |
|
if (this.step === null || this.step === 1) { |
|
return (val >= this.start && val <= this.end); |
|
} else { |
|
for (var i = this.start; i < this.end; i += this.step) { |
|
if (i === val) { |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
}; |
|
|
|
/* RecurrenceRule object */ |
|
/* |
|
Interpreting each property: |
|
null - any value is valid |
|
number - fixed value |
|
Range - value must fall in range |
|
array - value must validate against any item in list |
|
|
|
NOTE: Cron months are 1-based, but RecurrenceRule months are 0-based. |
|
*/ |
|
function RecurrenceRule(year, month, date, dayOfWeek, hour, minute, second) { |
|
this.recurs = true; |
|
|
|
this.year = (year == null) ? null : year; |
|
this.month = (month == null) ? null : month; |
|
this.date = (date == null) ? null : date; |
|
this.dayOfWeek = (dayOfWeek == null) ? null : dayOfWeek; |
|
this.hour = (hour == null) ? null : hour; |
|
this.minute = (minute == null) ? null : minute; |
|
this.second = (second == null) ? 0 : second; |
|
} |
|
|
|
RecurrenceRule.prototype.isValid = function() { |
|
function isValidType(num) { |
|
if (Array.isArray(num) || (num instanceof Array)) { |
|
return num.every(function(e) { |
|
return isValidType(e); |
|
}); |
|
} |
|
return !(Number.isNaN(Number(num)) && !(num instanceof Range)); |
|
} |
|
if (this.month !== null && (this.month < 0 || this.month > 11 || !isValidType(this.month))) { |
|
return false; |
|
} |
|
if (this.dayOfWeek !== null && (this.dayOfWeek < 0 || this.dayOfWeek > 6 || !isValidType(this.dayOfWeek))) { |
|
return false; |
|
} |
|
if (this.hour !== null && (this.hour < 0 || this.hour > 23 || !isValidType(this.hour))) { |
|
return false; |
|
} |
|
if (this.minute !== null && (this.minute < 0 || this.minute > 59 || !isValidType(this.minute))) { |
|
return false; |
|
} |
|
if (this.second !== null && (this.second < 0 || this.second > 59 || !isValidType(this.second))) { |
|
return false; |
|
} |
|
if (this.date !== null) { |
|
if(!isValidType(this.date)) { |
|
return false; |
|
} |
|
switch (this.month) { |
|
case 3: |
|
case 5: |
|
case 8: |
|
case 10: |
|
if (this.date < 1 || this. date > 30) { |
|
return false; |
|
} |
|
break; |
|
case 1: |
|
if (this.date < 1 || this. date > 29) { |
|
return false; |
|
} |
|
break; |
|
default: |
|
if (this.date < 1 || this. date > 31) { |
|
return false; |
|
} |
|
} |
|
} |
|
return true; |
|
}; |
|
|
|
RecurrenceRule.prototype.nextInvocationDate = function(base) { |
|
var next = this._nextInvocationDate(base); |
|
return next ? next.toDate() : null; |
|
}; |
|
|
|
RecurrenceRule.prototype._nextInvocationDate = function(base) { |
|
base = ((base instanceof CronDate) || (base instanceof Date)) ? base : (new Date()); |
|
if (!this.recurs) { |
|
return null; |
|
} |
|
|
|
if(!this.isValid()) { |
|
return null; |
|
} |
|
|
|
var now = new CronDate(Date.now(), this.tz); |
|
var fullYear = now.getFullYear(); |
|
if ((this.year !== null) && |
|
(typeof this.year == 'number') && |
|
(this.year < fullYear)) { |
|
return null; |
|
} |
|
|
|
var next = new CronDate(base.getTime(), this.tz); |
|
next.addSecond(); |
|
|
|
while (true) { |
|
if (this.year !== null) { |
|
fullYear = next.getFullYear(); |
|
if ((typeof this.year == 'number') && (this.year < fullYear)) { |
|
next = null; |
|
break; |
|
} |
|
|
|
if (!recurMatch(fullYear, this.year)) { |
|
next.addYear(); |
|
next.setMonth(0); |
|
next.setDate(1); |
|
next.setHours(0); |
|
next.setMinutes(0); |
|
next.setSeconds(0); |
|
continue; |
|
} |
|
} |
|
if (this.month != null && !recurMatch(next.getMonth(), this.month)) { |
|
next.addMonth(); |
|
continue; |
|
} |
|
if (this.date != null && !recurMatch(next.getDate(), this.date)) { |
|
next.addDay(); |
|
continue; |
|
} |
|
if (this.dayOfWeek != null && !recurMatch(next.getDay(), this.dayOfWeek)) { |
|
next.addDay(); |
|
continue; |
|
} |
|
if (this.hour != null && !recurMatch(next.getHours(), this.hour)) { |
|
next.addHour(); |
|
continue; |
|
} |
|
if (this.minute != null && !recurMatch(next.getMinutes(), this.minute)) { |
|
next.addMinute(); |
|
continue; |
|
} |
|
if (this.second != null && !recurMatch(next.getSeconds(), this.second)) { |
|
next.addSecond(); |
|
continue; |
|
} |
|
|
|
break; |
|
} |
|
|
|
return next; |
|
}; |
|
|
|
function recurMatch(val, matcher) { |
|
if (matcher == null) { |
|
return true; |
|
} |
|
|
|
if (typeof matcher === 'number') { |
|
return (val === matcher); |
|
} else if(typeof matcher === 'string') { |
|
return (val === Number(matcher)); |
|
} else if (matcher instanceof Range) { |
|
return matcher.contains(val); |
|
} else if (Array.isArray(matcher) || (matcher instanceof Array)) { |
|
for (var i = 0; i < matcher.length; i++) { |
|
if (recurMatch(val, matcher[i])) { |
|
return true; |
|
} |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
/* Date-based scheduler */ |
|
function runOnDate(date, job) { |
|
var now = Date.now(); |
|
var then = date.getTime(); |
|
|
|
return lt.setTimeout(function() { |
|
if (then > Date.now()) |
|
runOnDate(date, job); |
|
else |
|
job(); |
|
}, (then < now ? 0 : then - now)); |
|
} |
|
|
|
var invocations = []; |
|
var currentInvocation = null; |
|
|
|
function scheduleInvocation(invocation) { |
|
sorted.add(invocations, invocation, sorter); |
|
prepareNextInvocation(); |
|
var date = invocation.fireDate instanceof CronDate ? invocation.fireDate.toDate() : invocation.fireDate; |
|
invocation.job.emit('scheduled', date); |
|
} |
|
|
|
function prepareNextInvocation() { |
|
if (invocations.length > 0 && currentInvocation !== invocations[0]) { |
|
if (currentInvocation !== null) { |
|
lt.clearTimeout(currentInvocation.timerID); |
|
currentInvocation.timerID = null; |
|
currentInvocation = null; |
|
} |
|
|
|
currentInvocation = invocations[0]; |
|
|
|
var job = currentInvocation.job; |
|
var cinv = currentInvocation; |
|
currentInvocation.timerID = runOnDate(currentInvocation.fireDate, function() { |
|
currentInvocationFinished(); |
|
|
|
if (job.callback) { |
|
job.callback(); |
|
} |
|
|
|
if (cinv.recurrenceRule.recurs || cinv.recurrenceRule._endDate === null) { |
|
var inv = scheduleNextRecurrence(cinv.recurrenceRule, cinv.job, cinv.fireDate, cinv.endDate); |
|
if (inv !== null) { |
|
inv.job.trackInvocation(inv); |
|
} |
|
} |
|
|
|
job.stopTrackingInvocation(cinv); |
|
|
|
job.invoke(cinv.fireDate instanceof CronDate ? cinv.fireDate.toDate() : cinv.fireDate); |
|
job.emit('run'); |
|
}); |
|
} |
|
} |
|
|
|
function currentInvocationFinished() { |
|
invocations.shift(); |
|
currentInvocation = null; |
|
prepareNextInvocation(); |
|
} |
|
|
|
function cancelInvocation(invocation) { |
|
var idx = invocations.indexOf(invocation); |
|
if (idx > -1) { |
|
invocations.splice(idx, 1); |
|
if (invocation.timerID !== null) { |
|
lt.clearTimeout(invocation.timerID); |
|
} |
|
|
|
if (currentInvocation === invocation) { |
|
currentInvocation = null; |
|
} |
|
|
|
invocation.job.emit('canceled', invocation.fireDate); |
|
prepareNextInvocation(); |
|
} |
|
} |
|
|
|
/* Recurrence scheduler */ |
|
function scheduleNextRecurrence(rule, job, prevDate, endDate) { |
|
|
|
prevDate = (prevDate instanceof CronDate) ? prevDate : new CronDate(); |
|
|
|
var date = (rule instanceof RecurrenceRule) ? rule._nextInvocationDate(prevDate) : rule.next(); |
|
if (date === null) { |
|
return null; |
|
} |
|
|
|
if ((endDate instanceof CronDate) && date.getTime() > endDate.getTime()) { |
|
return null; |
|
} |
|
|
|
var inv = new Invocation(job, date, rule, endDate); |
|
scheduleInvocation(inv); |
|
|
|
return inv; |
|
} |
|
|
|
/* Convenience methods */ |
|
function scheduleJob() { |
|
if (arguments.length < 2) { |
|
return null; |
|
} |
|
|
|
var name = (arguments.length >= 3 && typeof arguments[0] === 'string') ? arguments[0] : null; |
|
var spec = name ? arguments[1] : arguments[0]; |
|
var method = name ? arguments[2] : arguments[1]; |
|
var callback = name ? arguments[3] : arguments[2]; |
|
|
|
var job = new Job(name, method, callback); |
|
|
|
if (job.schedule(spec)) { |
|
return job; |
|
} |
|
|
|
return null; |
|
} |
|
|
|
function rescheduleJob(job, spec) { |
|
if (job instanceof Job) { |
|
if (job.reschedule(spec)) { |
|
return job; |
|
} |
|
} else if (typeof job == 'string' || job instanceof String) { |
|
if (job in scheduledJobs && scheduledJobs.hasOwnProperty(job)) { |
|
if (scheduledJobs[job].reschedule(spec)) { |
|
return scheduledJobs[job]; |
|
} |
|
} |
|
} |
|
return null; |
|
} |
|
|
|
function cancelJob(job) { |
|
var success = false; |
|
if (job instanceof Job) { |
|
success = job.cancel(); |
|
} else if (typeof job == 'string' || job instanceof String) { |
|
if (job in scheduledJobs && scheduledJobs.hasOwnProperty(job)) { |
|
success = scheduledJobs[job].cancel(); |
|
} |
|
} |
|
|
|
return success; |
|
} |
|
|
|
/* Public API */ |
|
module.exports.Job = Job; |
|
module.exports.Range = Range; |
|
module.exports.RecurrenceRule = RecurrenceRule; |
|
module.exports.Invocation = Invocation; |
|
module.exports.scheduleJob = scheduleJob; |
|
module.exports.rescheduleJob = rescheduleJob; |
|
module.exports.scheduledJobs = scheduledJobs; |
|
module.exports.cancelJob = cancelJob;
|
|
|