@zappinginc/zm2 6.0.14

package/lib/God/ClusterMode.js

@@ -0,0 +1,97 @@
+/**
+ * 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.
+ */
+'use strict';
+
+/**
+ * @file Cluster execution functions related
+ * @author Alexandre Strzelewicz <as@unitech.io>
+ * @project PM2
+ */
+var cluster       = require('cluster');
+var Utility       = require('../Utility.js');
+var pkg           = require('../../package.json');
+
+/**
+ * Description
+ * @method exports
+ * @param {} God
+ * @return
+ */
+module.exports = function ClusterMode(God) {
+
+  /**
+   * For Node apps - Cluster mode
+   * It will wrap the code and enable load-balancing mode
+   * @method nodeApp
+   * @param {} env_copy
+   * @param {} cb
+   * @return Literal
+   */
+  God.nodeApp = function nodeApp(env_copy, cb){
+    var clu = null;
+
+    console.log(`App [${env_copy.name}:${env_copy.pm_id}] starting in -cluster mode-`)
+    if (env_copy.node_args && Array.isArray(env_copy.node_args)) {
+      cluster.settings.execArgv = env_copy.node_args;
+    }
+
+    env_copy._pm2_version = pkg.version;
+
+    try {
+      // node.js cluster clients can not receive deep-level objects or arrays in the forked process, e.g.:
+      // { "args": ["foo", "bar"], "env": { "foo1": "bar1" }} will be parsed to
+      // { "args": "foo, bar", "env": "[object Object]"}
+      // So we passing a stringified JSON here.
+      clu = cluster.fork({pm2_env: JSON.stringify(env_copy), windowsHide: true});
+    } catch(e) {
+      God.logAndGenerateError(e);
+      return cb(e);
+    }
+
+    clu.pm2_env = env_copy;
+
+    /**
+     * Broadcast message to God
+     */
+    clu.on('message', function cluMessage(msg) {
+      /*********************************
+       * If you edit this function
+       * Do the same in ForkMode.js !
+       *********************************/
+      if (msg.data && msg.type) {
+        return God.bus.emit(msg.type ? msg.type : 'process:msg', {
+          at      : Utility.getDate(),
+          data    : msg.data,
+          process :  {
+            pm_id      : clu.pm2_env.pm_id,
+            name       : clu.pm2_env.name,
+            rev        : (clu.pm2_env.versioning && clu.pm2_env.versioning.revision) ? clu.pm2_env.versioning.revision : null,
+            namespace  : clu.pm2_env.namespace
+          }
+        });
+      }
+      else {
+
+        if (typeof msg == 'object' && 'node_version' in msg) {
+          clu.pm2_env.node_version = msg.node_version;
+          return false;
+        }
+
+        return God.bus.emit('process:msg', {
+          at      : Utility.getDate(),
+          raw     : msg,
+          process :  {
+            pm_id      : clu.pm2_env.pm_id,
+            name       : clu.pm2_env.name,
+            namespace  : clu.pm2_env.namespace
+          }
+        });
+      }
+    });
+
+    return cb(null, clu);
+  };
+};

package/lib/God/ForkMode.js

