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.
658 lines
16 KiB
658 lines
16 KiB
5 years ago
|
|
||
|
'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;
|