var initJob = function(){
var CronJob = require('cron').CronJob;
// define the job
var job = new CronJob({
cronTime: interval || '00 30 16 * * 1-5',
onTick: function() {
console.log('[scheduler] Starting run to ' + httpOptions.host);
Update.run(httpOptions).then(function(data){
console.log('[scheduler] Call succeeded. Running task...');
if (task) {
task(data);
}
});
},
start: false,
timeZone: 'America/Toronto'
});
// start the job
job.start();
// finish init request
var response = {
host: httpOptions.host,
path: httpOptions.path,
port: httpOptions.port,
interval: interval,
status: 'started'
};
d.resolve(response);
};
// Initialise the task
function initTask(config, app) {
if (!config.cron) {
config.cron = '0 30 0 * * *'; // 00:30 daily
}
var job = new CronJob(config.cron, run.bind(null, app));
job.start();
}
http.createServer(app).listen(app.get('port'), function(){
// create blog models
var Blog = mongoose.model("Blog");
CONFIG.blogs.forEach(function(blogspec) {
Blog.create(blogspec).then(function(blog) {
winston.log("info", "success to create blog object: " + blog.title);
}, function(err) {
// ignore the error
});
});
// every one minute
var job = new cronJob({
cronTime: "*/1 * * * *",
onTick: function() {
Blog.find({}, function(err, blogs) {
blogs.forEach(function(blog) {
blog.scrapingNewArticlesFromRSS()
.then(function(articles) {
winston.log("info", articles.length + " articles updated");
})
.fail(function(err) {
winston.log("warn", "articles cannot be updated");
});
});
});
},
start: false
});
job.start();
winston.log("info", 'Express server listening on port ' + app.get('port'));
});
var db = mongoose.connect(config.db, function (err) {
if (err) {
console.error('\x1b[31m', 'Could not connect to MongoDB!');
console.log(err);
}
else {
// Init the express application
var app = require('./config/express')(db);
// Bootstrap passport config
require('./config/passport')();
// Start the app by listening on <port>
app.listen(config.port);
// Expose app
exports = module.exports = app;
// Ideally, the timeout check stuff would be in a separate process, but then I'm not sure Heroku would be
// quite as free any more...
var cron = require('cron');
var timeoutCheck = require('./utilities/timeoutcheck');
try {
var timeoutCheckJob = new cron.CronJob('*/1 * * * *', timeoutCheck.check);
timeoutCheckJob.start();
} catch(e) {
console.log('exception setting up cron job: ' + e);
}
// Logging initialization
console.log('MEAN.JS application started on port ' + config.port);
}
});
module.exports.start=function() {
//console.log("starting monitoring for alerts");
// scheduler
var job = new CronJob('0 */5 * * * *',
function(){
// console.log("hello");
alertdef.getAllAlertDefinitions().then(function(result){
for(var i=0;i<result.length;i++) {
var alert=result[i];
alert.shouldAlert().then(function(result){
if(result[0]) {
alert.sendEmail(result).then(function(result){
console.log(result);
},function(err){
console.log(err);
})
}
});
}
});
},
null,
true,
"America/Los_Angeles");
job.start();
};
function runCron(cronLine) {
var cronElements = splitWithTail(cronLine, ' ', 5);
var command = cronElements.pop();
var handle;
var schedule = cronElements.join(' ');
console.log("Loading cron:", "'" + schedule + "'", "with command", "'" + command + "'");
var job = new CronJob(schedule, function() {
if (handle) {
console.error("Process still running after next cron run", cronLine);
handle.kill('SIGKILL');
}
var start = new Date().getTime();
handle = childProcess.exec(command, function(err, stdout, stderr) {
if (err) {
return console.error("Error during running cron", cronLine, err.toString());
}
var runTime = new Date().getTime() - start;
if (runTime > 5000) {
console.warn('Command running too long from cron', "'" + cronLine + "'", runTime, "ms");
}
console.log(command, ':', stdout.toString(), stderr.toString());
handle = null;
});
});
job.start();
}
function refreshToken(redisClient) {
console.log('connect to redis successful');
console.log('');
console.log('A Refresh Token job is working at ' + moment().format("YYYY/MM/DD HH:mm:ss"));
console.log('==============================================================================');
worker(redisClient);
var job = new CronJob('0 */1 * * *', function() {
console.log('');
console.log('A Refresh Token job is working at ' + moment().format("YYYY/MM/DD HH:mm:ss"));
console.log('==============================================================================');
worker(redisClient);
}, function () {
/* This function is executed when the job stops */
},
true, /* Start the job right now */
'Asia/Shanghai' /* Time zone of this job. */
);
job.start();
}
bot.startRTM(function (err) {
if (!err) {
trackBot(bot);
}
bot.startPrivateConversation({user: config.createdBy}, function (err, convo) {
if (err) {
console.log(err);
} else {
convo.say("I'm consciousness. I'm alive. I'm Chappie.")
convo.say('Type `help` to know more about how we can converse...')
}
});
// Ask user every 20 mins
var job = new CronJob({
cronTime: "0 0 16 * * 0-4",
onTick: function () {
console.log('Calling askAboutTomorrow')
WfhHandler.askAboutTomorrow(controller, bot)
},
start: false,
timeZone: 'Asia/Kolkata'
});
job.start();
});
return () => {
sendMsg(sample(sentences).text, channel);
let job = new CronJob(schedule, () => {
sendMsg(sample(sentences).text, channel);
}, null, false, 'Europe/Berlin');
job.start();
};
fs.readFile(params.key, {encoding: 'utf-8'}, function(err, data){
if (!err){
self.auth = new google.auth.JWT(
params.email,
null, //this would be the path to to the key file
data, //this is the key file's content
params.scope
);
// setup cron to authorize auth client every 30 minutes
var authorizeServiceAccount = function(){
// authorize service account
self.auth.authorize(function(err, tokens) {
if(err) console.error('Can\'t authorize Google Service Account', err);
console.log('Google Service Account authorized', tokens);
google.options({ auth: self.auth })
})
}
var authJob = new cron.CronJob({
cronTime: params.cronTimePattern || "0 */15 * * * *",
onTick: authorizeServiceAccount
});
authJob.start();
authorizeServiceAccount();
}else{
console.error('Google JWT Autentification failed', err);
}
})
CroneHandler.CroneDataRecorder(req.body,company,tenant, function (error,result) {
console.log("---------------------- length start -------------------"+Jobs);
if(error)
{
var jsonString = messageFormatter.FormatMessage(error, "ERROR", false, undefined);
logger.debug('[DVP-CronScheduler.New Cron] - [%s] - Error',reqId,jsonString);
res.end(jsonString);
}
else
{
var job=new cronJob(pattern, function() {
CroneHandler.CronCallbackHandler(reqId,result.Company,result.Tenant, function (err,response) {
if(err)
{
console.log(err);
}
else
{
if(checkDate)
{
delete Jobs[reqId];
CroneHandler.JobRemover(reqId,company,tenant, function (errRemove,resRemove) {
if(errRemove)
{
console.log("Error in object cache removing");
}
else
{
console.log("Object cache removed successfully");
}
});
}
}
});
}, null, false,req.body.Timezone);
Jobs[reqId] =job;
job.start();
var jsonString = messageFormatter.FormatMessage(undefined, "SUCCESS", true, reqId);
logger.debug('[DVP-CronScheduler.New Cron] - [%s] - Successfully saved',reqId,jsonString);
res.end(jsonString);
}
});
export function start() {
DEBUG('Setting up cron jobs');
const cron = new CronJob({
cronTime: EVERY_MIDNIGHT,
timeZone: TIMEZONE,
onTick: () => ChiaDAO.reset()
});
cron.start();
}
mongoose.connect(process.env.MONGOHQ_URL || process.env.MONGOLAB_URL ||'mongodb://localhost/tesla', function(err){
if(err){
console.log("Database connection failed, not using features requiring database");
}
else {
updateDriveStateJob.start();
informDepartureOrArrivalJob.start();
}
});
var start = function start() {
var myCron = new CronJob('*/10 * * * *', function() {
console.log('[CRON] Running pullFromMongo()');
pull();
}, function() {
console.log('[CRON] Done running pullFromMongo()');
}, true);
myCron.start();
};
function schedule(options, node){
var job = new CronJob({
cronTime: options.time,
onTick: function() {
node.createReport();
},
start: false
});
job.start();
}
//
// Cron pattern like to force app to restart
//
function cronize(cron_pattern) {
var cronJob = require('cron').CronJob;
var job = new cronJob({
cronTime: cron_pattern,
onTick: function() {
process.exit(0);
},
start: false
});
job.start();
}
CroneHandler.CroneObjectUpdater(croneId,company,tenant,req.body, function (err,response) {
if(err)
{
var jsonString = messageFormatter.FormatMessage(err, "ERROR", false, undefined);
logger.debug('[DVP-CronScheduler.update Cron] - [%s] - Updation error',reqId,jsonString);
res.end(jsonString);
}
else
{
var job=new cronJob(pattern, function() {
CroneHandler.CronCallbackHandler(croneId,company,tenant, function (err,response) {
if(err)
{
console.log(err);
}
else
{
if(checkDate)
{
delete Jobs[croneId];
CroneHandler.JobRemover(croneId,company,tenant, function (errRemove,resRemove) {
if(errRemove)
{
console.log("Error in object cache removing");
}
else
{
console.log("Object cache removed successfully");
}
});
}
}
});
}, null, false,req.body.Timezone);
Jobs[croneId] =job;
job.start();
var jsonString = messageFormatter.FormatMessage(undefined, "SUCCESS", true, response);
logger.debug('[DVP-CronScheduler.update Cron] - [%s] - Updation success',reqId,jsonString);
res.end(jsonString);
}
});
Pooler.startCron = function() {
var CronJob = require("cron").CronJob;
var job = new CronJob({
cronTime: "*/30 * * * * *",
onTick: function() {
Pooler.feedDataAllLanguages(function() {});
},
start: true
});
job.start();
};
module.exports = function() {
var job = new CronJob({
cronTime: '5 * * * * *',
onTick: function() {
archive.downloadUrls();
console.log("CRON TIMEEEEEEE!");
},
start: true,
timeZone: 'America/Los_Angeles'
});
job.start();
};
module.exports = function(f, w, p)
{
if(w !== undefined) weeks = w;
if(p !== undefined) cronPattern = p;
if(f !== undefined) file = f;
var job = new CronJob({
cronTime: cronPattern,
onTick: onTick,
start: false
});
job.start();
};
function submit(crontime, jobFunc, options){
var job = new cronJob({
cronTime: crontime,
onTick: jobFunc,
start: options && options.start ? options.start : false,
timeZone: options && options.tz ? options.tz : "US/Central"
});
if(undefined !== options &&
true === options.start){
job.start();
}
return job;
}
function setup(config, db, ar, cb) {
const job = new cron.CronJob({
cronTime: ar.schedule,
onTick: (function() {
run(config, db, ar._id);
}),
start: false,
timeZone: 'Europe/Berlin',
});
jobs.set(ar._id, job);
job.start();
cb();
}
_.forEach(self.runAt, function(runAt) {
if(!_.isString(runAt)) {
log(ErrorMessages.cronPatternIsInvalid);
} else {
try {
var checkFileJob = new cron.CronJob(runAt, self.checkAndGetNewFile, self.onCronComplete);
checkFileJob.start();
self.cronJobs.push(checkFileJob);
} catch(err) {
log(ErrorMessages.cronPatternIsInvalid);
}
}
});
main.on ('activateDB', () => {
ws.log("Start activating DB...");
ws.log("Removing previous programs...");
cancelAllSessions();
ws.log("Done");
for (var i=0;i<db.programs.length;i++) {
if (db.programs[i].enabled) {
ws.log("Activating program '"+db.programs[i].name+"'");
for (var j=0;j<db.programs[i].valves.length;j++) {
var valve = db.programs[i].valves[j];
var dependentValvesIDs = [];
if (valve.hasOwnProperty('dependentValvesIDs')) {
dependentValvesIDs.push(valve.dependentValvesIDs);
}
ws.log("Scheduling valve '" + valve.name + "' - " + valve.ID);
for (var k=0;k<valve.sessions.length;k++) {
var session = valve.sessions[k];
if (session.enabled) {
const id = [];
const duration = session.schedule.duration;
id.push(valve.ID);
id.push(dependentValvesIDs);
var cronExp = getCronExp(session.schedule);
var job = new CronJob({
cronTime: cronExp,
onTick: function() {
openValve(id, duration);
},
start: false
});
ws.log("cron: " + cronExp + " - for " + session.schedule.duration + " minutes");
job.start();
addSession(session, job);
}
}
}
}
}
ws.log("DB is activated successfully!");
});
function retryStart(func_name,stall) {
// body...
pushInventoryJob.stop();
pullTimeOutTries--;
if(pullTimeOutTries > 0) {
startOfDayOptions.cronTime = '*/'+stall+' * * * *';
startOfDayOptions.onTick = func_name;
pushInventoryJob = new cronJob(startOfDayOptions);
pushInventoryJob.start();
} else {
startSyncOptions();
console.log("TIMEOUT TRIES REACHED. Further operations will be aborted.");
}
}
function _runJob (id, schedule, mode) {
var job = new cron({
cronTime: schedule,
onTick: function () {
if (mode === "run") instances._runInstance("ap-northeast-1", id);
if (mode === "stop") instances._stopInstance("ap-northeast-1", id);
},
start: false,
timeZone: "Japan/Tokyo"
});
job.start();
if (!_(defs).has("jobs")) defs["jobs"] = [];
defs.jobs.push(job);
}
fs.readJson(usecroncheckfile, function (err, data) {
if (err) {
logger.silly('do not use cron for origination');
}
else {
logger.silly('using cron for origination', data);
var automate_cloud_backup = new CronJob({
cronTime: backupconfig.cloud_backup_cron,
onTick: cron_automate_cloud_backup,
onComplete: function () {} //,
// start: true
});
automate_cloud_backup.start();
}
});
function initSyncOptions () {
//console.log('WTF!!');
if(pullInventoryJob)
pullInventoryJob.stop();
endOfDayOptions = {
cronTime : '30 23 * * *',
onTick : endOfDaySync,
start : false,
timeZone :'Singapore'
};
pullInventoryJob = new cronJob(endOfDayOptions);
pullInventoryJob.start();
resetTimeOutTries();
}
//
// Cron pattern like to force app to restart
//
/**
* Description
* @method cronize
* @param {} cron_pattern
* @return
*/
function cronize(cron_pattern) {
var cronJob = require('cron').CronJob;
var job = new cronJob({
cronTime: cron_pattern,
/**
* Description
* @method onTick
* @return
*/
onTick: function() {
process.exit(0);
},
start: false
});
job.start();
}
(function (schedule) {
var CronJob = require('cron').CronJob;
var data = require("../data");
var request = require('request');
var job = new CronJob({
cronTime: '1 1 1 * * *', //Todo: Fix the pattern to run every hour
onTick: function () {
console.log("calling zeus");
var log = {logs: [{"name": "health", "value": "OK" }]};
var logOptions = {
url: data.zeusUrl,
json: log
};
request.post(logOptions, function (error, response, body) {
console.log("called zeus");
console.log(error);
console.log(body);
});
},
start: true,
timeZone: null
});
schedule.init = function () {
job.start();
};
})(module.exports);