@@ -0,0 +1,297 @@
+/**
+ * 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.
+ */
+'use strict';
+
+/**
+ * @file Fork execution related functions
+ * @author Alexandre Strzelewicz <as@unitech.io>
+ * @project PM2
+ */
+var log           = require('debug')('zm2:fork_mode');
+var fs            = require('fs');
+var Utility       = require('../Utility.js');
+var path          = require('path');
+var dayjs         = require('dayjs');
+var semver  = require('semver')
+var cst           = require('../../constants.js');
+
+/**
+ * Description
+ * @method exports
+ * @param {} God
+ * @return
+ */
+module.exports = function ForkMode(God) {
+  /**
+   * For all apps - FORK MODE
+   * fork the app
+   * @method forkMode
+   * @param {} pm2_env
+   * @param {} cb
+   * @return
+   */
+  God.forkMode = function forkMode(pm2_env, cb) {
+    var command = '';
+    var args    = [];
+
+    console.log(`App [${pm2_env.name}:${pm2_env.pm_id}] starting in -fork mode-`)
+    var spawn = require('child_process').spawn;
+
+    var interpreter = pm2_env.exec_interpreter || process.execPath;
+    var pidFile     = pm2_env.pm_pid_path;
+
+    if (interpreter !== 'none') {
+      command = interpreter;
+
+      if (pm2_env.node_args && Array.isArray(pm2_env.node_args)) {
+        args = args.concat(pm2_env.node_args);
+      }
+
+      // Deprecated - to remove at some point
+      if (process.env.PM2_NODE_OPTIONS) {
+        args = args.concat(process.env.PM2_NODE_OPTIONS.split(' '));
+      }
+
+      if (interpreter === 'node' || RegExp('node$').test(interpreter)) {
+        args.push(path.resolve(path.dirname(module.filename), '..', 'ProcessContainerFork.js'));
+      }
+      else if (interpreter.includes('bun') === true) {
+        args.push(path.resolve(path.dirname(module.filename), '..', 'ProcessContainerForkBun.js'));
+      }
+      else
+        args.push(pm2_env.pm_exec_path);
+    }
+    else {
+      command = pm2_env.pm_exec_path;
+      args = [ ];
+    }
+
+    if (pm2_env.args) {
+      args = args.concat(pm2_env.args);
+    }
+
+    // piping stream o file
+    var stds = {
+      out: pm2_env.pm_out_log_path,
+      err: pm2_env.pm_err_log_path
+    };
+
+    // entire log std if necessary.
+    if ('pm_log_path' in pm2_env){
+      stds.std = pm2_env.pm_log_path;
+    }
+
+    log("stds: %j", stds);
+
+    Utility.startLogging(stds, pm2_env, function(err, result) {
+      if (err) {
+        God.logAndGenerateError(err);
+        return cb(err);
+      };
+
+      try {
+        var options = {
+          env      : pm2_env,
+          detached : true,
+          cwd      : pm2_env.pm_cwd || process.cwd(),
+          stdio    : ['pipe', 'pipe', 'pipe', 'ipc'] //Same as fork() in node core
+        }
+
+        if (typeof(pm2_env.windowsHide) === "boolean") {
+          options.windowsHide = pm2_env.windowsHide;
+        } else {
+          options.windowsHide = true;
+        }
+
+        if (pm2_env.uid) {
+          options.uid = pm2_env.uid
+        }
+
+        if (pm2_env.gid) {
+          options.gid = pm2_env.gid
+        }
+
+        var cspr = spawn(command, args, options);
+      } catch(e) {
+        God.logAndGenerateError(e);
+        return cb(e);
+      }
+
+      if (!cspr || !cspr.stderr || !cspr.stdout) {
+        var fatalError = new Error('Process could not be forked properly, check your system health')
+        God.logAndGenerateError(fatalError);
+        return cb(fatalError);
+      }
+
+      cspr.process = {};
+      cspr.process.pid = cspr.pid;
+      cspr.pm2_env = pm2_env;
+
+      function transformLogToJson(pm2_env, type, data) {
+        return JSON.stringify({
+          message : data.toString(),
+          timestamp : pm2_env.log_date_format ? dayjs().format(pm2_env.log_date_format) : new Date().toISOString(),
+          type : type,
+          process_id : cspr.pm2_env.pm_id,
+          app_name : cspr.pm2_env.name
+        }) + '\n'
+      }
+
+      function prefixLogWithDate(pm2_env, data) {
+        var log_data = []
+        log_data = data.toString().split('\n')
+        if (log_data.length > 1)
+          log_data.pop()
+        log_data = log_data.map(line => `${dayjs().format(pm2_env.log_date_format)}: ${line}\n`)
+        log_data = log_data.join('')
+        return log_data
+      }
+
+      cspr.stderr.on('data', function forkErrData(data) {
+        var log_data = null;
+
+        // via --out /dev/null --err /dev/null
+        if (pm2_env.disable_logs === true) return false;
+
+        if (pm2_env.log_type && pm2_env.log_type === 'json')
+          log_data = transformLogToJson(pm2_env, 'err', data)
+        else if (pm2_env.log_date_format)
+          log_data = prefixLogWithDate(pm2_env, data)
+        else
+          log_data = data.toString();
+
+        God.bus.emit('log:err', {
+          process : {
+            pm_id      : cspr.pm2_env.pm_id,
+            name       : cspr.pm2_env.name,
+            rev        : (cspr.pm2_env.versioning && cspr.pm2_env.versioning.revision) ? cspr.pm2_env.versioning.revision : null,
+            namespace  : cspr.pm2_env.namespace
+          },
+          at  : Utility.getDate(),
+          data : log_data
+        });
+
+        if (Utility.checkPathIsNull(pm2_env.pm_err_log_path) &&
+          (!pm2_env.pm_log_path || Utility.checkPathIsNull(pm2_env.pm_log_path))) {
+          return false;
+        }
+
+        stds.std && stds.std.write && stds.std.write(log_data);
+        stds.err && stds.err.write && stds.err.write(log_data);
+      });
+
+      cspr.stdout.on('data', function forkOutData(data) {
+        var log_data = null;
+
+        if (pm2_env.disable_logs === true)
+          return false;
+
+        if (pm2_env.log_type && pm2_env.log_type === 'json')
+          log_data = transformLogToJson(pm2_env, 'out', data)
+        else if (pm2_env.log_date_format)
+          log_data = prefixLogWithDate(pm2_env, data)
+        else
+          log_data = data.toString()
+
+        God.bus.emit('log:out', {
+          process : {
+            pm_id      : cspr.pm2_env.pm_id,
+            name       : cspr.pm2_env.name,
+            rev        : (cspr.pm2_env.versioning && cspr.pm2_env.versioning.revision) ? cspr.pm2_env.versioning.revision : null,
+            namespace  : cspr.pm2_env.namespace
+          },
+          at  : Utility.getDate(),
+          data : log_data
+        });
+
+        if (Utility.checkPathIsNull(pm2_env.pm_out_log_path) &&
+          (!pm2_env.pm_log_path || Utility.checkPathIsNull(pm2_env.pm_log_path)))
+          return false;
+
+        stds.std && stds.std.write && stds.std.write(log_data);
+        stds.out && stds.out.write && stds.out.write(log_data);
+      });
+
+      /**
+       * Broadcast message to God
+       */
+      cspr.on('message', function forkMessage(msg) {
+        /*********************************
+         * If you edit this function
+         * Do the same in ClusterMode.js !
+         *********************************/
+        if (msg.data && msg.type) {
+          process.nextTick(function() {
+            return God.bus.emit(msg.type ? msg.type : 'process:msg', {
+              at      : Utility.getDate(),
+              data    : msg.data,
+              process : {
+                pm_id      : cspr.pm2_env.pm_id,
+                name       : cspr.pm2_env.name,
+                versioning : cspr.pm2_env.versioning,
+                namespace  : cspr.pm2_env.namespace
+              }
+            });
+          });
+        }
+        else {
+
+          if (typeof msg == 'object' && 'node_version' in msg) {
+            cspr.pm2_env.node_version = msg.node_version;
+            return false;
+          }
+
+          return God.bus.emit('process:msg', {
+            at      : Utility.getDate(),
+            raw     : msg,
+            process :  {
+              pm_id      : cspr.pm2_env.pm_id,
+              name       : cspr.pm2_env.name,
+              namespace  : cspr.pm2_env.namespace
+            }
+          });
+        }
+      });
+
+      try {
+        var pid = cspr.pid
+        if (typeof(pid) !== 'undefined')
+          fs.writeFileSync(pidFile, pid.toString());
+      } catch (e) {
+        console.error(e.stack || e);
+      }
+
+      cspr.once('exit', function forkClose(status) {
+        try {
+          for(var k in stds){
+            if (stds[k] && stds[k].destroy) stds[k].destroy();
+            else if (stds[k] && stds[k].end) stds[k].end();
+            else if (stds[k] && stds[k].close) stds[k].close();
+            stds[k] = stds[k]._file;
+          }
+        } catch(e) { God.logAndGenerateError(e);}
+      });
+
+      cspr._reloadLogs = function(cb) {
+        try {
+          for (var k in stds){
+            if (stds[k] && stds[k].destroy) stds[k].destroy();
+            else if (stds[k] && stds[k].end) stds[k].end();
+            else if (stds[k] && stds[k].close) stds[k].close();
+            stds[k] = stds[k]._file;
+          }
+        } catch(e) { God.logAndGenerateError(e);}
+        //cspr.removeAllListeners();
+        Utility.startLogging(stds, pm2_env, cb);
+      };
+
+      cspr.unref();
+
+      return cb(null, cspr);
+    });
+
+  };
+};

