@zappinginc/zm2 6.0.14

package/lib/API/LogManagement.js

@@ -0,0 +1,371 @@
+var chalk  = require('ansis');
+var util   = require('util');
+var fs     = require('fs');
+var exec   = require('child_process').exec;
+var path   = require('path');
+
+var Log    = require('./Log');
+var cst    = require('../../constants.js');
+var Common = require('../Common.js');
+
+module.exports = function(CLI) {
+
+  /**
+   * Description
+   * @method flush
+   * @return
+   */
+  CLI.prototype.flush = function(api, cb) {
+    var that = this;
+
+    if (!api) {
+      Common.printOut(cst.PREFIX_MSG + 'Flushing ' + cst.PM2_LOG_FILE_PATH);
+      fs.closeSync(fs.openSync(cst.PM2_LOG_FILE_PATH, 'w'));
+    }
+
+    that.Client.executeRemote('getMonitorData', {}, function(err, list) {
+      if (err) {
+        Common.printError(err);
+        return cb ? cb(Common.retErr(err)) : that.exitCli(cst.ERROR_EXIT);
+      }
+      list.forEach(function(l) {
+        if (typeof api == 'undefined') {
+          Common.printOut(cst.PREFIX_MSG + 'Flushing:');
+          Common.printOut(cst.PREFIX_MSG + l.pm2_env.pm_out_log_path);
+          Common.printOut(cst.PREFIX_MSG + l.pm2_env.pm_err_log_path);
+
+          if (l.pm2_env.pm_log_path) {
+            Common.printOut(cst.PREFIX_MSG + l.pm2_env.pm_log_path);
+            fs.closeSync(fs.openSync(l.pm2_env.pm_log_path, 'w'));
+          }
+          fs.closeSync(fs.openSync(l.pm2_env.pm_out_log_path, 'w'));
+          fs.closeSync(fs.openSync(l.pm2_env.pm_err_log_path, 'w'));
+        }
+        else if (l.pm2_env.pm_id == api || l.pm2_env.name === api) {
+          Common.printOut(cst.PREFIX_MSG + 'Flushing:');
+
+          if (l.pm2_env.pm_log_path && fs.existsSync(l.pm2_env.pm_log_path)) {
+            Common.printOut(cst.PREFIX_MSG + l.pm2_env.pm_log_path);
+            fs.closeSync(fs.openSync(l.pm2_env.pm_log_path, 'w'));
+          }
+
+          if (l.pm2_env.pm_out_log_path && fs.existsSync(l.pm2_env.pm_out_log_path)) {
+            Common.printOut(cst.PREFIX_MSG + l.pm2_env.pm_out_log_path);
+            fs.closeSync(fs.openSync(l.pm2_env.pm_out_log_path, 'w'));
+          }
+
+          if (l.pm2_env.pm_err_log_path && fs.existsSync(l.pm2_env.pm_err_log_path)) {
+            Common.printOut(cst.PREFIX_MSG + l.pm2_env.pm_err_log_path);
+            fs.closeSync(fs.openSync(l.pm2_env.pm_err_log_path, 'w'));
+          }
+        }
+      });
+
+      Common.printOut(cst.PREFIX_MSG + 'Logs flushed');
+      return cb ? cb(null, list) : that.exitCli(cst.SUCCESS_EXIT);
+    });
+  };
+
+  CLI.prototype.logrotate = function(opts, cb) {
+    var that = this;
+
+    if (process.getuid() != 0) {
+      return exec('whoami', function(err, stdout, stderr) {
+        Common.printError(cst.PREFIX_MSG + 'You have to run this command as root. Execute the following command:');
+        Common.printError(cst.PREFIX_MSG + chalk.gray('      sudo env PATH=$PATH:' + path.dirname(process.execPath) + ' pm2 logrotate -u ' + stdout.trim()));
+
+        cb ? cb(Common.retErr('You have to run this with elevated rights')) : that.exitCli(cst.ERROR_EXIT);
+      });
+    }
+
+    if (!fs.existsSync('/etc/logrotate.d')) {
+      Common.printError(cst.PREFIX_MSG + '/etc/logrotate.d does not exist we can not copy the default configuration.');
+      return cb ? cb(Common.retErr('/etc/logrotate.d does not exist')) : that.exitCli(cst.ERROR_EXIT);
+    }
+
+    var templatePath = path.join(cst.TEMPLATE_FOLDER, cst.LOGROTATE_SCRIPT);
+    Common.printOut(cst.PREFIX_MSG + 'Getting logrorate template ' + templatePath);
+    var script = fs.readFileSync(templatePath, {encoding: 'utf8'});
+
+    var user = opts.user || 'root';
+
+    script = script.replace(/%HOME_PATH%/g, cst.PM2_ROOT_PATH)
+      .replace(/%USER%/g, user);
+
+    try {
+      fs.writeFileSync('/etc/logrotate.d/pm2-'+user, script);
+    } catch (e) {
+      console.error(e.stack || e);
+    }
+
+    Common.printOut(cst.PREFIX_MSG + 'Logrotate configuration added to /etc/logrotate.d/pm2');
+    return cb ? cb(null, {success:true}) : that.exitCli(cst.SUCCESS_EXIT);
+  };
+
+  /**
+   * Description
+   * @method reloadLogs
+   * @return
+   */
+  CLI.prototype.reloadLogs = function(cb) {
+    var that = this;
+
+    Common.printOut('Reloading all logs...');
+    that.Client.executeRemote('reloadLogs', {}, function(err, logs) {
+      if (err) {
+        Common.printError(err);
+        return cb ? cb(Common.retErr(err)) : that.exitCli(cst.ERROR_EXIT);
+      }
+      Common.printOut('All logs reloaded');
+      return cb ? cb(null, logs) : that.exitCli(cst.SUCCESS_EXIT);
+    });
+  };
+
+  /**
+   * Description
+   * @method streamLogs
+   * @param {String} id
+   * @param {Number} lines
+   * @param {Boolean} raw
+   * @return
+   */
+  CLI.prototype.streamLogs = function(id, lines, raw, timestamp, exclusive, highlight) {
+    var that = this;
+    var files_list = [];
+
+    // If no argument is given, we stream logs for all running apps
+    id = id || 'all';
+    lines = lines !== undefined ? lines : 20;
+    lines = lines < 0 ? -(lines) : lines;
+
+    // Avoid duplicates and check if path is different from '/dev/null'
+    var pushIfUnique = function(entry) {
+      var exists = false;
+
+      if (entry.path.toLowerCase
+          && entry.path.toLowerCase() !== '/dev/null') {
+
+        files_list.some(function(file) {
+          if (file.path === entry.path)
+            exists = true;
+          return exists;
+        });
+
+        if (exists)
+          return;
+
+        files_list.push(entry);
+      }
+    }
+
+    // Get the list of all running apps
+    that.Client.executeRemote('getMonitorData', {}, function(err, list) {
+      var regexList = [];
+      var namespaceList = [];
+
+      if (err) {
+        Common.printError(err);
+        that.exitCli(cst.ERROR_EXIT);
+      }
+
+      if (lines === 0)
+        return Log.stream(that.Client, id, raw, timestamp, exclusive, highlight);
+
+      Common.printOut(chalk.bold.gray(util.format.call(this, '[TAILING] Tailing last %d lines for [%s] process%s (change the value with --lines option)', lines, id, id === 'all' ? 'es' : '')));
+
+      // Populate the array `files_list` with the paths of all files we need to tail
+      list.forEach(function(proc) {
+        if (proc.pm2_env && (id === 'all' ||
+                             proc.pm2_env.name == id ||
+                             proc.pm2_env.pm_id == id)) {
+          if (proc.pm2_env.pm_out_log_path && exclusive !== 'err')
+            pushIfUnique({
+              path     : proc.pm2_env.pm_out_log_path,
+              app_name :proc.pm2_env.pm_id + '|' + proc.pm2_env.name,
+              type     : 'out'});
+          if (proc.pm2_env.pm_err_log_path && exclusive !== 'out')
+            pushIfUnique({
+              path     : proc.pm2_env.pm_err_log_path,
+              app_name : proc.pm2_env.pm_id + '|' + proc.pm2_env.name,
+              type     : 'err'
+            });
+        } else if(proc.pm2_env && proc.pm2_env.namespace == id) {
+          if(namespaceList.indexOf(proc.pm2_env.name) === -1) {
+            namespaceList.push(proc.pm2_env.name)
+          }
+          if (proc.pm2_env.pm_out_log_path && exclusive !== 'err')
+            pushIfUnique({
+              path     : proc.pm2_env.pm_out_log_path,
+              app_name :proc.pm2_env.pm_id + '|' + proc.pm2_env.name,
+              type     : 'out'});
+          if (proc.pm2_env.pm_err_log_path && exclusive !== 'out')
+            pushIfUnique({
+              path     : proc.pm2_env.pm_err_log_path,
+              app_name : proc.pm2_env.pm_id + '|' + proc.pm2_env.name,
+              type     : 'err'
+            });
+        }
+        // Populate the array `files_list` with the paths of all files we need to tail, when log in put is a regex
+        else if(proc.pm2_env && (isNaN(id) && id[0] === '/' && id[id.length - 1] === '/')) {
+          var regex = new RegExp(id.replace(/\//g, ''));
+          if(regex.test(proc.pm2_env.name)) {
+            if(regexList.indexOf(proc.pm2_env.name) === -1) {
+              regexList.push(proc.pm2_env.name);
+            }
+            if (proc.pm2_env.pm_out_log_path && exclusive !== 'err')
+              pushIfUnique({
+                path     : proc.pm2_env.pm_out_log_path,
+                app_name : proc.pm2_env.pm_id + '|' + proc.pm2_env.name,
+                type     : 'out'});
+            if (proc.pm2_env.pm_err_log_path && exclusive !== 'out')
+              pushIfUnique({
+                path     : proc.pm2_env.pm_err_log_path,
+                app_name : proc.pm2_env.pm_id + '|' + proc.pm2_env.name,
+                type     : 'err'
+              });
+          }
+        }
+      });
+
+    //for fixing issue https://github.com/Unitech/pm2/issues/3506
+     /* if (files_list && files_list.length == 0) {
+        Common.printError(cst.PREFIX_MSG_ERR + 'No file to stream for app [%s], exiting.', id);
+        return process.exit(cst.ERROR_EXIT);
+      }*/
+
+      if (!raw && (id === 'all' || id === 'PM2') && exclusive === false) {
+        Log.tail([{
+          path     : cst.PM2_LOG_FILE_PATH,
+          app_name : 'PM2',
+          type     : 'PM2'
+        }], lines, raw, function() {
+          Log.tail(files_list, lines, raw, function() {
+            Log.stream(that.Client, id, raw, timestamp, exclusive, highlight);
+          });
+        });
+      }
+      else {
+        Log.tail(files_list, lines, raw, function() {
+          if(regexList.length > 0) {
+            regexList.forEach(function(id) {
+                Log.stream(that.Client, id, raw, timestamp, exclusive, highlight);
+            })
+          }
+          else if(namespaceList.length > 0) {
+            namespaceList.forEach(function(id) {
+                Log.stream(that.Client, id, raw, timestamp, exclusive, highlight);
+            })
+          }
+          else {
+            Log.stream(that.Client, id, raw, timestamp, exclusive, highlight);
+          }
+        });
+      }
+    });
+  };
+
+  /**
+   * Description
+   * @method printLogs
+   * @param {String} id
+   * @param {Number} lines
+   * @param {Boolean} raw
+   * @return
+   */
+  CLI.prototype.printLogs = function(id, lines, raw, timestamp, exclusive) {
+    var that = this;
+    var files_list = [];
+
+    // If no argument is given, we stream logs for all running apps
+    id = id || 'all';
+    lines = lines !== undefined ? lines : 20;
+    lines = lines < 0 ? -(lines) : lines;
+
+    // Avoid duplicates and check if path is different from '/dev/null'
+    var pushIfUnique = function(entry) {
+      var exists = false;
+
+      if (entry.path.toLowerCase
+          && entry.path.toLowerCase() !== '/dev/null') {
+
+        files_list.some(function(file) {
+          if (file.path === entry.path)
+            exists = true;
+          return exists;
+        });
+
+        if (exists)
+          return;
+
+        files_list.push(entry);
+      }
+    }
+
+    // Get the list of all running apps
+    that.Client.executeRemote('getMonitorData', {}, function(err, list) {
+      if (err) {
+        Common.printError(err);
+        that.exitCli(cst.ERROR_EXIT);
+      }
+
+      if (lines <= 0) {
+        return that.exitCli(cst.SUCCESS_EXIT)
+      }
+
+      Common.printOut(chalk.bold.gray(util.format.call(this, '[TAILING] Tailing last %d lines for [%s] process%s (change the value with --lines option)', lines, id, id === 'all' ? 'es' : '')));
+
+      // Populate the array `files_list` with the paths of all files we need to tail
+      list.forEach(function(proc) {
+        if (proc.pm2_env && (id === 'all' ||
+                             proc.pm2_env.name == id ||
+                             proc.pm2_env.pm_id == id)) {
+          if (proc.pm2_env.pm_out_log_path && exclusive !== 'err')
+            pushIfUnique({
+              path     : proc.pm2_env.pm_out_log_path,
+              app_name :proc.pm2_env.pm_id + '|' + proc.pm2_env.name,
+              type     : 'out'});
+          if (proc.pm2_env.pm_err_log_path && exclusive !== 'out')
+            pushIfUnique({
+              path     : proc.pm2_env.pm_err_log_path,
+              app_name : proc.pm2_env.pm_id + '|' + proc.pm2_env.name,
+              type     : 'err'
+            });
+        }
+        // Populate the array `files_list` with the paths of all files we need to tail, when log in put is a regex
+        else if(proc.pm2_env && (isNaN(id) && id[0] === '/' && id[id.length - 1] === '/')) {
+          var regex = new RegExp(id.replace(/\//g, ''));
+          if(regex.test(proc.pm2_env.name)) {
+            if (proc.pm2_env.pm_out_log_path && exclusive !== 'err')
+              pushIfUnique({
+                path     : proc.pm2_env.pm_out_log_path,
+                app_name : proc.pm2_env.pm_id + '|' + proc.pm2_env.name,
+                type     : 'out'});
+            if (proc.pm2_env.pm_err_log_path && exclusive !== 'out')
+              pushIfUnique({
+                path     : proc.pm2_env.pm_err_log_path,
+                app_name : proc.pm2_env.pm_id + '|' + proc.pm2_env.name,
+                type     : 'err'
+              });
+          }
+        }
+      });
+
+      if (!raw && (id === 'all' || id === 'PM2') && exclusive === false) {
+        Log.tail([{
+          path     : cst.PM2_LOG_FILE_PATH,
+          app_name : 'PM2',
+          type     : 'PM2'
+        }], lines, raw, function() {
+          Log.tail(files_list, lines, raw, function() {
+            that.exitCli(cst.SUCCESS_EXIT);
+          });
+        });
+      }
+      else {
+        Log.tail(files_list, lines, raw, function() {
+          that.exitCli(cst.SUCCESS_EXIT);
+        });
+      }
+    });
+  };
+};

package/lib/API/Modules/LOCAL.js

@@ -0,0 +1,122 @@
+
+var path          = require('path');
+var fs            = require('fs');
+var os            = require('os');
+var spawn         = require('child_process').spawn;
+var chalk         = require('ansis');
+var parallel      = require('async/parallel');
+
+var Configuration = require('../../Configuration.js');
+var cst           = require('../../../constants.js');
+var Common        = require('../../Common');
+var Utility       = require('../../Utility.js');
+var readline = require('readline')
+
+var INTERNAL_MODULES = {
+  'deep-monitoring': {
+    dependencies: [{name: 'v8-profiler-node8'}, {name: 'gc-stats'}, {name: 'event-loop-inspector'}]
+  },
+  'gc-stats': {name: 'gc-stats'},
+  'event-loop-inspector': {name: 'event-loop-inspector'},
+  'v8-profiler': {name: 'v8-profiler-node8'},
+  'profiler': {name: 'v8-profiler-node8'},
+  'typescript': {dependencies: [{name: 'typescript'}, {name: 'ts-node@latest'}]},
+  'livescript': {name: 'livescript'},
+  'coffee-script': {name: 'coffee-script', message: 'Coffeescript v1 support'},
+  'coffeescript': {name: 'coffeescript', message: 'Coffeescript v2 support'}
+};
+
+module.exports = {
+  install,
+  INTERNAL_MODULES,
+  installMultipleModules
+}
+
+
+function install(module, cb, verbose) {
+  if (!module || !module.name || module.name.length === 0) {
+    return cb(new Error('No module name !'));
+  }
+
+  if (typeof verbose === 'undefined') {
+    verbose = true;
+  }
+
+  installLangModule(module.name, function (err) {
+    var display = module.message || module.name;
+    if (err) {
+      if (verbose) { Common.printError(cst.PREFIX_MSG_MOD_ERR + chalk.bold.green(display + ' installation has FAILED (checkout previous logs)')); }
+      return cb(err);
+    }
+
+    if (verbose) { Common.printOut(cst.PREFIX_MSG + chalk.bold.green(display + ' ENABLED')); }
+    return cb();
+  });
+}
+
+function installMultipleModules(modules, cb, post_install) {
+  var functionList = [];
+  for (var i = 0; i < modules.length; i++) {
+    functionList.push((function (index) {
+      return function (callback) {
+        var module = modules[index];
+        if (typeof modules[index] === 'string') {
+          module = {name: modules[index]};
+        }
+        install(module, function ($post_install, err, $index, $modules) {
+          try {
+            var install_instance = spawn(post_install[modules[index]], {
+              stdio : 'inherit',
+              windowsHide: true,
+              env: process.env,
+              shell : true,
+              cwd : process.cwd()
+            });
+            Common.printOut(cst.PREFIX_MSG_MOD + 'Running configuraton script.');
+          }
+          catch(e)
+          {
+            Common.printOut(cst.PREFIX_MSG_MOD + 'No configuraton script found.');
+          }
+          callback(null, {  module: module, err: err });
+        }, false);
+      };
+    })(i));
+  }
+
+  parallel(functionList, function (err, results) {
+    for (var i = 0; i < results.length; i++) {
+      var display = results[i].module.message || results[i].module.name;
+      if (results[i].err) {
+        err = results[i].err;
+        Common.printError(cst.PREFIX_MSG_MOD_ERR + chalk.bold.green(display + ' installation has FAILED (checkout previous logs)'));
+      } else {
+        Common.printOut(cst.PREFIX_MSG + chalk.bold.green(display + ' ENABLED'));
+      }
+    }
+
+    if(cb) cb(err);
+  });
+};
+
+function installLangModule(module_name, cb) {
+  var node_module_path = path.resolve(path.join(__dirname, '../../../'));
+  Common.printOut(cst.PREFIX_MSG_MOD + 'Calling ' + chalk.bold.red('[NPM]') + ' to install ' + module_name + ' ...');
+
+  var install_instance = spawn(cst.IS_WINDOWS ? 'npm.cmd' : 'npm', ['install', module_name, '--loglevel=error'], {
+    stdio : 'inherit',
+    env: process.env,
+		shell : true,
+    cwd : node_module_path
+  });
+
+  install_instance.on('close', function(code) {
+    if (code > 0)
+      return cb(new Error('Module install failed'));
+    return cb(null);
+  });
+
+  install_instance.on('error', function (err) {
+    console.error(err.stack || err);
+  });
+};

package/lib/API/Modules/Modularizer.js

@@ -0,0 +1,148 @@
+/**
+ * Copyright 2013-2022 the PM2 project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+var path          = require('path');
+var eachLimit     = require('async/eachLimit');
+var forEachLimit  = require('async/forEachLimit');
+
+var Configuration = require('../../Configuration.js');
+var cst = require('../../../constants.js');
+var Common = require('../../Common');
+var NPM = require('./NPM.js')
+var TAR = require('./TAR.js')
+var LOCAL = require('./LOCAL.js')
+
+var Modularizer = module.exports = {};
+
+/**
+ * PM2 Module System.
+ */
+Modularizer.install = function (CLI, module_name, opts, cb) {
+  module_name = module_name.replace(/[;`|]/g, "");
+  if (typeof(opts) == 'function') {
+    cb = opts;
+    opts = {};
+  }
+
+  if (LOCAL.INTERNAL_MODULES.hasOwnProperty(module_name)) {
+    Common.logMod(`Adding dependency ${module_name} to PM2 Runtime`);
+    var currentModule = LOCAL.INTERNAL_MODULES[module_name];
+    if (currentModule && currentModule.hasOwnProperty('dependencies')) {
+      LOCAL.installMultipleModules(currentModule.dependencies, cb);
+    } else {
+      LOCAL.install(currentModule, cb);
+    }
+  }
+  else if (module_name == '.') {
+    Common.logMod(`Installing local NPM module`);
+    return NPM.localStart(CLI, opts, cb)
+  }
+  else if (opts.tarball || /\.tar\.gz$/i.test(module_name)) {
+    Common.logMod(`Installing TAR module`);
+    TAR.install(CLI, module_name, opts, cb)
+  }
+  else {
+    Common.logMod(`Installing NPM ${module_name} module`);
+    NPM.install(CLI, module_name, opts, cb)
+  }
+};
+
+/**
+ * Launch All Modules
+ * Used PM2 at startup
+ */
+Modularizer.launchModules = function(CLI, cb) {
+  var modules = Modularizer.listModules();
+
+  if (!modules) return cb();
+
+  // 1#
+  function launchNPMModules(cb) {
+    if (!modules.npm_modules) return launchTARModules(cb)
+
+    eachLimit(Object.keys(modules.npm_modules), 1, function(module_name, next) {
+      NPM.start(CLI, modules, module_name, next)
+    }, function() {
+      launchTARModules(cb)
+    });
+  }
+
+  // 2#
+  function launchTARModules(cb) {
+    if (!modules.tar_modules) return cb()
+
+    eachLimit(Object.keys(modules.tar_modules), 1, function(module_name, next) {
+      TAR.start(CLI, module_name, next)
+    }, function() {
+      return cb ? cb(null) : false;
+    });
+  }
+
+  launchNPMModules(cb)
+}
+
+Modularizer.package = function(CLI, module_path, cb) {
+  var fullpath = process.cwd()
+  if (module_path)
+    fullpath = require('path').resolve(module_path)
+  TAR.packager(fullpath, process.cwd(), cb)
+}
+
+/**
+ * Uninstall module
+ */
+Modularizer.uninstall = function(CLI, module_name, cb) {
+  Common.printOut(cst.PREFIX_MSG_MOD + 'Uninstalling module ' + module_name);
+  var modules_list = Modularizer.listModules();
+
+  if (module_name == 'all') {
+    if (!modules_list) return cb();
+
+    return forEachLimit(Object.keys(modules_list.npm_modules), 1, function(module_name, next) {
+      NPM.uninstall(CLI, module_name, next)
+    }, () => {
+      forEachLimit(Object.keys(modules_list.tar_modules), 1, function(module_name, next) {
+        TAR.uninstall(CLI, module_name, next)
+      }, cb)
+    });
+  }
+
+  if (modules_list.npm_modules[module_name]) {
+    NPM.uninstall(CLI, module_name, cb)
+  } else if (modules_list.tar_modules[module_name]) {
+    TAR.uninstall(CLI, module_name, cb)
+  }
+  else {
+    Common.errMod('Unknown module')
+    CLI.exitCli(1)
+  }
+};
+
+/**
+ * List modules based on modules present in ~/.pm2/modules/ folder
+ */
+Modularizer.listModules = function() {
+  return {
+    npm_modules: Configuration.getSync(cst.MODULE_CONF_PREFIX) || {},
+    tar_modules: Configuration.getSync(cst.MODULE_CONF_PREFIX_TAR) || {}
+  }
+};
+
+Modularizer.getAdditionalConf = function(app_name) {
+  return NPM.getModuleConf(app_name)
+};
+
+Modularizer.publish = function(PM2, folder, opts, cb) {
+  if (opts.npm == true) {
+    NPM.publish(opts, cb)
+  }
+  else {
+    TAR.publish(PM2, folder, cb)
+  }
+};
+
+Modularizer.generateSample = function(app_name, cb) {
+  NPM.generateSample(app_name, cb)
+};