mirror of
https://github.com/Unitech/pm2.git
synced 2025-12-08 20:35:53 +00:00
938 lines
26 KiB
JavaScript
938 lines
26 KiB
JavaScript
var commander = require('commander');
|
|
var fs = require('fs');
|
|
var path = require('path');
|
|
var util = require('util');
|
|
var async = require('async');
|
|
|
|
var Monit = require('./Monit');
|
|
var UX = require('./CliUx');
|
|
var Log = require('./Log');
|
|
var Satan = require('./Satan');
|
|
var Common = require('./Common');
|
|
var cst = require('../constants.js');
|
|
var pkg = require('../package.json');
|
|
var extItps = require('./interpreter.json');
|
|
var InteractorDaemonizer = require('./InteractorDaemonizer');
|
|
var p = path;
|
|
|
|
var CLI = module.exports = {};
|
|
require('colors');
|
|
|
|
/**
|
|
* Method to start a script
|
|
* @param {string} script script name (will be resolved according to location)
|
|
*/
|
|
CLI.startFile = function(script) {
|
|
var appConf = {
|
|
script : script,
|
|
name : p.basename(script, '.js')
|
|
};
|
|
|
|
if (commander.nodeArgs)
|
|
appConf['nodeArgs'] = commander.nodeArgs;
|
|
if (commander.name)
|
|
appConf['name'] = commander.name;
|
|
if (commander.instances)
|
|
appConf['instances'] = commander.instances;
|
|
if (commander.error)
|
|
appConf['error_file'] = commander.error;
|
|
if (commander.output)
|
|
appConf['out_file'] = commander.output;
|
|
if (commander.pid)
|
|
appConf['pid_file'] = commander.pid;
|
|
if (commander.cron)
|
|
appConf['cron_restart'] = commander.cron;
|
|
if (commander.mergeLogs)
|
|
appConf['merge_logs'] = true;
|
|
if (commander.watch)
|
|
appConf['watch'] = true;
|
|
if (commander.runAsUser)
|
|
appConf['run_as_user'] = commander.runAsUser;
|
|
if (commander.runAsGroup)
|
|
appConf['run_as_group'] = commander.runAsGroup;
|
|
|
|
if (commander.executeCommand)
|
|
appConf['exec_mode'] = 'fork_mode';
|
|
else
|
|
appConf['exec_mode'] = 'cluster_mode';
|
|
|
|
if (commander.interpreter)
|
|
appConf['exec_interpreter'] = commander.interpreter;
|
|
else if (extItps[path.extname(script)]) {
|
|
appConf['exec_interpreter'] = extItps[path.extname(script)];
|
|
appConf['exec_mode'] = 'fork_mode';
|
|
}
|
|
else
|
|
appConf['exec_interpreter'] = 'node';
|
|
|
|
if (commander.startOneTime)
|
|
appConf['one_launch_only'] = cst.ONE_LAUNCH_STATUS;
|
|
|
|
// if (appConf['exec_mode'] == 'cluster_mode' && process.version.match(/0.10/)) {
|
|
// printOut(cst.PREFIX_MSG_ERR + ' [Warning], you\'re using the 0.10.x node version, it\'s prefered that you switch to fork mode by adding the -x parameter.');
|
|
// }
|
|
|
|
// Script arguments
|
|
var env = commander.rawArgs.indexOf('--') + 1;
|
|
if (env > 1)
|
|
appConf['args'] = JSON.stringify(commander.rawArgs.slice(env, commander.rawArgs.length));
|
|
|
|
if (commander.write) {
|
|
var dst_path = path.join(process.env.PWD, path.basename(script, '.js') + '-pm2.json');
|
|
printOut(cst.PREFIX_MSG + 'Writing configuration to ', dst_path);
|
|
fs.writeFileSync(dst_path, JSON.stringify(appConf));
|
|
}
|
|
|
|
/*
|
|
* Re start script name that is already launched
|
|
*/
|
|
Satan.executeRemote('findByFullPath', path.resolve(process.cwd(), script), function(err, exec) {
|
|
if (exec &&
|
|
(exec[0].pm2_env.status == cst.STOPPED_STATUS ||
|
|
exec[0].pm2_env.status == cst.STOPPING_STATUS)) {
|
|
var app_name = exec[0].pm2_env.name;
|
|
Satan.executeRemote('restartProcessName', app_name, function(err, list) {
|
|
printOut(cst.PREFIX_MSG + 'Process successfully started');
|
|
return speedList();
|
|
});
|
|
return false;
|
|
}
|
|
else if (exec && !commander.force) {
|
|
console.error(cst.PREFIX_MSG_ERR + 'Script already launched, add -f option to force re execution');
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
|
|
Satan.executeRemote('prepare', resolvePaths(appConf), function() {
|
|
printOut(cst.PREFIX_MSG + 'Process launched');
|
|
speedList();
|
|
});
|
|
return false;
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Use a RPC method on the json file
|
|
* @param {string} action RPC Method
|
|
*/
|
|
CLI.actionFromJson = function(action, file, jsonVia) {
|
|
if (jsonVia == 'pipe')
|
|
var appConf = JSON.parse(file);
|
|
else {
|
|
var data = fs.readFileSync(file);
|
|
var appConf = JSON.parse(data);
|
|
}
|
|
|
|
if (!Array.isArray(appConf)) appConf = [appConf]; //convert to array
|
|
|
|
async.eachLimit(appConf, cst.CONCURRENT_ACTIONS, function(proc, next) {
|
|
var name;
|
|
|
|
if (!proc.name)
|
|
name = p.basename(proc.script);
|
|
else
|
|
name = proc.name;
|
|
|
|
Satan.executeRemote(action, name, function(err, list) {
|
|
if (err)
|
|
console.error(err);
|
|
printOut(cst.PREFIX_MSG + 'Stopping process by name ' + name);
|
|
next();
|
|
});
|
|
|
|
}, function(err) {
|
|
if (err) {
|
|
printOut(err);
|
|
return exitCli(cst.ERROR_EXIT);
|
|
}
|
|
|
|
return setTimeout(speedList, 800);
|
|
});
|
|
};
|
|
|
|
CLI.startFromJson = function(cmd,jsonVia) {
|
|
var appConf;
|
|
|
|
if (jsonVia == 'pipe')
|
|
appConf = JSON.parse(cmd);
|
|
else {
|
|
var data = fs.readFileSync(cmd);
|
|
appConf = JSON.parse(data);
|
|
}
|
|
|
|
if (!Array.isArray(appConf)) appConf = [appConf]; //convert to array
|
|
|
|
(function ex(apps) {
|
|
if (apps.length == 0) return speedList();
|
|
|
|
var appPaths = resolvePaths(apps[0]);
|
|
|
|
if(commander.watch)
|
|
appPaths.watch = true;
|
|
|
|
var rpcCall = 'findByScript';
|
|
var rpcArg = p.basename(appPaths.script);
|
|
|
|
//find script by port
|
|
if (appPaths.port) {
|
|
rpcCall = 'findByPort';
|
|
rpcArg = appPaths.port;
|
|
}
|
|
|
|
Satan.executeRemote(rpcCall, rpcArg , function(err, exec) {
|
|
if (exec && !commander.force) {
|
|
console.error(cst.PREFIX_MSG + 'Script already launched, add -f option to force re execution');
|
|
nextApp();
|
|
return false;
|
|
} else {
|
|
launchApp(appPaths);
|
|
return false;
|
|
}
|
|
});
|
|
|
|
function launchApp(appPaths){
|
|
Satan.executeRemote('prepare', appPaths, function() {
|
|
printOut(cst.PREFIX_MSG + 'Process launched');
|
|
nextApp();
|
|
});
|
|
}
|
|
|
|
function nextApp(){
|
|
apps.shift();
|
|
return ex(apps);
|
|
}
|
|
|
|
return false;
|
|
})(appConf);
|
|
};
|
|
|
|
CLI.startup = function(platform) {
|
|
var exec = require('child_process').exec;
|
|
|
|
if (process.getuid() != 0) {
|
|
|
|
exec('whoami', function(err, stdout, stderr) {
|
|
console.error(cst.PREFIX_MSG + 'You have to run this command as root');
|
|
console.error(cst.PREFIX_MSG + 'Execute the following command :');
|
|
if (platform === undefined) platform = '';
|
|
console.error(cst.PREFIX_MSG + 'sudo env PATH=$PATH:' + p.dirname(process.execPath) + ' pm2 startup ' + platform + ' -u ' + stdout.trim());
|
|
exitCli(cst.ERROR_EXIT);
|
|
});
|
|
return;
|
|
}
|
|
|
|
var INIT_SCRIPT = "/etc/init.d/pm2-init.sh";
|
|
|
|
var script;
|
|
|
|
if (platform == 'systemd') {
|
|
script = fs.readFileSync(path.join(__dirname, cst.SYSTEMD_STARTUP_SCRIPT));
|
|
INIT_SCRIPT = '/etc/systemd/system/pm2.service';
|
|
}
|
|
else if (platform == 'centos' || platform == 'redhat')
|
|
script = fs.readFileSync(path.join(__dirname, cst.CENTOS_STARTUP_SCRIPT));
|
|
else if (platform == 'amazon')
|
|
script = fs.readFileSync(path.join(__dirname, cst.AMAZON_STARTUP_SCRIPT));
|
|
else
|
|
script = fs.readFileSync(path.join(__dirname, cst.UBUNTU_STARTUP_SCRIPT));
|
|
|
|
var user = commander.user || 'root';
|
|
|
|
script = script.toString().replace(/%PM2_PATH%/g, process.mainModule.filename);
|
|
script = script.toString().replace(/%HOME_PATH%/g, process.env.HOME);
|
|
script = script.toString().replace(/%NODE_PATH%/g, p.dirname(process.execPath));
|
|
script = script.toString().replace(/%USER%/g, user);
|
|
|
|
printOut(cst.PREFIX_MSG + 'Generating system init script in ' + INIT_SCRIPT);
|
|
|
|
fs.writeFileSync(INIT_SCRIPT, script);
|
|
|
|
if (fs.existsSync(INIT_SCRIPT) == false) {
|
|
printOut(script);
|
|
printOut(cst.PREFIX_MSG_ERR + ' There is a problem when trying to write file : ' + INIT_SCRIPT);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
|
|
var cmd;
|
|
|
|
printOut(cst.PREFIX_MSG + 'Making script booting at startup...');
|
|
|
|
if (platform == 'systemd') {
|
|
cmd = [
|
|
'sudo -Ei -u ' + user + ' pm2 dump', //We need an empty dump so that the first resurrect works correctly
|
|
'pm2 kill',
|
|
'systemctl daemon-reload',
|
|
'systemctl enable pm2',
|
|
'systemctl start pm2'
|
|
].join(' && ');
|
|
|
|
printOut(cst.PREFIX_MSG + '-systemd- Using the command %s', cmd);
|
|
}
|
|
else if (platform == 'centos' || platform == 'redhat' || platform == 'amazon') {
|
|
cmd = 'chmod +x ' + INIT_SCRIPT + '; chkconfig --add ' + p.basename(INIT_SCRIPT);
|
|
printOut(cst.PREFIX_MSG + '-centos- Using the command %s', cmd);
|
|
fs.openSync('/var/lock/subsys/pm2-init.sh', 'w');
|
|
printOut('/var/lock/subsys/pm2-init.sh lockfile has been added');
|
|
}
|
|
else {
|
|
cmd = 'chmod +x ' + INIT_SCRIPT + '; update-rc.d ' + p.basename(INIT_SCRIPT) + ' defaults';
|
|
printOut(cst.PREFIX_MSG + '-ubuntu- Using the command %s', cmd);
|
|
}
|
|
|
|
exec(cmd, function(err, stdo, stde) {
|
|
if (err) {
|
|
console.error(err);
|
|
printOut('----- Are you sure you use the right platform command line option ? centos / redhat, amazon, ubuntu or systemd?');
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
printOut(stdo);
|
|
printOut(cst.PREFIX_MSG + 'Done.');
|
|
exitCli(cst.SUCCESS_EXIT);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Interactor methods
|
|
*/
|
|
CLI.interact = function(secret_key, public_key, machine_name) {
|
|
InteractorDaemonizer.launchOrAttach(secret_key, public_key, machine_name, function(status) {
|
|
if (status == false)
|
|
printOut('Interactor already launched');
|
|
else
|
|
printOut('Successfully launched interactor');
|
|
exitCli(cst.SUCCESS_EXIT);
|
|
});
|
|
};
|
|
|
|
CLI.killInteract = function(secret_key, machine_name) {
|
|
InteractorDaemonizer.ping(function(online) {
|
|
if (!online) {
|
|
console.error('Interactor not launched');
|
|
return exitCli(cst.ERROR_EXIT);
|
|
}
|
|
InteractorDaemonizer.launchRPC(function() {
|
|
InteractorDaemonizer.rpc.kill(function(err) {
|
|
if (err) {
|
|
console.error(err);
|
|
return exitCli(cst.ERROR_EXIT);
|
|
}
|
|
printOut('Interactor successfully killed');
|
|
return exitCli(cst.SUCCESS_EXIT);
|
|
});
|
|
});
|
|
return false;
|
|
});
|
|
};
|
|
|
|
CLI.infoInteract = function() {
|
|
getInteractInfo(function(err, data) {
|
|
if (err) {
|
|
console.error('Interactor not launched');
|
|
return exitCli(cst.ERROR_EXIT);
|
|
}
|
|
console.log(data);
|
|
return exitCli(cst.SUCCESS_EXIT);
|
|
});
|
|
};
|
|
|
|
CLI.ping = function() {
|
|
Satan.executeRemote('ping', {}, function(err, res) {
|
|
if (err) {
|
|
console.error(err);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
printOut(res);
|
|
exitCli(cst.SUCCESS_EXIT);
|
|
});
|
|
};
|
|
|
|
CLI.resurrect = function() {
|
|
try {
|
|
var apps = fs.readFileSync(cst.DUMP_FILE_PATH);
|
|
} catch(e) {
|
|
console.error(cst.PREFIX_MSG + 'No processes saved; DUMP file doesn\'t exist');
|
|
return exitCli(cst.ERROR_EXIT);
|
|
}
|
|
|
|
(function ex(apps) {
|
|
if (!apps[0]) return speedList();
|
|
Satan.executeRemote('prepare', apps[0], function(err) {
|
|
if (err)
|
|
console.error(cst.PREFIX_MSG_ERR + ' Process %s not launched - (script missing)', apps[0].pm_exec_path);
|
|
else
|
|
printOut(cst.PREFIX_MSG + 'Process %s launched', apps[0].pm_exec_path);
|
|
apps.shift();
|
|
return ex(apps);
|
|
});
|
|
return false;
|
|
})(JSON.parse(apps));
|
|
};
|
|
|
|
/**
|
|
* Dump current processes managed by pm2 into DUMP_FILE_PATH file
|
|
*/
|
|
CLI.dump = function() {
|
|
var env_arr = [];
|
|
Satan.executeRemote('getMonitorData', {}, function(err, list) {
|
|
if (err) {
|
|
console.error('Error retrieving process list: ' + err);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
|
|
function fin(err) {
|
|
fs.writeFileSync(cst.DUMP_FILE_PATH, JSON.stringify(env_arr));
|
|
UX.processing.stop();
|
|
exitCli(cst.SUCCESS_EXIT);
|
|
}
|
|
|
|
(function ex(apps) {
|
|
if (!apps[0]) return fin(null);
|
|
delete apps[0].pm2_env.instances;
|
|
delete apps[0].pm2_env.pm_id;
|
|
env_arr.push(apps[0].pm2_env);
|
|
apps.shift();
|
|
return ex(apps);
|
|
})(list);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Launch API interface
|
|
*/
|
|
CLI.web = function() {
|
|
Satan.executeRemote('prepare', resolvePaths({
|
|
script : p.resolve(p.dirname(module.filename), './HttpInterface.js'),
|
|
name : 'Pm2Http' + cst.WEB_INTERFACE,
|
|
exec_mode : 'fork_mode'
|
|
}), function() {
|
|
printOut(cst.PREFIX_MSG + 'Process launched');
|
|
speedList();
|
|
});
|
|
};
|
|
|
|
/**
|
|
* CLI method for reloading
|
|
* @param {string} reload_method RPC method to hit (can be reloadProcessId or softReloadProcessId)
|
|
*/
|
|
CLI.reload = function (reload_method) {
|
|
Satan.executeRemote('getMonitorData', {}, function(err, list) {
|
|
if (err) {
|
|
console.error('Error retrieving process list: ' + err);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
|
|
async.eachLimit(list, 1, function(proc, next) {
|
|
if ((proc.state == cst.STOPPED_STATUS ||
|
|
proc.state == cst.STOPPING_STATUS) &&
|
|
proc.pm2_env.exec_mode != 'cluster_mode') {
|
|
return next();
|
|
}
|
|
Satan.executeRemote(reload_method, proc.pm2_env.pm_id, function(err, res) {
|
|
if (err) {
|
|
console.error('Error : ' + err);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
printOut(cst.PREFIX_MSG + 'Process %s succesfully reloaded', proc.pm2_env.name);
|
|
return next();
|
|
});
|
|
return false;
|
|
}, function(err) {
|
|
printOut(cst.PREFIX_MSG + 'All processes reloaded');
|
|
return setTimeout(speedList, 500);
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* CLI method for reloading
|
|
* @param {string} process_name name of processes to reload
|
|
* @param {string} reload_method RPC method to hit (can be reloadProcessId or softReloadProcessId)
|
|
*/
|
|
CLI.reloadProcessName = function (process_name, reload_method) {
|
|
printOut(cst.PREFIX_MSG + 'Reloading process by name %s', process_name);
|
|
|
|
getProcessByName(process_name, function(err, processes) {
|
|
|
|
if (processes.length === 0) {
|
|
printError('No processes with this name: %s', process_name);
|
|
return exitCli(cst.ERROR_EXIT);
|
|
}
|
|
|
|
async.eachLimit(processes, 1, function(proc, next) {
|
|
if (proc.state == cst.STOPPED_STATUS ||
|
|
proc.state == cst.STOPPING_STATUS ||
|
|
proc.pm2_env.exec_mode != 'cluster_mode') {
|
|
return next();
|
|
}
|
|
Satan.executeRemote(reload_method, proc.pm2_env.pm_id, function(err, res) {
|
|
if (err) {
|
|
console.error('Error : ' + err);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
printOut(cst.PREFIX_MSG + 'Process %s succesfully reloaded', proc.pm2_env.name);
|
|
return next();
|
|
});
|
|
return false;
|
|
}, function(err) {
|
|
printOut(cst.PREFIX_MSG + 'All processes reloaded');
|
|
return setTimeout(speedList, 500);
|
|
});
|
|
});
|
|
};
|
|
|
|
CLI.restartProcessByName = function(pm2_name) {
|
|
Satan.executeRemote('restartProcessName', pm2_name, function(err, list) {
|
|
if (err) {
|
|
printError(err);
|
|
return exitCli(cst.ERROR_EXIT);
|
|
}
|
|
UX.processing.stop();
|
|
printOut(cst.PREFIX_MSG + 'Process ' + pm2_name + ' restarted');
|
|
speedList();
|
|
});
|
|
};
|
|
|
|
CLI.restartProcessById = function(pm2_id) {
|
|
Satan.executeRemote('restartProcessId', pm2_id, function(err, res) {
|
|
if (err) {
|
|
printError(err);
|
|
return exitCli(cst.ERROR_EXIT);
|
|
}
|
|
UX.processing.stop();
|
|
printOut(cst.PREFIX_MSG + 'Process ' + pm2_id + ' restarted');
|
|
speedList();
|
|
});
|
|
};
|
|
|
|
CLI.restartAll = function() {
|
|
Satan.executeRemote('getMonitorData', {}, function(err, list) {
|
|
if (err) {
|
|
printError(err);
|
|
return exitCli(cst.ERROR_EXIT);
|
|
}
|
|
if (list && list.length === 0) {
|
|
printError('No process launched');
|
|
return exitCli(cst.ERROR_EXIT);
|
|
}
|
|
|
|
|
|
(function rec(processes) {
|
|
var proc = processes[0];
|
|
|
|
if (proc == null) {
|
|
printOut(cst.PREFIX_MSG + 'Process restarted...');
|
|
return setTimeout(speedList, 1000);
|
|
}
|
|
Satan.executeRemote('restartProcessId', proc.pm2_env.pm_id, function(err, res) {
|
|
if (err) {
|
|
printError(err);
|
|
return exitCli(cst.ERROR_EXIT);
|
|
}
|
|
printOut(cst.PREFIX_MSG + 'Process ' + proc.pm2_env.name + ' restarted');
|
|
processes.shift();
|
|
return rec(processes);
|
|
});
|
|
return false;
|
|
})(list);
|
|
});
|
|
};
|
|
|
|
CLI.stopAll = function() {
|
|
Satan.executeRemote('stopAll', {}, function(err, list) {
|
|
if (err) {
|
|
printError(err);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
UX.processing.stop();
|
|
speedList();
|
|
});
|
|
};
|
|
|
|
CLI.deleteProcess = function(process_name, jsonVia) {
|
|
if (jsonVia == 'pipe')
|
|
return CLI.actionFromJson('deleteProcessName', process_name, 'pipe');
|
|
if (process_name.indexOf('.json') > 0)
|
|
return CLI.actionFromJson('deleteProcessName', process_name, 'file');
|
|
else if (process_name == 'all') {
|
|
printOut(cst.PREFIX_MSG + 'Stopping and deleting all processes');
|
|
Satan.executeRemote('deleteAll', {}, function(err, list) {
|
|
if (err) {
|
|
printError(err);
|
|
return exitCli(cst.ERROR_EXIT);
|
|
}
|
|
UX.processing.stop();
|
|
speedList();
|
|
});
|
|
}
|
|
else if (!isNaN(parseInt(process_name))) {
|
|
printOut('Stopping and deleting process by id : %s', process_name);
|
|
Satan.executeRemote('deleteProcessId', process_name, function(err, list) {
|
|
if (err) {
|
|
printError(err);
|
|
return exitCli(cst.ERROR_EXIT);
|
|
}
|
|
UX.processing.stop();
|
|
speedList();
|
|
});
|
|
}
|
|
else {
|
|
printOut(cst.PREFIX_MSG + 'Stopping and deleting process by name %s', process_name);
|
|
Satan.executeRemote('deleteProcessName', process_name, function(err, list) {
|
|
if (err) {
|
|
printError(err);
|
|
return exitCli(cst.ERROR_EXIT);
|
|
}
|
|
UX.processing.stop();
|
|
speedList();
|
|
});
|
|
}
|
|
};
|
|
|
|
CLI.stopProcessName = function(name) {
|
|
Satan.executeRemote('stopProcessName', name, function(err, list) {
|
|
if (err) {
|
|
printError(err);
|
|
return exitCli(cst.ERROR_EXIT);
|
|
}
|
|
printOut(cst.PREFIX_MSG + 'Stopping process by name ' + name);
|
|
UX.processing.stop();
|
|
speedList();
|
|
});
|
|
};
|
|
|
|
CLI.stopId = function(pm2_id) {
|
|
Satan.executeRemote('stopProcessId', pm2_id, function(err, list) {
|
|
if (err) {
|
|
printError(err);
|
|
return exitCli(cst.ERROR_EXIT);
|
|
}
|
|
printOut(cst.PREFIX_MSG + ' Process stopped');
|
|
UX.processing.stop();
|
|
speedList();
|
|
});
|
|
};
|
|
|
|
CLI.generateSample = function(name) {
|
|
var sample = fs.readFileSync(path.join(__dirname, cst.SAMPLE_FILE_PATH));
|
|
var dt = sample.toString().replace(/VARIABLE/g, name);
|
|
var f_name = name + '-pm2.json';
|
|
|
|
fs.writeFileSync(path.join(process.env.PWD, f_name), dt);
|
|
console.info('Sample generated on current folder\n%s :\n', f_name);
|
|
console.info(dt);
|
|
exitCli(cst.SUCCESS_EXIT);
|
|
};
|
|
|
|
CLI.list = function() {
|
|
speedList();
|
|
};
|
|
|
|
CLI.jlist = function(debug) {
|
|
Satan.executeRemote('getMonitorData', {}, function(err, list) {
|
|
if (err) {
|
|
printError(err);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
if (debug)
|
|
printOut(list);
|
|
else
|
|
printOut(JSON.stringify(list));
|
|
exitCli(cst.SUCCESS_EXIT);
|
|
});
|
|
};
|
|
|
|
CLI.flush = function() {
|
|
printOut(cst.PREFIX_MSG + 'Flushing ' + cst.PM2_LOG_FILE_PATH);
|
|
fs.openSync(cst.PM2_LOG_FILE_PATH, 'w');
|
|
|
|
Satan.executeRemote('getMonitorData', {}, function(err, list) {
|
|
if (err) {
|
|
printError(err);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
list.forEach(function(l) {
|
|
printOut(cst.PREFIX_MSG + 'Flushing');
|
|
printOut(cst.PREFIX_MSG + l.pm2_env.pm_out_log_path);
|
|
printOut(cst.PREFIX_MSG + l.pm2_env.pm_err_log_path);
|
|
|
|
fs.openSync(l.pm2_env.pm_out_log_path, 'w');
|
|
fs.openSync(l.pm2_env.pm_err_log_path, 'w');
|
|
});
|
|
exitCli(cst.SUCCESS_EXIT);
|
|
});
|
|
};
|
|
|
|
CLI.describeProcess = function(pm2_id) {
|
|
var found = false;
|
|
Satan.executeRemote('getMonitorData', {}, function(err, list) {
|
|
if (err) {
|
|
console.error('Error retrieving process list: ' + err);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
list.forEach(function(proc) {
|
|
if (proc.pm_id == pm2_id) {
|
|
found = true;
|
|
UX.describeTable(proc);
|
|
}
|
|
});
|
|
|
|
if (found === false) {
|
|
printError('%d id doesn\'t exists', pm2_id);
|
|
return exitCli(cst.ERROR_EXIT);
|
|
}
|
|
return exitCli(cst.SUCCESS_EXIT);
|
|
});
|
|
};
|
|
|
|
CLI.reloadLogs = function() {
|
|
printOut('Reloading all logs...');
|
|
Satan.executeRemote('reloadLogs', {}, function(err, logs) {
|
|
if (err) printError(err);
|
|
printOut('All logs reloaded');
|
|
exitCli(cst.SUCCESS_EXIT);
|
|
});
|
|
};
|
|
|
|
CLI.sendSignalToProcessName = function(signal, process_name) {
|
|
Satan.executeRemote('sendSignalToProcessName', {
|
|
signal : signal,
|
|
process_name : process_name
|
|
}, function(err, list) {
|
|
if (err) {
|
|
printError(err);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
printOut(cst.PREFIX_MSG + 'Succesfully sent signal %s to process name %s', signal, process_name);
|
|
UX.processing.stop();
|
|
speedList();
|
|
});
|
|
};
|
|
|
|
CLI.sendSignalToProcessId = function(signal, process_id) {
|
|
Satan.executeRemote('sendSignalToProcessId', {
|
|
signal : signal,
|
|
process_id : process_id
|
|
}, function(err, list) {
|
|
if (err) {
|
|
printError(err);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
printOut(cst.PREFIX_MSG + 'Succesfully sent signal %s to process id %s', signal, process_id);
|
|
UX.processing.stop();
|
|
speedList();
|
|
});
|
|
};
|
|
|
|
CLI.monit = function() {
|
|
Satan.executeRemote('getMonitorData', {}, function(err, list) {
|
|
if (err) {
|
|
printError(err);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
if (Object.keys(list).length == 0) {
|
|
printOut(cst.PREFIX_MSG + 'No online process to monitor');
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
|
|
Monit.init(list);
|
|
|
|
function refresh(cb) {
|
|
Satan.executeRemote('getMonitorData', {}, function(err, list) {
|
|
if (err) {
|
|
console.error('Error retrieving process list: ' + err);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
setTimeout(function() {
|
|
Monit.refresh(list);
|
|
refresh();
|
|
}, 400);
|
|
});
|
|
}
|
|
refresh();
|
|
});
|
|
};
|
|
|
|
CLI.streamLogs = function(id) {
|
|
var tdb = {};
|
|
|
|
Satan.executeRemote('getMonitorData', {}, function(err, list) {
|
|
if (err) {
|
|
printError(err);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
|
|
printOut('########### Starting streaming logs for [%s] process', id || 'all');
|
|
list.forEach(function(proc) {
|
|
if ((!id || (id && !isNaN(parseInt(id)) && proc.pm_id == id)) ||
|
|
(!id || (id && isNaN(parseInt(id)) && proc.pm2_env.name == id))) {
|
|
var app_name = proc.pm2_env.name || p.basename(proc.pm2_env.pm_exec_path);
|
|
|
|
if (proc.pm2_env.pm_out_log_path)
|
|
Log.stream(proc.pm2_env.pm_out_log_path,
|
|
app_name + '-' + proc.pm_id + ' (out)');
|
|
if (proc.pm2_env.pm_err_log_path)
|
|
Log.stream(proc.pm2_env.pm_err_log_path,
|
|
app_name + '-' + proc.pm_id + ' (err)');
|
|
}
|
|
});
|
|
|
|
});
|
|
};
|
|
|
|
CLI.killDaemon = function() {
|
|
printOut('Killing pm2...');
|
|
|
|
Satan.executeRemote('getMonitorData', {}, function(err, list) {
|
|
if (err) {
|
|
console.error('Error retrieving process list: ' + err);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
|
|
async.eachLimit(list, 2, function(proc, next) {
|
|
Satan.executeRemote('deleteProcessId', proc.pm2_env.pm_id, function(err, res) {
|
|
if (err)
|
|
printError('Error : ' + err);
|
|
printOut('Process %s stopped', proc.pm2_env.name);
|
|
return next();
|
|
});
|
|
return false;
|
|
}, function(err) {
|
|
printOut('All processes stopped');
|
|
Satan.killDaemon(function(err, res) {
|
|
if (err) {
|
|
printError(err);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
console.info('PM2 stopped');
|
|
exitCli(cst.SUCCESS_EXIT);
|
|
});
|
|
});
|
|
|
|
});
|
|
|
|
};
|
|
|
|
var WatchDog = require('./WatchDog.js');
|
|
|
|
CLI.subscribe = function(email) {
|
|
printOut('Subscribing...');
|
|
|
|
WatchDog.createConfFile(email, function() {
|
|
printOut('PM2 is now ready for monitoring via PING strategy. To enable it, please restart pm2');
|
|
printOut('For more informations : https://github.com/Unitech/pm2#builtin-remote-monitoring');
|
|
exitCli(cst.SUCCESS_EXIT);
|
|
});
|
|
};
|
|
|
|
CLI.unsubscribe = function(email) {
|
|
printOut('Unsubscribing to monitoring letter...');
|
|
|
|
WatchDog.unsubscribe(function() {
|
|
printOut('Succefully unsubscribed from monitoring watchdog');
|
|
exitCli(cst.SUCCESS_EXIT);
|
|
});
|
|
};
|
|
|
|
|
|
//
|
|
// Private methods
|
|
//
|
|
var gl_retry = 0;
|
|
function speedList() {
|
|
var self = this;
|
|
|
|
UX.processing.stop();
|
|
|
|
getInteractInfo(function(i_err, interact_infos) {
|
|
|
|
Satan.executeRemote('getMonitorData', {}, function(err, list) {
|
|
if (err) {
|
|
if (gl_retry == 0) {
|
|
gl_retry += 1;
|
|
return setTimeout(speedList, 1400);
|
|
}
|
|
console.error('Error retrieving process list: %s.\nA process seems to be on infinite loop, retry in 5 seconds',err);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
if (commander.miniList && !commander.silent)
|
|
UX.miniDisplay(list);
|
|
else if (!commander.silent) {
|
|
if (interact_infos) {
|
|
printOut('●'.green.bold + ' Connected to VitalSigns public id : %s - machine name : %s', interact_infos.public_key, interact_infos.machine_name);
|
|
}
|
|
UX.dispAsTable(list, interact_infos);
|
|
printOut(' Use `pm2 desc[ribe] <id>` to get more details');
|
|
}
|
|
|
|
if (commander.daemon) {
|
|
return exitCli(cst.SUCCESS_EXIT);
|
|
}
|
|
else {
|
|
printOut('--no-daemon option enabled = do not exit pm2 CLI');
|
|
printOut('PM2 dameon PID = %s', fs.readFileSync(cst.PM2_PID_FILE_PATH));
|
|
return Log.stream(cst.PM2_LOG_FILE_PATH);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
function printError(msg) {
|
|
if (msg instanceof Error)
|
|
return console.error(msg.message);
|
|
return console.error.apply(console, arguments);
|
|
};
|
|
|
|
function printOut() {
|
|
console.log.apply(console, arguments);
|
|
}
|
|
|
|
function getInteractInfo(cb) {
|
|
InteractorDaemonizer.ping(function(online) {
|
|
if (!online) {
|
|
return cb({msg : 'offline'});
|
|
}
|
|
InteractorDaemonizer.launchRPC(function() {
|
|
InteractorDaemonizer.rpc.getInfos(function(err, infos) {
|
|
if (err) {
|
|
return cb(err);
|
|
}
|
|
return cb(null, infos);
|
|
});
|
|
});
|
|
return false;
|
|
});
|
|
};
|
|
|
|
function exitCli(code) {
|
|
Satan.client.sock.close();
|
|
return process.exit(code);
|
|
}
|
|
|
|
function resolvePaths(appConf) {
|
|
var app = Common.resolveAppPaths(appConf, null, console.log);
|
|
if (app instanceof Error) {
|
|
console.error(cst.PREFIX_MSG_ERR + app.message);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
return app;
|
|
}
|
|
|
|
function getProcessByName(name, cb) {
|
|
var arr = [];
|
|
|
|
Satan.executeRemote('getMonitorData', {}, function(err, list) {
|
|
if (err) {
|
|
console.error('Error retrieving process list: ' + err);
|
|
exitCli(cst.ERROR_EXIT);
|
|
}
|
|
|
|
list.forEach(function(proc) {
|
|
if (p.basename(proc.pm2_env.pm_exec_path) == name ||
|
|
p.basename(proc.pm2_env.pm_exec_path) == p.basename(name) ||
|
|
proc.pm2_env.name == name) {
|
|
arr.push(proc);
|
|
}
|
|
});
|
|
return cb(null, arr);
|
|
});
|
|
}
|