agenda.purge(function () {
agenda.define('resolve actions', function (job, callback) {
resolve(callback);
});
agenda.define('execute actions', function (job, callback) {
execute(callback);
});
agenda.every('30 seconds', 'resolve actions');
agenda.every('1 minute', 'execute actions');
agenda.on('start', function (job) {
timing.start(job.attrs.name);
logger.info({message: 'job started', job: job.attrs.name });
});
agenda.on('success', function (job) {
var duration = timing.finish(job.attrs.name);
logger.success({message: 'job compeleted', job: job.attrs.name, duration: duration.asMilliseconds()});
});
agenda.on('fail', function (err, job) {
logger.error({message: 'job failed', job: job.attrs.name, err: err});
});
agenda.start();
});
agenda.purge(function () {
agenda.define('resolve actions', function (job, callback) {
handler('created', 'resolve', callback);
});
agenda.define('execute actions', function (job, callback) {
handler('resolved', 'execute', callback);
});
agenda.every(util.format('%d seconds', config.jobs.run.resolve), 'resolve actions');
agenda.every(util.format('%d seconds', config.jobs.run.execute), 'execute actions');
agenda.on('start', function (job) {
timing.start(job.attrs.name);
});
agenda.on('success', function (job) {
var duration = timing.finish(job.attrs.name);
logger.info({message: 'job compeleted', job: job.attrs.name, duration: duration.asMilliseconds()});
});
agenda.on('fail', function (err, job) {
logger.error({message: 'job failed', job: job.attrs.name, err: err});
});
agenda.start();
});
module.exports = function(jobTypes) {
var Agenda = require('agenda');
var keystone = require('keystone'),
moment = require('moment');
var agenda = new Agenda({name: 'playgroundAgenda', defaultLockLifetime: 5000, db:{address: keystone.get('mongo'), collection: 'agendaJobs'}, maxConcurrency: 200});
agenda.processEvery('1 minute');
//***********LOGGING*************//
agenda.on('start', function(job) {
console.log("Job %s starting %s", job.attrs.name, moment().format("dddd, MMMM Do YYYY, h:mm:ss a"));
});
agenda.on('complete', function(job) {
console.log("Job %s finished %s", job.attrs.name, moment().format("dddd, MMMM Do YYYY, h:mm:ss a"));
});
agenda.on('fail', function(err, job) {
console.log("Job failed with error: %s %s", err.message, moment().format("dddd, MMMM Do YYYY, h:mm:ss a"));
});
//***********REGISTER JOBS*************//
jobTypes.forEach(function(type) {
require('./jobs/'+type)(agenda);
});
//***********START*************//
agenda.start();
return agenda;
}
module.exports = function () {
var self = this;
// Remove polls that have been closed for 2+ weeks.
agenda.define('remove closed polls', function (job, done) {
Poll.find({
created: {
$lte: moment.utc().subtract(14, 'weeks')
}
},
function (err, docs) {
if (err) {
return done(err);
}
docs.forEach(function (doc) {
doc.remove(function (err, doc) {
if (err) {
return done(err);
}
console.log('Poll removed: ' + JSON.stringify({
_id: doc._id,
closeTime: doc.closeTime,
creator: doc.creator.username
}));
});
});
done();
}
);
});
agenda.define('check twitch api status', function (job, done) {
// Twitch API Status
twitch.api(
'/', {
clientID: nconf.get('authkeys:twitchtv:clientID')
},
function (err, statusCode, response) {
if (err) {
console.log(err);
}
if (statusCode !== 200) {
self.locals.twitchStatus = false;
}
else {
self.locals.twitchStatus = true;
}
done();
}
);
});
agenda.on('ready', function () {
agenda.every('1 day', 'remove closed polls');
agenda.every('2 minutes', 'check twitch api status');
agenda.start();
});
};
module.exports = function (deps, callback) {
var mongoConnectionString = "mongodb://127.0.0.1:27017/agenda";
var agenda = new Agenda({db: {address: mongoConnectionString}});
['email', 'watchlist'].forEach(function(job){
require('./jobs/'+job)(deps, agenda);
});
agenda.on('ready', function() {
console.log('Agenda ready');
agenda.purge(function(err, numRemoved) {
console.log('purged count: ', numRemoved)
});
callback(null, agenda);
});
function graceful() {
agenda.stop(function() {
process.exit(0);
});
}
process.on('SIGTERM', graceful);
process.on('SIGINT' , graceful);
agenda.on('start', function(job) {
console.log(new Date(), " - Job %s starting", job.attrs.name);
});
agenda.on('success', function(job) {
console.log(new Date(), " - Job %s Successfully completed.", job.attrs.name);
});
agenda.on('fail', function(err, job) {
console.log(new Date(), " - Job %s failed with error: %s", job.attrs.name, err.message);
});
agenda.on('error', function(e){
console.log('**Agenda Error**');
console.log(e);
})
};
})(function (require, exports) {
"use strict";
var Agenda = require('agenda');
var bodyParser = require('body-parser');
var express = require('express');
var path = require('path');
var socketIo = require('socket.io');
var request = require('request');
var socketIoAuth = require('socketio-auth');
var app = express();
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
app.use(express.static(path.join(__dirname, 'public'), { maxAge: 86400 }));
app.use('/jspm_packages', express.static(path.join(__dirname, '../jspm_packages')));
var router = express.Router();
router.use(function (req, res, next) { return next(); });
router.route('/test').get(function (req, res) { return res.json({ test: 'ok' }); });
router.get('/config.js', function (req, res) { return res.sendFile(path.join(__dirname, '../config.js')); });
router.get('/socket.io-client.js', function (req, res) { return res.sendFile(path.join(__dirname, '../jspm_packages/npm/socket.io-client@1.4.6.js')); });
app.use('/', router);
var server = app.listen(3000, 'localhost', function () {
console.log('App listening at http://%s:%s', server.address().address, server.address().port);
console.log(__dirname);
});
var io = socketIo.listen(server);
socketIoAuth(io, {
authenticate: function (socket, data, callback) {
return callback(null, true);
}
});
io.sockets.on('connection', function (socket) {
console.log("user connected");
socket.emit('helloWorld', { hello: 'world' });
socket.on('refreshRepos', function (data) {
var url = "https://api.github.com/users/" + (data && data.user) + "/repos";
request(url, { json: true, headers: { 'user-agent': 'node.js' } }, function (err, response, data) {
socket.emit('reposRefreshed', data);
});
});
});
var mongoConnectionString = "mongodb://localhost/agenda";
var agenda = new Agenda({ db: { address: mongoConnectionString } });
agenda.define('test', function (job, done) {
console.log('agenda test');
done();
});
agenda.on('ready', function () {
agenda.every('10 minutes', 'test');
agenda.start();
});
});
module.exports = function(app, appPath, gfs){
if ('test' === app.get('env')) {
return;
}
// Agenda
var agenda = new Agenda();
agenda.database(config.db);
agenda.on('start', function(job) {
console.log('Job %s starting', job.attrs.name);
});
agenda.on('complete', function(job) {
console.log('Job %s finished', job.attrs.name);
});
util.walk(appPath + '/server/scheduled', null, function(path){
require(path)(app, agenda, gfs);
});
agenda.start();
};
var Agenda = require('agenda');
var winston = require('./winston');
var config = require('./environment');
var Settings = require('./../api/settings/settings.model');
// Agenda settings
var agenda = new Agenda({
db: {
address: config.mongo.uri,
collection: 'agenda'
}
});
// Agenda event to catch errors
agenda.on('fail', function(err, job) {
winston.error('agenda.js error: ' + err);
});
// Remove all jobs to avoid starting mutliple jobs
agenda.purge(function(err, numRemoved) {
winston.info('Purged jobs in Agenda que');
});
// Define agenda jobs
require('./jobs/weather')(agenda);
// Get the settings document and then scedule sensor readings
Settings.findOne({}, {}, { sort: { 'timestamp': 1 } }, function(err, settings){
// Only start jobs if settings exist
if (settings){
//Setup an Agenda connection
var Agenda = require('agenda');
var agenda = new Agenda({db: {address: userConfig.mongodb.host + ':' + userConfig.mongodb.port + '/' + userConfig.mongodb.databaseName,
collection: 'agenda'},
options: {ssl: true}});
require('./config/express')(app);
require('./routes')(app);
require('./jobs/jobs');
process.on('unhandledRejection', function (reason, p) {
console.log('Possibly Unhandled Rejection at: Promise ', p, ' reason: ', reason);
});
process.on('unhandledException', function (err) {
console.log('Possibly Unhandled Exception at: Promise ', err);
});
// Start server
server.listen(config.port, config.ip, function () {
console.log('Express server listening on %d, in %s mode', config.port, app.get('env'));
});
//Start agenda
agenda.on('ready', function() {
agenda.start();
});
// Expose app
exports = module.exports = app;
const Agenda = require('agenda');
const mongoConnectionString = process.env.MONGODB_URI;
var agenda = new Agenda({
db: {
address: mongoConnectionString,
collection: 'mapJobs',
options: {
server: { auto_reconnect: true }
}
}
});
agenda.on('ready', () => {
console.log('Agenda is connected to Heroku mongodb.');
agenda.start();
});
agenda.on('error', (err) => {
console.warn('Error in Agenda connecting to Heroku mongodb:\n', err);
});
agenda.on('fail', (err, job) => {
console.log('Job failed with error: %s', err.message);
});
agenda.on('success', (job) => {
console.log('Successfully completed job:', job.attrs);
});
module.exports = agenda;
module.exports = function (app, db, jobs) {
// Initialize agenda instance
var agenda = new Agenda({ mongo: db.connections[0].db, db: { collection: "jobs" }, processEvery: '5 seconds' });
// Load job types (define in each module)
var jobTypes = {};
// Iterate over each modules jobs and initialize
_.forEach(jobs, function(jobs) {
_.extend(jobTypes, require('./../../' + jobs)(function(moduleName, jobName, interval, derivedJobName, data, cb) {
// Define job using agenda API
agenda.define(derivedJobName, function(job, done) {
// Extend data with module and job
var jobData = _.extend(job.attrs.data, { moduleName: moduleName, jobName: jobName, derivedJobName: derivedJobName });
// Execut job callback
if(cb) {
try {
cb(jobData);
} catch (err) {
console.log("Caught failed job! - " + derivedJobName);
job.fail(err); // call Agenda fail function
job.save(); // save updated job
}
}
done(); // Make sure to call - otherwise jobs do not run
});
// Schedule job
agenda.every(interval, derivedJobName, data);
}));
});
// Get all configured jobs and load them into memory
agenda.jobs({}, function(err, jobs) {
if(!err) {
_.forEach(jobs, function(job) {
if(job.attrs.data && job.attrs.data.moduleName && job.attrs.data.jobName) {
// Call each job's init function
var interval = (job.attrs.repeatInterval) ? job.attrs.repeatInterval : '';
jobTypes[job.attrs.data.moduleName][job.attrs.data.jobName](interval, job.attrs.data, null,
// Failure callback
function(message) {
console.log(message);
}
);
console.log("\nLoaded " + job.attrs.data.derivedJobName + " into active memory with interval " + job.attrs.repeatInterval);
// Check to see if the job's next run already passed (and if so, fire the job)
if(job.attrs.nextRunAt) {
if(job.attrs.nextRunAt < Date.now()) {
console.log("--> Triggering " + job.attrs.data.derivedJobName + " to fire immediately.");
job.run(function(err, job) {});
} else {
console.log("--> Scheduling startup:" + job.attrs.data.derivedJobName + " to fire " + job.attrs.nextRunAt);
// Create a one-time startup job to run a loaded job at the desired startup time
agenda.define("startup:" + job.attrs.data.derivedJobName, function(startupJob, done) {
job.run(function(err, job) {});
done();
});
agenda.schedule(job.attrs.nextRunAt, "startup:" + job.attrs.data.derivedJobName, {
jobName: "startup",
derivedJobName: "startup:" + job.attrs.data.derivedJobName
});
}
}
}
});
}
});
// Add jobTypes to agenda object
agenda.jobTypes = jobTypes;
// Setup recurrance
agenda.on('ready', function() {
// Create indexes
agenda._collection.createIndexes([
{key: { nextRunAt: -1, lastRunAt: -1, lastFinishedAt: -1 }},
{key: { name: 1, nextRunAt: -1, lastRunAt: -1, lastFinishedAt: -1 }}
], function (err, result) {
if (err) {
console.warn('Jobs module indexes might not exist. Performance may decrease.');
}
});
// Start agenda
agenda.start();
});
return agenda;
};
if(fulltime.length > 0){
myArray.push(fulltime);
}
if(parameterized.length > 0){
myArray.push(parameterized);
}
console.log(myArray);
});
agenda.on('ready', function(){
agenda.every('5 seconds', 'rodar integrações');
agenda.purge(function(err, numRemoved) {
console.log(numRemoved);
});
agenda.start();
})
function getResultsToRun(){
var obj = [{
nome: "Integração full-time",
proximaExecucao: null
},{
nome: "Integração parametrizada",
proximaExecucao: starterTime
}];
return obj;
};
exports.register = function (server, options, next) {
// Validating the options
const validateOptions = internals.optionsSchema.validate(options);
if (validateOptions.error) {
return next(validateOptions.error);
}
options = validateOptions.value;
// Configuring Agenda
const agenda = new Agenda();
agenda
.database(options.mongoUri)
.processEvery(options.processEvery)
.maxConcurrency(options.maxConcurrency)
.defaultConcurrency(options.defaultConcurrency)
.lockLimit(options.lockLimit)
.defaultLockLimit(options.defaultLockLimit)
.defaultLockLifetime(options.defaultLockLifetime);
// Set Job Queue Events
agenda.on('start', (job) => {
server.log(['agenda', 'start'], job.attrs);
});
agenda.on('complete', (job) => {
server.log(['agenda', 'complete'], job.attrs);
});
agenda.on('success', (job) => {
server.log(['agenda', 'success'], job.attrs);
});
agenda.on('fail', (err, job) => {
server.log(['agenda', 'error'], { err: err, job: job.attrs });
});
// Retrieve all the jobs from the file system and define them in Agenda
Recursive(options.jobs, function (err, files) {
_.forIn(files, (jobFile) => {
let jobName = Path.parse(jobFile).name;
let jobFunction;
let jobOpts = {};
let job = require(jobFile);
if (typeof job === 'function') {
jobFunction = job;
} else {
jobName = job.name;
jobFunction = job.job;
jobOpts = Object.assign({}, job);
delete jobOpts.name;
delete jobOpts.job;
}
agenda.define(jobName, jobOpts, (agendaJob, done) => {
server.log(['agenda', 'queue'], { jobName: jobName, job: agendaJob.attrs });
jobFunction(server, agendaJob, done);
});
});
agenda.on('ready', () => {
server.log(['agenda', 'ready']);
agenda.cancel({}, (err, numRemoved) => {
if (err) {
throw err;
}
if (numRemoved > 0) {
server.log(['agenda', 'delete'], { jobsRemoved: numRemoved });
}
// https://github.com/rschmukler/agenda#everyinterval-name-data-options-cb
if (options.every) {
_.forIn(options.every, (jobOpts, jobInterval) => {
if (typeof jobOpts === 'string') {
agenda.every(jobInterval, jobOpts);
} else {
_.forIn(jobOpts, (value, key) => {
if (typeof value === 'string') {
agenda.every(jobInterval, value);
} else {
if (value.data != undefined) {
if (value.options == undefined) {
agenda.every(jobInterval, key, value.data);
} else {
agenda.every(jobInterval, key, value.data, value.options);
}
}
else {
_.forIn(value, (v, k) => {
if (v.data != undefined) {
if (v.options == undefined) {
agenda.every(jobInterval, k, v.data);
} else {
agenda.every(jobInterval, k, v.data, v.options);
}
} else {
agenda.every(jobInterval, k);
}
});
}
}
});
}
});
}
// https://github.com/rschmukler/agenda#schedulewhen-name-data-cb
if (options.schedule) {
_.forIn(options.schedule, (jobOpts, when) => {
if (typeof jobOpts === 'string') {
agenda.schedule(when, jobOpts);
} else {
_.forIn(jobOpts, (value, key) => {
if (typeof value === 'string') {
agenda.schedule(when, value);
} else {
if (value.data != undefined) {
agenda.schedule(when, key, value.data);
} else {
_.forIn(value, (v, k) => {
if (v.data == undefined) {
agenda.schedule(when, k);
} else {
agenda.schedule(when, k, v.data);
}
});
}
}
});
}
});
}
agenda.start();
next();
});
});
});
// http://hapijs.com/api#serverexposekey-value
server.expose('agenda', agenda);
// http://hapijs.com/api#serverbindcontext
server.bind({ agenda: agenda });
// http://hapijs.com/api#server-events
server.on('start', () => {
// Server starting...
});
};
Recursive(options.jobs, function (err, files) {
_.forIn(files, (jobFile) => {
let jobName = Path.parse(jobFile).name;
let jobFunction;
let jobOpts = {};
let job = require(jobFile);
if (typeof job === 'function') {
jobFunction = job;
} else {
jobName = job.name;
jobFunction = job.job;
jobOpts = Object.assign({}, job);
delete jobOpts.name;
delete jobOpts.job;
}
agenda.define(jobName, jobOpts, (agendaJob, done) => {
server.log(['agenda', 'queue'], { jobName: jobName, job: agendaJob.attrs });
jobFunction(server, agendaJob, done);
});
});
agenda.on('ready', () => {
server.log(['agenda', 'ready']);
agenda.cancel({}, (err, numRemoved) => {
if (err) {
throw err;
}
if (numRemoved > 0) {
server.log(['agenda', 'delete'], { jobsRemoved: numRemoved });
}
// https://github.com/rschmukler/agenda#everyinterval-name-data-options-cb
if (options.every) {
_.forIn(options.every, (jobOpts, jobInterval) => {
if (typeof jobOpts === 'string') {
agenda.every(jobInterval, jobOpts);
} else {
_.forIn(jobOpts, (value, key) => {
if (typeof value === 'string') {
agenda.every(jobInterval, value);
} else {
if (value.data != undefined) {
if (value.options == undefined) {
agenda.every(jobInterval, key, value.data);
} else {
agenda.every(jobInterval, key, value.data, value.options);
}
}
else {
_.forIn(value, (v, k) => {
if (v.data != undefined) {
if (v.options == undefined) {
agenda.every(jobInterval, k, v.data);
} else {
agenda.every(jobInterval, k, v.data, v.options);
}
} else {
agenda.every(jobInterval, k);
}
});
}
}
});
}
});
}
// https://github.com/rschmukler/agenda#schedulewhen-name-data-cb
if (options.schedule) {
_.forIn(options.schedule, (jobOpts, when) => {
if (typeof jobOpts === 'string') {
agenda.schedule(when, jobOpts);
} else {
_.forIn(jobOpts, (value, key) => {
if (typeof value === 'string') {
agenda.schedule(when, value);
} else {
if (value.data != undefined) {
agenda.schedule(when, key, value.data);
} else {
_.forIn(value, (v, k) => {
if (v.data == undefined) {
agenda.schedule(when, k);
} else {
agenda.schedule(when, k, v.data);
}
});
}
}
});
}
});
}
agenda.start();
next();
});
});
});
}//for loop closing bracket here
} else {
return
}//if bracket
});
});
//agenda define ends
//agenda.initialize from here
agenda.on('ready', function() {
agenda.every('30 seconds', 'abort games');
agenda.every('30 seconds', 'check progress');
agenda.every('30 seconds', 'check result'); //'open' ==> 'progress'
// agenda.processEvery('180 seconds', 'check games result');// 'progress' ==> 'completed'
agenda.start();
});
process.on('SIGTERM', graceful);
process.on('SIGINT', graceful);
//Middleware, param for summoner_id
router.param('summoner_id', function(req, res, next, id) {
var query = Summoners.findOne({
'summoner_id': id
});
query.exec(function(err, summoner) {
if (err) {
});
done();
});
});
agenda.define('execute procurer', function (job, done) {
var options = {};
queue.enqueue('procurer_run_event', options, function (err, job) {
if (err) {
LOG.error(util.format('[STATUS] [Failure] [%s] Error enqueueing procurer run job', err));
return done(err);
}
LOG.info('[STATUS] [OK] Procurer run job enqueued');
return done(err, options);
});
});
agenda.on('ready', function() {
var harvesterJob = agenda.create('execute harvester');
harvesterJob.repeatEvery(config.harvester.execution.rule).save();
var procurerJob = agenda.create('execute procurer');
procurerJob.repeatEvery(config.procurer.execution.rule).save();
agenda.start();
});
from: '*****@*****.**', // sender address
to: '*****@*****.**', // list of receivers
subject: 'Hello ✔', // Subject line
text: 'Hello world 🐴', // plaintext body
html: '<b>Hello world 🐴</b>' // html body
};
// send mail with defined transport object
transporter.sendMail(mailOptions, function(error, response){
if(error){
console.log(error);
}else{
console.log("Message sent: " + response.message);
}
done();
});
});
/*agenda.on('ready', function() {
agenda.schedule('in 2 minutes', 'send email report', {to: '*****@*****.**'});
//agenda.start();
});
*/
agenda.on('start', function(job) {
console.log("Job %s starting", job.attrs.name);
});
agenda.on('complete', function(job) {
console.log("Job %s finished", job.attrs.name);
});
module.exports=agenda;
const Agenda = require('agenda');
const mongoConnectionString = process.env.MONGODB_URI;
var agenda = new Agenda({db: {address: mongoConnectionString, collection: 'mapJobs', options: {server:{auto_reconnect:true}}}});
agenda.on('ready', function() {
// getTravels();
console.log('Agenda is connected to Heroku mongodb.');
agenda.start();
});
agenda.on('error', function(err) {
console.warn('Error in Agenda connecting to Heroku mongodb:\n', err);
});
agenda.on('fail', function(err, job) {
console.log("Job failed with error: %s", err.message);
});
agenda.on('success', function(job) {
console.log('Successfully completed job:', job.attrs);
})
module.exports = agenda;
// const getTravels = function() {
relaySwitch(data.pins, 0, done);
});
agenda.define('pwm switch on', function(job, done) {
var data = job.attrs.data;
pwmSwitch(data.pins, 1023, done);
});
agenda.define('pwm switch off', function(job, done) {
var data = job.attrs.data;
pwmSwitch(data.pins, 0, done);
});
agenda.on('ready', function() {
// initial new jobs saved into db
/*
agenda.every('0-4,10-14,20-24,30-34,40-44,50-54 * * * *', 'relay switch on', { pins: relayPins, status: true });
agenda.every('5-9,15-19,25-29,35-39,45-49,55-59 * * * *', 'relay switch off', { pins: relayPins, status: false });
agenda.every('* 8-20 * * *', 'pwm switch on', { pins: pwmPins });
agenda.every('* 0-7,21-23 * * *', 'pwm switch off', { pins: pwmPins });
*/
agenda.start();
});
agenda.on('start', function(job) {
console.log("Job %s starting", job.attrs.name);
});
console.log("Fully started Local worker");