function(err, conf) {
var options = conf;
options.logglyClient.json = true;
options.logglyClient.tags = options.logglyClient.tags.split(',');
options.ignore = options.ignore.split(';');
options.pm2Apps = options.pm2Apps.split(',');
var client = loggly.createClient(options.logglyClient);
pm2.connect(function(err) {
if (err) return console.error('PM2 Loggly:', err.stack || err);
pm2.launchBus(
function(err, bus) {
if (err) return console.error('PM2 Loggly:', err);
console.log('PM2 Loggly: Bus connected');
bus.on('log:out', function(log) {
if (log.process.name !== 'pm2-loggly') {
if (options.pm2Apps.indexOf(log.process.name) > -1) {
if (options.ignore && options.ignore.length && log.data) {
for (var i = options.ignore.length - 1; i >= 0; i--) {
if (log.data.indexOf(options.ignore[i]) > -1) {
return;
}
}
}
console.log(log.data);
client.log(
getLogglyMeta('info', log.data),
[log.process.name]
);
}
}
});
bus.on('log:err', function(log) {
if (log.process.name !== 'pm2-loggly') {
if (options.pm2Apps.indexOf(log.process.name) > -1) {
console.error(log.data);
client.log(
getLogglyMeta('error', log.data),
[log.process.name]
);
}
}
});
bus.on('reconnect attempt', function() {
console.log('PM2 Loggly: Bus reconnecting');
});
bus.on('close', function() {
console.log('PM2 Loggly: Bus closed');
pm2.disconnectBus();
});
}
);
});
}
router.get('/', function(req, res) {
pm2.connect(function(err){
if(err) throw new Error(err);
pm2.list( function(err, process_list){
if(err) throw new Error(err);
plist = process_list;
for(var proc in plist) {
plist[proc].monit.memory = parseInt(plist[proc].monit.memory / 1048576) + " MB";
}
pm2.disconnect(function(err){ if (err) throw new Error(err);});
res.render('actions/processes',
{
title:'ArchiPi :: Process',
siteTitle: 'Archi Pi',
content:plist,
status: false,
proc: true
});
});
});
});
() => {
pm2.connect(function(err){
pm2.stop('ProcessOrder'); // TODO make this a config, tricky because pm2 wants its own app declaration file
notifier.message("Stopped ProcessOrder",opts);
console.log('Stopped ProcessOrder');
});
},
reqGet.on('error', function (e) {
emailSent++;
pm2.connect((err) => {
if (err) {
console.error(err);
} else {
pm2.restart(serviceName, function (err) {
pm2.disconnect();
if (emailSent > 0 && emailSent < 3) {
var mailer = new mail.mail(mailOptions),
to = ["*****@*****.**", "*****@*****.**"];
var subject = `Servicio ${serviceName} - AGP detenido`;
mailer.send(to, subject, JSON.stringify(optionsget), function (err) {
if (err) {
console.log("Error enviando email. %j, %s", err, new Date());
} else {
emailSent++;
console.log('Caído - emailSent %s a %s - %s', emailSent, to, new Date());
if (emailSent === 2) {
console.log("\nEnvio de Alertas Finalizado hasta tanto se reinicie el servicio %s\n", new Date());
}
}
});
}
});
}
});
});
kill: function(what, cb) {
cb = cb || function(){}
pm2.connect(function() {
pm2.delete('all', function(){
cb();
});
});
},
router.get('/', function(req, res, next) {
pm2.connect(function(err) {
pm2.list(function(err, process_list) {
res.setHeader('Content-Type', 'application/json');
console.log(process_list)
res.end(process_list);
});
});
});
return new Promise((resolve, reject) => {
pm2.connect((err) => {
if(err) reject(err);
this.update().then((list) => {
console.log(list);
resolve();
});
});
});
return new Promise((resolve, reject)=>{
pm2.connect(true,(err)=>{
if(err) return reject(err);
pm2.killDaemon((err,details)=>{
if(err){
return reject(err);
}
return resolve(details);
});
});
});
return new Promise((resolve, reject)=>{
pm2.connect(true,(err)=>{
if(err) return reject(err);
pm2.describe(id, (err, details)=>{
pm2.disconnect();
if(err){
return reject(err);
}
return resolve(details);
});
});
});
return new Promise((resolve, reject)=>{
pm2.connect(true,(err)=>{
if(err) return reject(err);
pm2.list((err,list)=>{
pm2.disconnect();
if(err){
return reject(err);
}
return resolve(list);
});
});
});
var _connect = function () {
if (connected) {
logger.info("Reuse PM2 connection");
return Promise.resolve();
} else {
return pm2Instance.connect()
.then(function () {
connected = true;
logger.info("Connected to pm2", new Date());
});
}
}
spawn: function(options, cb) {
options = options || {}
options = _.defaults(options, {
ports: [],
ssl: false,
});
pm2.connect(function() {
var ports = options.ports;
var done = 0;
var handler = function(err, cb) {
done++;
if (done == ports.length) {
cb(err);
};
}
var start = function(cb) {
for (var i = 0; i < ports.length; ++i) {
(function(port){
pm2.start({
script: __dirname + '/server.js',
cluster: false,
args: [port, false],
instances: 1,
//error_file: './server.stderr.log',
}, function(err, apps) {
if (err) {
console.error(err)
}
handler(err, cb);
});
})(ports[i]);
}
}
var kill = function(cb){
pm2.delete('all', cb);
}
kill(function() {
start(function() {
pm2.disconnect();
cb();
});
});
});
},
export function pm2stop(name, callback) {
pm2.connect(err => {
if (err) {
callback(err);
return;
}
pm2.delete(name, () => {
pm2.disconnect();
callback();
});
});
}
var pm2Stop = function(socket, data) {
pm2.connect(function(err){
if(err) throw new Error(err);
pm2.stop(data.name, function(err, proc){
if(err) socket.emit('p-state', {name:proc[0].name, status:proc[0].pm2_env.status, msg:err});
console.log(proc, err);
//socket.emit('p-state', {name:proc[0].name, status:proc[0].pm2_env.status});
pm2.disconnect(function(err, proc){ socket.emit('msg', {msg:{proc:proc}, err:err}) });
})
})
}
gulp.task('api', function () {
pm2.connect(true, function () {
pm2.start({
name: 'ckreator',
script: './api/server.js',
// env: {
// "NODE_ENV": require('../config').ENV
// }
}, function () {
console.log('pm2 started');
pm2.streamLogs('all', 0);
});
});
});
function pm2action(cmd, name, cb){
pm2.connect(function (err) {
pm2[cmd](name, function (err, proc) {
if (err) throw new Error('err');
if(proc.success === true){
cli.log.ok(cmd + ' ' + name + ' success');
} else {
cli.log.warn(cmd + ' ' + name + ' not successfull');
console.log(proc);
}
cli.exit();
});
});
}
var pm2Reset = function(socket, data){
pm2.connect(function(err){
if(err) throw new Error(err);
pm2.reset(data.name, function(err, proc){
if(err) socket.emit('msg', {msg:"Something went wrong...", err:err});
pm2UpdateState(socket, data);
pm2.disconnect(function(err, proc){ socket.emit('msg', {msg:{proc:proc}, err:err}); });
})
});
}
function poll()
{
// Connect or launch pm2
pm2.connect(function(err){
console.log('Just connected to PM2');
// Pull down the list
pm2.list(function(err, list) {
// Start an output message
var agent = {};
agent.host = os.hostname();
agent.pid = process.pid;
agent.version = ver;
var msg = {};
msg.agent = agent;
// Get the components
var cmps = [];
// Pull down data for each function
list.forEach(function(l) {
// Basic information
var name = l.pm2_env.name
var metrics = {};
metrics['Component/pm2[uptime]'] = calcUptime(l.pm2_env.pm_uptime);
metrics['Component/pm2[restarts]'] = l.pm2_env.restart_time;
metrics['Component/pm2[cpu]'] = l.monit.cpu;
metrics['Component/pm2[memory]'] = l.monit.memory;
var cmp = {};
cmp['name'] = name;
cmp['guid'] = guid;
cmp['duration'] = 60;
cmp['metrics'] = metrics;
cmps.push(cmp);
});
msg.components = cmps;
postToNewRelic(msg);
});
});
// Re-run every 60s
setTimeout(poll, 60000)
}
myRepo.reset('origin/'+(req.params.branch||'master'),function(err){
var pm2 = require('pm2');
pm2.connect(function(err) {
if (err) {
console.error(err);
process.exit(2);
}
pm2.restart({
name: sd._config.name
}, function(err, apps) {
pm2.disconnect();
process.exit(2);
});
});
});
module.exports = () => {
pm2.connect((err) => {
if (err) {
console.error(err);
process.exit(2);
}
console.log('再起動するよ!\n');
pm2.restart({name: pm2name, watch:false}, (err, apps) => {
pm2.disconnect(); // Disconnect from PM2
if (err) throw err;
// console.log(apps);
});
});
}
function deleteApp(id) {
if (id) {
pm2.connect(function() {
pm2.delete(id, function(err) {
if (err) {
tiny.log.error('删除进程失败');
} else {
tiny.log.info('删除进程成功');
}
pm2.disconnect();
});
});
}
}
after(function(done)
{
// Stop the server
pm2.connect(function() {
pm2.stop("recalbox-api-test", function(error, proc) {
pm2.disconnect();
// Reset the configuration file
var source = __dirname + "/share/system/recalbox.conf.template";
var destination = __dirname + "/share/system/recalbox.conf";
fs.readFile(source, "utf8", function (error, data) {
fs.writeFile(destination, data, done);
});
});
});
});
/**
* Start a subprocess using the PM2 process manager
* @param {object} conf - PM2-format process specification
* @param {function} cb - callback(err)
*/
function startWithPM2 (conf, cb) {
console.log('calling connect...')
pm2.connect(function (err) {
if (err) {
return cb(err)
}
pm2.start(conf, function (err, apps) {
console.log('in start callback...')
if (err) {
return cb(err)
}
pm2.disconnect()
console.log('startWithPM2: finishing successfully')
return cb(null)
})
})
}
function cleanup() {
helper.killMongo();
pm2.connect((err) => {
if (err) {
console.log(err);
return;
}
pm2.delete('integration-test', (err) => {
pm2.disconnect();
if (err) {
console.log(err);
return;
}
});
});
}
export function pm2start(name, config = {}, callback = () => {}) {
pm2.connect(err => {
if (err) {
callback(err);
return;
}
pm2.start(
{
name: name,
...config,
},
(err, apps) => {
pm2.disconnect();
callback(err);
}
);
});
}
installController.restart = function (req, res) {
var pm2 = require('pm2')
pm2.connect(function (err) {
if (err) {
winston.error(err)
res.status(400).send(err)
return
}
pm2.restart('trudesk', function (err) {
if (err) {
res.status(400).send(err)
return winston.error(err)
}
pm2.disconnect()
res.send()
})
})
}
function restart(env) {
debug("Starting PM2. NODE_ENV: "+env);
pm2.connect(function (err) {
if (err) {
console.error(err);
process.exit(2);
}
let options = {
name: "api",
script: './app.js', // Script to be run
exec_mode: 'cluster', // Allow your app to be clustered
instances: 2 // Optional: Scale your app by 4
};
if(env){
switch(env){
case "bsas":
options.env = {
"NODE_ENV": "rc"
};
break;
case "prod":
options.env = {
"NODE_ENV": "production"
};
break;
}
}
debug("PM2: START OPTIONS"+JSON.stringify(options));
pm2.restart(options, function (err, apps) {
if (err){
debug("Err: "+err);
pm2.disconnect(); // Disconnect from PM2
throw err;
}
debug("API STARTED");
pm2.disconnect();
});
});
}
helper.startMongo((code) => {
console.log('mongod exited with ' + code);
const restoreEnv = process.env;
process.env = { ...process.env, NODE_ENV: 'test', PORT: 4000 };
pm2.connect((err) => {
if (err) {
reject(err);
process.exit(2);
return;
}
pm2.start({
script: '/usr/local/bin/npm',
name: 'integration-test',
force: true,
args: ['start']
}, (err, apps) => {
pm2.disconnect();
process.env = restoreEnv;
if (err) return reject(err);
setTimeout(() => {
const env = processEnv({NODE_ENV: 'test', PORT: 4000});
const stream = gulp.src(['spec/integration/*.js'])
.pipe(plumber())
.pipe(webpack(testConfig))
.pipe(gulp.dest('specs-build'))
.pipe(env)
.pipe(jasmine({includeStackTrace: true}));
stream.pipe(env.restore());
stream.on('end', () => {
resolve(stream);
});
stream.on('error', (error) => {
reject({error})
});
}, 2000);
});
});
});
before(function(done)
{
// Start the server
pm2.connect(function() {
pm2.start({
name : "recalbox-api-test",
exec_interpreter : "node",
exec_mode : "cluster",
instances : 1,
max_memory_restart : "100M",
node_args : ["--harmony", "--harmony-proxies"],
cwd : "test/rest",
script : "console.js",
args : ["server:start"]
}, function(error, apps) {
pm2.disconnect();
setTimeout(done, 5000);
});
});
});
module.exports = function (gulp) {
// dev tasks
pm2.connect(true, () => {
pm2.start({
'name': 'name.of.app-dev',
'script': '/../../server.js',
'instances': 1,
'exec_mode': 'cluster',
'watch': true,
'env':{
'NODE_ENV': 'development',
}
}, () => {
console.log('started in development mode');
pm2.streamLogs('all', 0);
});
});
};