pm2-gui/pm2-gui.js

var chalk = require('chalk'),
  path = require('path'),
  fs = require('fs'),
  _ = require('lodash'),
  socketIO = require('socket.io'),
  inquirer = require("inquirer"),
  conf = require('./lib/util/conf'),
  Monitor = require('./lib/monitor'),
  Log = require('./lib/util/log'),
  Web = require('./web/index'),
  layout = require('./lib/blessed-widget/layout');

if (path.basename(process.mainModule.filename, '.js') == 'pm2-gui') {
  var cmd, file;
  if (process.argv.length > 2) {
    cmd = process.argv[2];
  }
  if (process.argv.length > 3) {
    file = process.argv[3];
  }
  cmd = cmd || 'start';

  switch (cmd) {
  case 'start':
    startWebServer(file);
    break;
  case 'agent':
    startAgent(file);
    break;
  case 'mon':
    dashboard(file);
    break;
  default:
    Log({
      level: 0,
      prefix: true
    });
    console.error('Command', cmd, 'is not supported!')
    break;
  }
}

exports.startWebServer = startWebServer;
exports.startAgent = startAgent;
exports.dashboard = dashboard;
exports.exitGraceful = exitGraceful;

function startWebServer(confFile) {
  var monitor = slave({
      confFile: confFile
    }),
    options = monitor.options;

  options.port = options.port || 8088;
  var server = Web({
    middleware: function (req, res, next) {
      req._config = options;
      next();
    },
    port: options.port
  });

  monitor.sockio = socketIO(server, {
    origins: options.origins || '*:*'
  });
  monitor.run();
  console.info('Web server is listening on 127.0.0.1:' + options.port);
}

function startAgent(confFile) {
  var monitor = slave({
    confFile: confFile
  });

  var options = monitor.options;
  options.agent = options.agent || {};
  if (options.agent.offline) {
    console.error('Agent is offline, can not start it.');
    return process.exit(0);
  }
  options.port = options.port || 8088;
  var sockio = socketIO();
  sockio.listen(options.port, {
    origins: options.origins || '*:*'
  });
  monitor.sockio = sockio;
  monitor.run();
  console.info('Socket.io server is listening on 0.0.0.0:' + options.port);
}

function dashboard(confFile) {
  // restore cursor;
  process.on('exit', function () {
    process.stdout.write('\u001b[?25h');
  });
  var monitor = slave({
      confFile: confFile
    }),
    options = _.clone(monitor.options),
    q = Monitor.available(options);

  if (!q) {
    console.error('No agent is online, can not start it.');
    return process.exit(0);
  }
  var ql = q.choices.length;
  if (ql == 1) {
    if (q.choices[0].short != 'localhost') {
      console.info('There is just one remoting server online, try to connect it.')
    }
    return _connectToDashboard(monitor, options, Monitor.parseConnectionString(q.choices[0].value));
  }
  if (!options.agent || !options.agent.offline) {
    q.choices.splice(ql - 1, 0, new inquirer.Separator());
  }

  console.info('Remoting servers are online, choose one you are intrested in.')
  console.log('');

  inquirer.prompt(q, function (answers) {
    console.log('');
    _connectToDashboard(monitor, options, Monitor.parseConnectionString(answers.socket_server));
  });
}

function exitGraceful(code, signal) {
  code = code || 0;
  if (signal != '-f') {
    console.debug('Slave has exited, code: ' + code + ', signal: ' + (signal || 'NULL'));
  }
  var fds = 0;

  function tryToExit() {
    if ((fds & 1) && (fds & 2)) {
      process.exit(code);
    }
  }

  [process.stdout, process.stderr].forEach(function (std) {
    var fd = std.fd;
    if (!std.bufferSize) {
      fds = fds | fd;
    } else {
      std.write && std.write('', function () {
        fds = fds | fd;
        tryToExit();
      });
    }
  });
  tryToExit();
}

function slave(options) {
  process.title = 'pm2-gui slave';
  options = options || {};
  var confFile = options.confFile;
  if (!confFile) {
    confFile = path.resolve(__dirname, './pm2-gui.ini');

    if (!fs.existsSync(confFile)) {
      console.error(chalk.bold(confFile), 'does not exist!');
      return process.exit(0);
    }
  }
  var monitor = Monitor({
    confFile: confFile
  });

  Log(monitor.options.log);

  console.log(chalk.cyan(
    '\n' +
    '█▀▀█ █▀▄▀█ █▀█ ░░ ▒█▀▀█ ▒█░▒█ ▀█▀\n' +
    '█░░█ █░▀░█ ░▄▀ ▀▀ ▒█░▄▄ ▒█░▒█ ▒█░\n' +
    '█▀▀▀ ▀░░░▀ █▄▄ ░░ ▒█▄▄█ ░▀▄▄▀ ▄█▄\n'));

  process.on('SIGTERM', shutdown);
  process.on('SIGINT', shutdown);
  process.on('SIGHUP', restart);
  process.on('uncaughtException', caughtException);
  process.on('exit', exitGraceful)

  function shutdown(code, signal) {
    console.info('Shutting down....');
    monitor.quit();
    console.info('Shutdown complete!');
    exitGraceful(code, '-f');
  }

  function restart() {
    if (process.send) {
      process.send({
        action: 'restart'
      });
    } else {
      console.error('No IPC found, could not restart monitor, shutting down.');
      shutdown(1);
    }
  }

  function caughtException(err) {
    console.error(err.stack);
    shutdown(1);
  }

  return monitor;
}

function _connectToDashboard(monitor, options, connection) {
  connection = _.extend({}, options, connection);
  if (!!~['127.0.0.1', '0.0.0.0', 'localhost'].indexOf(connection.hostname)) {
    return monitor.connect(connection, function (socket) {
      console.info('Agent is online, try to connect it in dashboard directly.');
      layout(connection).render(monitor);
    }, function (err, socket) {
      if (err == 'unauthorized') {
        console.error('There was an error with the authentication:', err);
        return process.exit(0);
      }
      console.warn('Agent is offline, try to start it.');
      var sockio = socketIO();
      sockio.listen(connection.port, {
        origins: options.origins || '*:*'
      });
      monitor.sockio = sockio;
      monitor.run();
      layout(connection).render(monitor);
    });
  }

  layout(connection).render(monitor);
}