@zappinginc/zm2 6.0.14

package/lib/Client.js

@@ -0,0 +1,776 @@
+/**
+ * Copyright 2013-2022 the ZM2 project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var debug          = require('debug')('zm2:client');
+var Common         = require('./Common.js');
+var KMDaemon       = require('@pm2/agent/src/InteractorClient');
+var rpc            = require('pm2-axon-rpc');
+var forEach        = require('async/forEach');
+var axon           = require('pm2-axon');
+var util           = require('util');
+var fs             = require('fs');
+var path           = require('path');
+var pkg            = require('../package.json');
+var which          = require('./tools/which.js');
+
+function noop() {}
+
+var Client = module.exports = function(opts) {
+  if (!opts) opts = {};
+
+  if (!opts.conf)
+    this.conf = require('../constants.js');
+  else {
+    this.conf     = opts.conf;
+  }
+
+  this.daemon_mode = typeof(opts.daemon_mode) === 'undefined' ? true : opts.daemon_mode;
+  this.pm2_home    = this.conf.PM2_ROOT_PATH;
+  this.secret_key   = opts.secret_key;
+  this.public_key   = opts.public_key;
+  this.machine_name = opts.machine_name;
+
+  // Create all folders and files needed
+  // Client depends to that to interact with ZM2 properly
+  this.initFileStructure(this.conf);
+
+  debug('Using RPC file %s', this.conf.DAEMON_RPC_PORT);
+  debug('Using PUB file %s', this.conf.DAEMON_PUB_PORT);
+  this.rpc_socket_file = this.conf.DAEMON_RPC_PORT;
+  this.pub_socket_file = this.conf.DAEMON_PUB_PORT;
+};
+
+// @breaking change (noDaemonMode has been drop)
+// @todo ret err
+Client.prototype.start = function(cb) {
+  var that = this;
+
+  this.pingDaemon(function(daemonAlive) {
+    if (daemonAlive === true)
+      return that.launchRPC(function(err, meta) {
+        return cb(null, {
+          daemon_mode      : that.conf.daemon_mode,
+          new_pm2_instance : false,
+          rpc_socket_file  : that.rpc_socket_file,
+          pub_socket_file  : that.pub_socket_file,
+          pm2_home         : that.pm2_home
+        });
+      });
+
+    /**
+     * No Daemon mode
+     */
+    if (that.daemon_mode === false) {
+      var Daemon         = require('./Daemon.js');
+
+      var daemon = new Daemon({
+        pub_socket_file : that.conf.DAEMON_PUB_PORT,
+        rpc_socket_file : that.conf.DAEMON_RPC_PORT,
+        pid_file        : that.conf.PM2_PID_FILE_PATH,
+        ignore_signals  : true
+      });
+
+      console.log('Launching in no daemon mode');
+
+      daemon.innerStart(function() {
+        KMDaemon.launchAndInteract(that.conf, {
+          machine_name : that.machine_name,
+          public_key   : that.public_key,
+          secret_key   : that.secret_key,
+          pm2_version  : pkg.version
+        }, function(err, data, interactor_proc) {
+          that.interactor_process = interactor_proc;
+        });
+
+        that.launchRPC(function(err, meta) {
+          return cb(null, {
+            daemon_mode      : that.conf.daemon_mode,
+            new_pm2_instance : true,
+            rpc_socket_file  : that.rpc_socket_file,
+            pub_socket_file  : that.pub_socket_file,
+            pm2_home         : that.pm2_home
+          });
+        });
+      });
+      return false;
+    }
+
+    /**
+     * Daemon mode
+     */
+    that.launchDaemon(function(err, child) {
+      if (err) {
+        Common.printError(err);
+        return cb ? cb(err) : process.exit(that.conf.ERROR_EXIT);
+      }
+
+      if (!(process.env.ZM2_DISCRETE_MODE || process.env.PM2_DISCRETE_MODE))
+        Common.printOut(that.conf.PREFIX_MSG + 'ZM2 Successfully daemonized');
+
+      that.launchRPC(function(err, meta) {
+        return cb(null, {
+          daemon_mode      : that.conf.daemon_mode,
+          new_pm2_instance : true,
+          rpc_socket_file  : that.rpc_socket_file,
+          pub_socket_file  : that.pub_socket_file,
+          pm2_home         : that.pm2_home
+        });
+      });
+    });
+  });
+};
+
+// Init file structure of zm2_home
+// This includes
+// - zm2 pid and log path
+// - rpc and pub socket for command execution
+Client.prototype.initFileStructure = function (opts) {
+  if (!fs.existsSync(opts.DEFAULT_LOG_PATH)) {
+    try {
+      require('mkdirp').sync(opts.DEFAULT_LOG_PATH);
+    } catch (e) {
+      console.error(e.stack || e);
+    }
+  }
+
+  if (!fs.existsSync(opts.DEFAULT_PID_PATH)) {
+    try {
+      require('mkdirp').sync(opts.DEFAULT_PID_PATH);
+    } catch (e) {
+      console.error(e.stack || e);
+    }
+  }
+
+  if (!fs.existsSync(opts.PM2_MODULE_CONF_FILE)) {
+    try {
+      fs.writeFileSync(opts.PM2_MODULE_CONF_FILE, "{}");
+    } catch (e) {
+      console.error(e.stack || e);
+    }
+  }
+
+  if (!fs.existsSync(opts.DEFAULT_MODULE_PATH)) {
+    try {
+      require('mkdirp').sync(opts.DEFAULT_MODULE_PATH);
+    } catch (e) {
+      console.error(e.stack || e);
+    }
+  }
+
+  if (process.env.ZM2_DISCRETE_MODE || process.env.PM2_DISCRETE_MODE) {
+    try {
+      fs.writeFileSync(path.join(opts.PM2_HOME, 'touch'), Date.now().toString());
+    } catch(e) {
+      debug(e.stack || e);
+    }
+  }
+
+  if (!(process.env.ZM2_PROGRAMMATIC || process.env.PM2_PROGRAMMATIC) && !fs.existsSync(path.join(opts.PM2_HOME, 'touch'))) {
+
+    var vCheck = require('./VersionCheck.js')
+
+    vCheck({
+      state: 'install',
+      version: pkg.version
+    })
+
+    var dt = fs.readFileSync(path.join(__dirname, opts.PM2_BANNER));
+    console.log(dt.toString());
+    try {
+      fs.writeFileSync(path.join(opts.PM2_HOME, 'touch'), Date.now().toString());
+    } catch(e) {
+      debug(e.stack || e);
+    }
+  }
+};
+
+Client.prototype.close = function(cb) {
+  var that = this;
+
+  forEach([
+    that.disconnectRPC.bind(that),
+    that.disconnectBus.bind(that)
+  ], function(fn, next) {
+    fn(next)
+  }, cb);
+};
+
+/**
+ * Launch the Daemon by forking this same file
+ * The method Client.remoteWrapper will be called
+ *
+ * @method launchDaemon
+ * @param {Object} opts
+ * @param {Object} [opts.interactor=true] allow to disable interaction on launch
+ */
+Client.prototype.launchDaemon = function(opts, cb) {
+  if (typeof(opts) == 'function') {
+    cb = opts;
+    opts = {
+      interactor : true
+    };
+  }
+
+  var that = this
+  var ClientJS = path.resolve(path.dirname(module.filename), 'Daemon.js');
+  var node_args = [];
+  var out, err;
+
+  // if (process.env.TRAVIS) {
+  //   // Redirect ZM2 internal err and out to STDERR STDOUT when running with Travis
+  //   out = 1;
+  //   err = 2;
+  // }
+  // else {
+  out = fs.openSync(that.conf.PM2_LOG_FILE_PATH, 'a'),
+  err = fs.openSync(that.conf.PM2_LOG_FILE_PATH, 'a');
+  //}
+
+  if (this.conf.LOW_MEMORY_ENVIRONMENT) {
+    var os = require('os');
+    node_args.push('--gc-global'); // Does full GC (smaller memory footprint)
+    node_args.push('--max-old-space-size=' + Math.floor(os.totalmem() / 1024 / 1024));
+  }
+
+  // Node.js tuning for better performance
+  //node_args.push('--expose-gc'); // Allows manual GC in the code
+
+  /**
+   * Add node [arguments] depending on ZM2_NODE_OPTIONS env variable
+   */
+  if (process.env.ZM2_NODE_OPTIONS || process.env.PM2_NODE_OPTIONS)
+    node_args = node_args.concat((process.env.ZM2_NODE_OPTIONS || process.env.PM2_NODE_OPTIONS).split(' '));
+  node_args.push(ClientJS);
+
+  if (!(process.env.ZM2_DISCRETE_MODE || process.env.PM2_DISCRETE_MODE))
+    Common.printOut(that.conf.PREFIX_MSG + 'Spawning ZM2 daemon with zm2_home=' + this.pm2_home);
+
+  var interpreter = process.execPath;
+
+  var child = require('child_process').spawn(interpreter, node_args, {
+    detached   : true,
+    cwd        : that.conf.cwd || process.cwd(),
+    windowsHide: true,
+    env        : Object.assign({
+      'SILENT'    : that.conf.DEBUG ? !that.conf.DEBUG : true,
+      'PM2_HOME'  : that.pm2_home
+    }, process.env),
+    stdio      : [null, out, err, 'ipc']
+  });
+
+  function onError(e) {
+    console.error(e.message || e);
+    return cb ? cb(e.message || e) : false;
+  }
+
+  child.once('error', onError);
+
+  if (this.conf.IS_BUN === false)
+    child.unref();
+
+  child.once('message', function(msg) {
+    debug('ZM2 daemon launched with return message: ', msg);
+    child.removeListener('error', onError);
+    child.disconnect();
+    if (opts && opts.interactor == false)
+      return cb(null, child);
+
+    if (process.env.ZM2_NO_INTERACTION == 'true' || process.env.PM2_NO_INTERACTION == 'true')
+      return cb(null, child);
+
+    /**
+     * Here the Keymetrics agent is launched automaticcaly if
+     * it has been already configured before (via zm2 link)
+     */
+    KMDaemon.launchAndInteract(that.conf, {
+      machine_name : that.machine_name,
+      public_key   : that.public_key,
+      secret_key   : that.secret_key,
+      pm2_version  : pkg.version
+    }, function(err, data, interactor_proc) {
+      that.interactor_process = interactor_proc;
+      return cb(null, child);
+    });
+  });
+};
+
+/**
+ * Ping the daemon to know if it alive or not
+ * @api public
+ * @method pingDaemon
+ * @param {} cb
+ * @return
+ */
+Client.prototype.pingDaemon = function pingDaemon(cb) {
+  var req    = axon.socket('req');
+  var client = new rpc.Client(req);
+  var that = this;
+
+  debug('[PING ZM2] Trying to connect to server');
+
+  client.sock.once('reconnect attempt', function() {
+    client.sock.close();
+    debug('Daemon not launched');
+    process.nextTick(function() {
+      return cb(false);
+    });
+  });
+
+  client.sock.once('error', function(e) {
+    if (e.code === 'EACCES') {
+      fs.stat(that.conf.DAEMON_RPC_PORT, function(e, stats) {
+        if (stats.uid === 0) {
+          console.error(that.conf.PREFIX_MSG_ERR + 'Permission denied, to give access to current user:');
+          console.log('$ sudo chown ' + process.env.USER + ':' + process.env.USER + ' ' + that.conf.DAEMON_RPC_PORT +  ' ' + that.conf.DAEMON_PUB_PORT);
+        }
+        else
+          console.error(that.conf.PREFIX_MSG_ERR + 'Permission denied, check permissions on ' + that.conf.DAEMON_RPC_PORT);
+
+        process.exit(1);
+      });
+    }
+    else
+      console.error(e.message || e);
+  });
+
+  client.sock.once('connect', function() {
+    client.sock.once('close', function() {
+      return cb(true);
+    });
+    client.sock.close();
+    debug('Daemon alive');
+  });
+
+  req.connect(this.rpc_socket_file);
+};
+
+/**
+ * Methods to interact with the Daemon via RPC
+ * This method wait to be connected to the Daemon
+ * Once he's connected it trigger the command parsing (on ./bin/zm2 file, at the end)
+ * @method launchRPC
+ * @params {function} [cb]
+ * @return
+ */
+Client.prototype.launchRPC = function launchRPC(cb) {
+  var self = this;
+  debug('Launching RPC client on socket file %s', this.rpc_socket_file);
+  var req      = axon.socket('req');
+  this.client  = new rpc.Client(req);
+
+  var connectHandler = function() {
+    self.client.sock.removeListener('error', errorHandler);
+    debug('RPC Connected to Daemon');
+    if (cb) {
+      setTimeout(function() {
+        cb(null);
+      }, 4);
+    }
+  };
+
+  var errorHandler = function(e) {
+    self.client.sock.removeListener('connect', connectHandler);
+    if (cb) {
+      return cb(e);
+    }
+  };
+
+  this.client.sock.once('connect', connectHandler);
+  this.client.sock.once('error', errorHandler);
+  this.client_sock = req.connect(this.rpc_socket_file);
+};
+
+/**
+ * Methods to close the RPC connection
+ * @callback cb
+ */
+Client.prototype.disconnectRPC = function disconnectRPC(cb) {
+  var that = this;
+  if (!cb) cb = noop;
+
+  if (!this.client_sock || !this.client_sock.close) {
+    this.client = null;
+    return process.nextTick(function() {
+      cb(new Error('SUB connection to ZM2 is not launched'));
+    });
+  }
+
+  if (this.client_sock.connected === false ||
+      this.client_sock.closing === true) {
+    this.client = null;
+    return process.nextTick(function() {
+      cb(new Error('RPC already being closed'));
+    });
+  }
+
+  try {
+    var timer;
+
+    that.client_sock.once('close', function() {
+      clearTimeout(timer);
+      that.client = null;
+      debug('ZM2 RPC cleanly closed');
+      return cb(null, { msg : 'RPC Successfully closed' });
+    });
+
+    timer = setTimeout(function() {
+      if (that.client_sock.destroy)
+        that.client_sock.destroy();
+      that.client = null;
+      return cb(null, { msg : 'RPC Successfully closed via timeout' });
+    }, 200);
+
+    that.client_sock.close();
+  } catch(e) {
+    debug('Error while disconnecting RPC ZM2', e.stack || e);
+    return cb(e);
+  }
+  return false;
+};
+
+Client.prototype.launchBus = function launchEventSystem(cb) {
+  var self = this;
+  this.sub = axon.socket('sub-emitter');
+  this.sub_sock = this.sub.connect(this.pub_socket_file);
+
+  this.sub_sock.once('connect', function() {
+    return cb(null, self.sub, self.sub_sock);
+  });
+};
+
+Client.prototype.disconnectBus = function disconnectBus(cb) {
+  if (!cb) cb = noop;
+
+  var that = this;
+
+  if (!this.sub_sock || !this.sub_sock.close) {
+    that.sub = null;
+    return process.nextTick(function() {
+      cb(null, { msg : 'bus was not connected'});
+    });
+  }
+
+  if (this.sub_sock.connected === false ||
+      this.sub_sock.closing === true) {
+    that.sub = null;
+    return process.nextTick(function() {
+      cb(new Error('SUB connection is already being closed'));
+    });
+  }
+
+  try {
+    var timer;
+
+    that.sub_sock.once('close', function() {
+      that.sub = null;
+      clearTimeout(timer);
+      debug('ZM2 PUB cleanly closed');
+      return cb();
+    });
+
+    timer = setTimeout(function() {
+      if (Client.sub_sock.destroy)
+        that.sub_sock.destroy();
+      return cb();
+    }, 200);
+
+    this.sub_sock.close();
+  } catch(e) {
+    return cb(e);
+  }
+};
+
+/**
+ * Description
+ * @method gestExposedMethods
+ * @param {} cb
+ * @return
+ */
+Client.prototype.getExposedMethods = function getExposedMethods(cb) {
+  this.client.methods(cb);
+};
+
+/**
+ * Description
+ * @method executeRemote
+ * @param {} method
+ * @param {} env
+ * @param {} fn
+ * @return
+ */
+Client.prototype.executeRemote = function executeRemote(method, app_conf, fn) {
+  var self = this;
+
+  // stop watch on stop | env is the process id
+  if (method.indexOf('stop') !== -1) {
+    this.stopWatch(method, app_conf);
+  }
+  // stop watching when process is deleted
+  else if (method.indexOf('delete') !== -1) {
+    this.stopWatch(method, app_conf);
+  }
+  // stop everything on kill
+  else if (method.indexOf('kill') !== -1) {
+    this.stopWatch('deleteAll', app_conf);
+  }
+  else if (method.indexOf('restartProcessId') !== -1 && process.argv.indexOf('--watch') > -1) {
+    delete app_conf.env.current_conf.watch;
+    this.toggleWatch(method, app_conf);
+  }
+
+  if (!this.client || !this.client.call) {
+    this.start(function(error) {
+      if (error) {
+        if (fn)
+          return fn(error);
+        console.error(error);
+        return process.exit(0);
+      }
+      if (self.client) {
+        return self.client.call(method, app_conf, fn);
+      }
+    });
+    return false;
+  }
+
+  debug('Calling daemon method zm2:%s on rpc socket:%s', method, this.rpc_socket_file);
+  return this.client.call(method, app_conf, fn);
+};
+
+Client.prototype.notifyGod = function(action_name, id, cb) {
+  this.executeRemote('notifyByProcessId', {
+    id : id,
+    action_name : action_name,
+    manually : true
+  }, function() {
+    debug('God notified');
+    return cb ? cb() : false;
+  });
+};
+
+Client.prototype.killDaemon = function killDaemon(fn) {
+  var timeout;
+  var that = this;
+
+  function quit() {
+    that.close(function() {
+      return fn ? fn(null, {success:true}) : false;
+    });
+  }
+
+  // under unix, we listen for signal (that is send by daemon to notify us that its shuting down)
+  if (process.platform !== 'win32' && process.platform !== 'win64') {
+    process.once('SIGQUIT', function() {
+      debug('Received SIGQUIT from zm2 daemon');
+      clearTimeout(timeout);
+      quit();
+    });
+  }
+  else {
+    // if under windows, try to ping the daemon to see if it still here
+    setTimeout(function() {
+      that.pingDaemon(function(alive) {
+        if (!alive) {
+          clearTimeout(timeout);
+          return quit();
+        }
+      });
+    }, 250)
+  }
+
+  timeout = setTimeout(function() {
+    quit();
+  }, 3000);
+
+  // Kill daemon
+  this.executeRemote('killMe', {pid : process.pid});
+};
+
+
+/**
+ * Description
+ * @method toggleWatch
+ * @param {String} zm2 method name
+ * @param {Object} application environment, should include id
+ * @param {Function} callback
+ */
+Client.prototype.toggleWatch = function toggleWatch(method, env, fn) {
+  debug('Calling toggleWatch');
+  this.client.call('toggleWatch', method, env, function() {
+    return fn ? fn() : false;
+  });
+};
+
+/**
+ * Description
+ * @method startWatch
+ * @param {String} zm2 method name
+ * @param {Object} application environment, should include id
+ * @param {Function} callback
+ */
+Client.prototype.startWatch = function restartWatch(method, env, fn) {
+  debug('Calling startWatch');
+  this.client.call('startWatch', method, env, function() {
+    return fn ? fn() : false;
+  });
+};
+
+/**
+ * Description
+ * @method stopWatch
+ * @param {String} zm2 method name
+ * @param {Object} application environment, should include id
+ * @param {Function} callback
+ */
+Client.prototype.stopWatch = function stopWatch(method, env, fn) {
+  debug('Calling stopWatch');
+  this.client.call('stopWatch', method, env, function() {
+    return fn ? fn() : false;
+  });
+};
+
+Client.prototype.getAllProcess = function(cb) {
+  var found_proc = [];
+
+  this.executeRemote('getMonitorData', {}, function(err, procs) {
+    if (err) {
+      Common.printError('Error retrieving process list: ' + err);
+      return cb(err);
+    }
+
+    return cb(null, procs);
+  });
+};
+
+Client.prototype.getAllProcessId = function(cb) {
+  var found_proc = [];
+
+  this.executeRemote('getMonitorData', {}, function(err, procs) {
+    if (err) {
+      Common.printError('Error retrieving process list: ' + err);
+      return cb(err);
+    }
+
+    return cb(null, procs.map(proc => proc.pm_id));
+  });
+};
+
+Client.prototype.getAllProcessIdWithoutModules = function(cb) {
+  var found_proc = [];
+
+  this.executeRemote('getMonitorData', {}, function(err, procs) {
+    if (err) {
+      Common.printError('Error retrieving process list: ' + err);
+      return cb(err);
+    }
+
+    var proc_ids = procs
+        .filter(proc => !proc.pm2_env.pmx_module)
+        .map(proc => proc.pm_id)
+
+    return cb(null, proc_ids);
+  });
+};
+
+Client.prototype.getProcessIdByName = function(name, force_all, cb) {
+  var found_proc   = [];
+  var full_details = {};
+
+  if (typeof(cb) === 'undefined') {
+    cb = force_all;
+    force_all = false;
+  }
+
+  if (typeof(name) == 'number')
+    name = name.toString();
+
+  this.executeRemote('getMonitorData', {}, function(err, list) {
+    if (err) {
+      Common.printError('Error retrieving process list: ' + err);
+      return cb(err);
+    }
+
+    list.forEach(function(proc) {
+      if (proc.pm2_env.name == name || proc.pm2_env.pm_exec_path == path.resolve(name)) {
+        found_proc.push(proc.pm_id);
+        full_details[proc.pm_id] = proc;
+      }
+    });
+
+    return cb(null, found_proc, full_details);
+  });
+};
+
+Client.prototype.getProcessIdsByNamespace = function(namespace, force_all, cb) {
+  var found_proc   = [];
+  var full_details = {};
+
+  if (typeof(cb) === 'undefined') {
+    cb = force_all;
+    force_all = false;
+  }
+
+  if (typeof(namespace) == 'number')
+    namespace = namespace.toString();
+
+  this.executeRemote('getMonitorData', {}, function(err, list) {
+    if (err) {
+      Common.printError('Error retrieving process list: ' + err);
+      return cb(err);
+    }
+
+    list.forEach(function(proc) {
+      if (proc.pm2_env.namespace == namespace) {
+        found_proc.push(proc.pm_id);
+        full_details[proc.pm_id] = proc;
+      }
+    });
+
+    return cb(null, found_proc, full_details);
+  });
+};
+
+Client.prototype.getProcessByName = function(name, cb) {
+  var found_proc = [];
+
+  this.executeRemote('getMonitorData', {}, function(err, list) {
+    if (err) {
+      Common.printError('Error retrieving process list: ' + err);
+      return cb(err);
+    }
+
+    list.forEach(function(proc) {
+      if (proc.pm2_env.name == name ||
+          proc.pm2_env.pm_exec_path == path.resolve(name)) {
+        found_proc.push(proc);
+      }
+    });
+
+    return cb(null, found_proc);
+  });
+};
+
+Client.prototype.getProcessByNameOrId = function (nameOrId, cb) {
+  var foundProc = [];
+
+  this.executeRemote('getMonitorData', {}, function (err, list) {
+    if (err) {
+      Common.printError('Error retrieving process list: ' + err);
+      return cb(err);
+    }
+
+    list.forEach(function (proc) {
+      if (proc.pm2_env.name === nameOrId ||
+        proc.pm2_env.pm_exec_path === path.resolve(nameOrId) ||
+        proc.pid === parseInt(nameOrId) ||
+        proc.pm2_env.pm_id === parseInt(nameOrId)) {
+        foundProc.push(proc);
+      }
+    });
+
+    return cb(null, foundProc);
+  });
+};