package/lib/God/Methods.js

@@ -0,0 +1,265 @@
+/**
+ * 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.
+ */
+'use strict';
+
+/**
+ * @file Utilities for PM2
+ * @author Alexandre Strzelewicz <as@unitech.io>
+ * @project PM2
+ */
+var p             = require('path');
+var treekill      = require('../TreeKill');
+var cst           = require('../../constants.js');
+
+/**
+ * Description
+ * @method exports
+ * @param {} God
+ * @return
+ */
+module.exports = function(God) {
+
+  /**
+   * Description
+   * @method logAndGenerateError
+   * @param {} err
+   * @return NewExpression
+   */
+  God.logAndGenerateError = function(err) {
+    // Is an Error object
+    if (err instanceof Error) {
+      console.trace(err);
+      return err;
+    }
+    // Is a JSON or simple string
+    console.error(err);
+    return new Error(err);
+  };
+
+  /**
+   * Utility functions
+   * @method getProcesses
+   * @return MemberExpression
+   */
+  God.getProcesses = function() {
+    return God.clusters_db;
+  };
+
+  God.getFormatedProcess = function getFormatedProcesses(id) {
+    if (God.clusters_db[id])
+      return {
+        pid     : God.clusters_db[id].process.pid,
+        name    : God.clusters_db[id].pm2_env.name,
+        pm2_env : God.clusters_db[id].pm2_env,
+        pm_id   : God.clusters_db[id].pm2_env.pm_id
+      };
+    return {};
+  };
+
+  /**
+   * Get formated processes
+   * @method getFormatedProcesses
+   * @return {Array} formated processes
+   */
+  God.getFormatedProcesses = function getFormatedProcesses() {
+    var keys = Object.keys(God.clusters_db);
+    var arr  = new Array();
+    var kl   = keys.length;
+
+    for (var i = 0; i < kl; i++) {
+      var key = keys[i];
+
+      if (!God.clusters_db[key]) continue;
+      // Avoid _old type pm_ids
+      if (isNaN(God.clusters_db[key].pm2_env.pm_id)) continue;
+
+      arr.push({
+        pid     : God.clusters_db[key].process.pid,
+        name    : God.clusters_db[key].pm2_env.name,
+        pm2_env : God.clusters_db[key].pm2_env,
+        pm_id   : God.clusters_db[key].pm2_env.pm_id
+      })
+    }
+    return arr;
+  };
+
+  /**
+   * Description
+   * @method findProcessById
+   * @param {} id
+   * @return ConditionalExpression
+   */
+  God.findProcessById = function findProcessById(id) {
+    return God.clusters_db[id] ? God.clusters_db[id] : null;
+  };
+
+  /**
+   * Description
+   * @method findByName
+   * @param {} name
+   * @return arr
+   */
+  God.findByName = function(name) {
+    var db = God.clusters_db;
+    var arr = [];
+
+    if (name == 'all') {
+      for (var key in db) {
+        // Avoid _old_proc process style
+        if (typeof(God.clusters_db[key].pm2_env.pm_id) === 'number')
+          arr.push(db[key]);
+      }
+      return arr;
+    }
+
+    for (var key in db) {
+      if (God.clusters_db[key].pm2_env.name == name ||
+          God.clusters_db[key].pm2_env.pm_exec_path == p.resolve(name)) {
+        arr.push(db[key]);
+      }
+    }
+    return arr;
+  };
+
+  /**
+   * Check if a process is alive in system processes
+   * Return TRUE if process online
+   * @method checkProcess
+   * @param {} pid
+   * @return
+   */
+  God.checkProcess = function(pid) {
+    if (!pid) return false;
+
+    try {
+      // Sending 0 signal do not kill the process
+      process.kill(pid, 0);
+      return true;
+    }
+    catch (err) {
+      return false;
+    }
+  };
+
+  /**
+   * Description
+   * @method processIsDead
+   * @param {} pid
+   * @param {} cb
+   * @return Literal
+   */
+  God.processIsDead = function(pid, pm2_env, cb, sigkill) {
+    if (!pid) return cb({type : 'param:missing', msg : 'no pid passed'});
+
+    var timeout      = null;
+    var kill_timeout = (pm2_env && pm2_env.kill_timeout) ? pm2_env.kill_timeout : cst.KILL_TIMEOUT;
+    var mode         = pm2_env.exec_mode;
+
+    var timer = setInterval(function() {
+      if (God.checkProcess(pid) === false) {
+        console.log('pid=%d msg=process killed', pid);
+        clearTimeout(timeout);
+        clearInterval(timer);
+        return cb(null, true);
+      }
+      console.log('pid=%d msg=failed to kill - retrying in %dms', pid, pm2_env.kill_retry_time);
+      return false;
+    }, pm2_env.kill_retry_time);
+
+    timeout = setTimeout(function() {
+      clearInterval(timer);
+      if (sigkill) {
+        console.log('Process with pid %d could not be killed', pid);
+        return cb({type : 'timeout', msg : 'timeout'});
+      }
+      else {
+        console.log('Process with pid %d still alive after %sms, sending it SIGKILL now...', pid, kill_timeout);
+
+        if (pm2_env.treekill !== true) {
+          try {
+            process.kill(parseInt(pid), 'SIGKILL');
+          } catch(e) {
+            console.error('[SimpleKill][SIGKILL] %s pid can not be killed', pid, e.stack, e.message);
+          }
+          return God.processIsDead(pid, pm2_env, cb, true);
+        }
+        else {
+          treekill(parseInt(pid), 'SIGKILL', function(err) {
+            return God.processIsDead(pid, pm2_env, cb, true);
+          });
+        }
+      }
+    }, kill_timeout);
+    return false;
+  };
+
+  /**
+   * Description
+   * @method killProcess
+   * @param int pid
+   * @param Object pm2_env
+   * @param function cb
+   * @return CallExpression
+   */
+  God.killProcess = function(pid, pm2_env, cb) {
+    if (!pid) return cb({msg : 'no pid passed or null'});
+
+    if (typeof(pm2_env.pm_id) === 'number' &&
+        (cst.KILL_USE_MESSAGE || pm2_env.shutdown_with_message == true)) {
+      var proc = God.clusters_db[pm2_env.pm_id];
+
+      if (proc && proc.send) {
+        try {
+          proc.send('shutdown');
+        } catch (e) {
+          console.error(`[AppKill] Cannot send "shutdown" message to ${pid}`)
+          console.error(e.stack, e.message)
+        }
+        return God.processIsDead(pid, pm2_env, cb);
+      }
+      else {
+        console.log(`[AppKill] ${pid} pid cannot be notified with send()`)
+      }
+    }
+
+    if (pm2_env.treekill !== true) {
+      try {
+        process.kill(parseInt(pid), cst.KILL_SIGNAL);
+      } catch(e) {
+        console.error('[SimpleKill] %s pid can not be killed', pid, e.stack, e.message);
+      }
+      return God.processIsDead(pid, pm2_env, cb);
+    }
+    else {
+      treekill(parseInt(pid), cst.KILL_SIGNAL, function(err) {
+        return God.processIsDead(pid, pm2_env, cb);
+      });
+    }
+  };
+
+  /**
+   * Description
+   * @method getNewId
+   * @return UpdateExpression
+   */
+  God.getNewId = function() {
+    return God.next_id++;
+  };
+
+  /**
+   * When a process is restarted or reloaded reset fields
+   * to monitor unstable starts
+   * @method resetState
+   * @param {} pm2_env
+   * @return
+   */
+  God.resetState = function(pm2_env) {
+    pm2_env.created_at = Date.now();
+    pm2_env.unstable_restarts = 0;
+    pm2_env.prev_restart_delay = 0;
+  };
+
+};