@zappinginc/zm2 6.0.14

package/lib/templates/sample-apps/http-server/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "simple-http-server",
+  "version": "1.0.0",
+  "description": "Simple HTTP server that can be used in cluster mode",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC"
+}

package/lib/templates/sample-apps/pm2-plus-metrics-actions/README.md

@@ -0,0 +1,45 @@
+
+# pm2 custom metrics boilerplate
+
+In this boilerplate you will discover a working example of custom metrics feature.
+
+Metrics covered are:
+- io.metric
+- io.counter
+- io.meter
+- io.histogram
+
+## What is Custom Metrics?
+
+Custom metrics is a powerfull way to get more visibility from a running application. It will allow you to monitor in realtime the current value of variables, know the number of actions being processed, measure latency and much more.
+
+Once you have plugged in some custom metrics you will be able to monitor their value in realtime with
+
+`pm2 monit`
+
+Or
+
+`pm2 describe`
+
+Or on the PM2+ Web interface
+
+`pm2 open`
+
+## Example
+
+```javascript
+const io = require('@pm2/io')
+
+const currentReq = io.counter({
+  name: 'CM: Current Processing',
+  type: 'counter'
+})
+
+setInterval(() => {
+  currentReq.inc()
+}, 1000)
+```
+
+## Documentation
+
+https://doc.pm2.io/en/plus/guide/custom-metrics/

package/lib/templates/sample-apps/pm2-plus-metrics-actions/custom-metrics.js

@@ -0,0 +1,66 @@
+
+const io = require('@pm2/io')
+
+// Straight Metric
+var user_count = 10
+
+const users = io.metric({
+  name: 'CM: Realtime user',
+  value: () => {
+    return user_count
+  }
+})
+
+// or users.set(user_count)
+
+// Counter (.inc() .dec())
+const currentReq = io.counter({
+  name: 'CM: Current Processing',
+  type: 'counter'
+})
+
+setInterval(() => {
+  currentReq.inc()
+}, 1000)
+
+// Meter
+const reqsec = io.meter({
+  name: 'CM: req/sec'
+})
+
+setInterval(() => {
+  reqsec.mark()
+}, 100)
+
+
+// Histogram
+const latency = io.histogram({
+  name: 'CM: latency'
+});
+
+var latencyValue = 0;
+
+setInterval(() => {
+  latencyValue = Math.round(Math.random() * 100);
+  latency.update(latencyValue);
+}, 100)
+
+
+////////////////////
+// Custom Actions //
+////////////////////
+
+io.action('add user', (done) => {
+  user_count++
+  done({success:true})
+})
+
+io.action('remove user', (done) => {
+  user_count++
+  done({success:true})
+})
+
+io.action('with params', (arg, done) => {
+  console.log(arg)
+  done({success:arg})
+})

package/lib/templates/sample-apps/pm2-plus-metrics-actions/ecosystem.config.js

@@ -0,0 +1,12 @@
+module.exports = {
+  apps : [{
+    name: 'Custom Metrics',
+    script: 'custom-metrics.js',
+    env: {
+      NODE_ENV: 'development'
+    },
+    env_production: {
+      NODE_ENV: 'production'
+    }
+  }]
+};

package/lib/templates/sample-apps/pm2-plus-metrics-actions/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "pm2-plus-custom-metrics",
+  "version": "1.0.0",
+  "description": "Example that shows how to use pm2+ custom metrics",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC"
+}

package/lib/templates/sample-apps/python-app/README.md

@@ -0,0 +1,4 @@
+
+# Managing a Python Application
+
+On this boilerlate you will see how you can start a Python application with PM2.

package/lib/templates/sample-apps/python-app/echo.py

@@ -0,0 +1,7 @@
+#!/usr/bin/python
+import time
+
+while 1:
+    print("Start : %s" % time.ctime())
+    print("second line")
+    time.sleep(1)

package/lib/templates/sample-apps/python-app/ecosystem.config.js

@@ -0,0 +1,12 @@
+module.exports = {
+  apps : [{
+    name: 'API',
+    script: 'echo.py',
+    env: {
+      NODE_ENV: 'development'
+    },
+    env_production: {
+      NODE_ENV: 'production'
+    }
+  }]
+};

package/lib/templates/sample-apps/python-app/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "python-app",
+  "version": "1.0.0",
+  "description": "Example on how to manage a Python application with PM2",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC"
+}

package/lib/tools/Config.js

@@ -0,0 +1,248 @@
+/**
+ * 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 util    = require('util');
+
+/**
+ * Validator of configured file / commander options.
+ */
+var Config = module.exports = {
+  _errMsgs: {
+    'require': '"%s" is required',
+    'type'   : 'Expect "%s" to be a typeof %s, but now is %s',
+    'regex'  : 'Verify "%s" with regex failed, %s',
+    'max'    : 'The maximum of "%s" is %s, but now is %s',
+    'min'    : 'The minimum of "%s" is %s, but now is %s'
+  },
+  /**
+   * Schema definition.
+   * @returns {exports|*}
+   */
+  get schema(){
+    // Cache.
+    if (this._schema) {
+      return this._schema;
+    }
+    // Render aliases.
+    this._schema = require('../API/schema');
+    for (var k in this._schema) {
+      if (k.indexOf('\\') > 0) {
+        continue;
+      }
+      var aliases = [
+        k.split('_').map(function(n, i){
+          if (i != 0 && n && n.length > 1) {
+            return n[0].toUpperCase() + n.slice(1);
+          }
+          return n;
+        }).join('')
+      ];
+
+      if (this._schema[k].alias && Array.isArray(this._schema[k].alias)) {
+        // If multiple aliases, merge
+        this._schema[k].alias.forEach(function(alias) {
+          aliases.splice(0, 0, alias);
+        });
+      }
+      else if (this._schema[k].alias)
+        aliases.splice(0, 0, this._schema[k].alias);
+
+      this._schema[k].alias = aliases;
+    }
+    return this._schema;
+  }
+};
+
+/**
+ * Filter / Alias options
+ */
+Config.filterOptions = function(cmd) {
+  var conf = {};
+  var schema = this.schema;
+
+  for (var key in schema) {
+    var aliases = schema[key].alias;
+    aliases && aliases.forEach(function(alias){
+      if (typeof(cmd[alias]) !== 'undefined') {
+        conf[key] || (conf[key] = cmd[alias]);
+      }
+    });
+  }
+
+  return conf;
+};
+
+/**
+ * Verify JSON configurations.
+ * @param {Object} json
+ * @returns {{errors: Array, config: {}}}
+ */
+Config.validateJSON = function(json){
+  // clone config
+  var conf = Object.assign({}, json),
+      res = {};
+  this._errors = [];
+
+  var regexKeys = {}, defines = this.schema;
+
+  for (var sk in defines) {
+    // Pick up RegExp keys.
+    if (sk.indexOf('\\') >= 0) {
+      regexKeys[sk] = false;
+      continue;
+    }
+
+    var aliases = defines[sk].alias;
+
+    aliases && aliases.forEach(function(alias){
+      conf[sk] || (conf[sk] = json[alias]);
+    })
+
+    var val = conf[sk];
+    delete conf[sk];
+
+    // Validate key-value pairs.
+    if (val === undefined ||
+        val === null ||
+        ((val = this._valid(sk, val)) === null)) {
+
+      // If value is not defined
+      // Set default value (via schema.json)
+      if (typeof(defines[sk].default) !== 'undefined')
+        res[sk] = defines[sk].default;
+      continue;
+    }
+    //console.log(sk, val, val === null, val === undefined);
+    res[sk] = val;
+  }
+
+  // Validate RegExp values.
+  var hasRegexKey = false;
+  for (var k in regexKeys) {
+    hasRegexKey = true;
+    regexKeys[k] = new RegExp(k);
+  }
+  if (hasRegexKey) {
+    for (var k in conf) {
+      for (var rk in regexKeys) {
+        if (regexKeys[rk].test(k))
+          if (this._valid(k, conf[k], defines[rk])) {
+            res[k] = conf[k];
+            delete conf[k];
+          }
+      }
+    }
+  }
+
+  return {errors: this._errors, config: res};
+};
+
+/**
+ * Validate key-value pairs by specific schema
+ * @param {String} key
+ * @param {Mixed} value
+ * @param {Object} sch
+ * @returns {*}
+ * @private
+ */
+Config._valid = function(key, value, sch){
+  var sch = sch || this.schema[key],
+      scht = typeof sch.type == 'string' ? [sch.type] : sch.type;
+
+  // Required value.
+  var undef = typeof value == 'undefined';
+  if(this._error(sch.require && undef, 'require', key)){
+    return null;
+  }
+
+  // If undefined, make a break.
+  if (undef) {
+    return null;
+  }
+
+  // Wrap schema types.
+  scht = scht.map(function(t){
+    return '[object ' + t[0].toUpperCase() + t.slice(1) + ']'
+  });
+
+  // Typeof value.
+  var type = Object.prototype.toString.call(value), nt = '[object Number]';
+
+  // Auto parse Number
+  if (type != '[object Boolean]' && scht.indexOf(nt) >= 0 && !isNaN(value)) {
+    value = parseFloat(value);
+    type = nt;
+  }
+
+  // Verify types.
+  if (this._error(!~scht.indexOf(type), 'type', key, scht.join(' / '), type)) {
+    return null;
+  }
+
+  // Verify RegExp if exists.
+  if (this._error(type == '[object String]' && sch.regex && !(new RegExp(sch.regex)).test(value),
+      'regex', key, sch.desc || ('should match ' + sch.regex))) {
+    return null;
+  }
+
+  // Verify maximum / minimum of Number value.
+  if (type == '[object Number]') {
+    if (this._error(typeof sch.max != 'undefined' && value > sch.max, 'max', key, sch.max, value)) {
+      return null;
+    }
+    if (this._error(typeof sch.min != 'undefined' && value < sch.min, 'min', key, sch.min, value)) {
+      return null;
+    }
+  }
+
+  // If first type is Array, but current is String, try to split them.
+  if(scht.length > 1 && type != scht[0] && type == '[object String]'){
+    if(scht[0] == '[object Array]') {
+      value = value.split(/([\w\-]+\="[^"]*")|([\w\-]+\='[^']*')|"([^"]*)"|'([^']*)'|\s/)
+      // unfortunately, js does not support lookahead RegExp (/(?<!\\)\s+/) now (until next ver).
+      //value = value.split(/((?<![\w\-])([\w\-]+\="[^"]*")|(?<![\w\-])([\w\-]+\='[^']*')|"([^"]*)"|'([^']*)'|\s )/)
+        .filter(function(v){
+          return v && v.trim();
+        });
+    }
+  }
+
+  // Custom types: sbyte && stime.
+  if(sch.ext_type && type == '[object String]' && value.length >= 2) {
+    var seed = {
+      'sbyte': {
+        'G': 1024 * 1024 * 1024,
+        'M': 1024 * 1024,
+        'K': 1024
+      },
+      'stime': {
+        'h': 60 * 60 * 1000,
+        'm': 60 * 1000,
+        's': 1000
+      }
+    }[sch.ext_type];
+
+    if(seed){
+      value = parseFloat(value.slice(0, -1)) * (seed[value.slice(-1)]);
+    }
+  }
+  return value;
+};
+
+/**
+ * Wrap errors.
+ * @param {Boolean} possible A value indicates whether it is an error or not.
+ * @param {String} type
+ * @returns {*}
+ * @private
+ */
+Config._error = function(possible, type){
+  if (possible) {
+    var args = Array.prototype.slice.call(arguments);
+    args.splice(0, 2, this._errMsgs[type]);
+    this._errors && this._errors.push(util.format.apply(null, args));
+  }
+  return possible;
+}

package/lib/tools/IsAbsolute.js

@@ -0,0 +1,20 @@
+'use strict';
+
+function posix(path) {
+	return path.charAt(0) === '/';
+}
+
+function win32(path) {
+	// https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56
+	var splitDeviceRe = /^([a-zA-Z]:|[\\/]{2}[^\\/]+[\\/]+[^\\/]+)?([\\/])?([\s\S]*?)$/;
+	var result = splitDeviceRe.exec(path);
+	var device = result[1] || '';
+	var isUnc = Boolean(device && device.charAt(1) !== ':');
+
+	// UNC paths are always absolute
+	return Boolean(result[2] || isUnc);
+}
+
+module.exports = process.platform === 'win32' ? win32 : posix;
+module.exports.posix = posix;
+module.exports.win32 = win32;

package/lib/tools/copydirSync.js

@@ -0,0 +1,101 @@
+var fs = require('fs');
+var path = require('path');
+/*
+  options: {
+    utimes: false,  // Boolean | Object, keep utimes if true
+    mode: false,    // Boolean | Number, keep file mode if true
+    cover: true,    // Boolean, cover if file exists
+    filter: true,   // Boolean | Function, file filter
+  }
+*/
+function copydirSync(from, to, options) {
+  if (typeof options === 'function') {
+    options = {
+      filter: options
+    };
+  }
+  if(typeof options === 'undefined') options = {};
+  if(typeof options.cover === 'undefined') {
+    options.cover = true;
+  }
+  options.filter = typeof options.filter === 'function' ? options.filter : function(state, filepath, filename) {
+    return options.filter;
+  };
+  var stats = fs.lstatSync(from);
+  var statsname = stats.isDirectory() ? 'directory' :
+    stats.isFile() ? 'file' :
+      stats.isSymbolicLink() ? 'symbolicLink' :
+      '';
+  var valid = options.filter(statsname, from, path.dirname(from), path.basename(from));
+
+  if (statsname === 'directory' || statsname === 'symbolicLink') {
+    // Directory or SymbolicLink
+    if(valid) {
+      try {
+        fs.statSync(to);
+      } catch(err) {
+        if(err.code === 'ENOENT') {
+          fs.mkdirSync(to, { recursive: true });
+          options.debug && console.log('>> ' + to);
+        } else {
+          throw err;
+        }
+      }
+      rewriteSync(to, options, stats);
+      if (statsname != 'symbolicLink')
+        listDirectorySync(from, to, options);
+    }
+  } else if(stats.isFile()) {
+    // File
+    if(valid) {
+      if(options.cover) {
+        writeFileSync(from, to, options, stats);
+      } else {
+        try {
+          fs.statSync(to);
+        } catch(err) {
+          if(err.code === 'ENOENT') {
+            writeFileSync(from, to, options, stats);
+          } else {
+            throw err;
+          }
+        }
+      }
+    }
+  } else {
+    throw new Error('stats invalid: '+ from);
+  }
+};
+
+function listDirectorySync(from, to, options) {
+  var files = fs.readdirSync(from);
+  copyFromArraySync(files, from, to, options);
+}
+
+function copyFromArraySync(files, from, to, options) {
+  if(files.length === 0) return true;
+  var f = files.shift();
+  copydirSync(path.join(from, f), path.join(to, f), options);
+  copyFromArraySync(files, from, to, options);
+}
+
+function writeFileSync(from, to, options, stats) {
+  fs.writeFileSync(to, fs.readFileSync(from, 'binary'), 'binary');
+  options.debug && console.log('>> ' + to);
+  rewriteSync(to, options, stats);
+}
+
+function rewriteSync(f, options, stats, callback) {
+  if(options.cover) {
+    var mode = options.mode === true ? stats.mode : options.mode;
+    var utimes = options.utimes === true ? {
+      atime: stats.atime,
+      mtime: stats.mtime
+    } : options.utimes;
+    mode && fs.chmodSync(f, mode);
+    utimes && fs.utimesSync(f, utimes.atime, utimes.mtime);
+  }
+  return true;
+}
+
+module.exports = copydirSync;

package/lib/tools/deleteFolderRecursive.js

@@ -0,0 +1,19 @@
+
+const fs = require('fs');
+const Path = require('path');
+
+const deleteFolderRecursive = function(path) {
+  if (fs.existsSync(path)) {
+    fs.readdirSync(path).forEach((file, index) => {
+      const curPath = Path.join(path, file);
+      if (fs.lstatSync(curPath).isDirectory()) { // recurse
+        deleteFolderRecursive(curPath);
+      } else { // delete file
+        fs.unlinkSync(curPath);
+      }
+    });
+    fs.rmdirSync(path);
+  }
+};
+
+module.exports = deleteFolderRecursive

package/lib/tools/find-package-json.js

@@ -0,0 +1,74 @@
+'use strict';
+
+var path = require('path')
+  , fs = require('fs');
+
+/**
+ * Attempt to somewhat safely parse the JSON.
+ *
+ * @param {String} data JSON blob that needs to be parsed.
+ * @returns {Object|false} Parsed JSON or false.
+ * @api private
+ */
+function parse(data) {
+  data = data.toString('utf-8');
+
+  //
+  // Remove a possible UTF-8 BOM (byte order marker) as this can lead to parse
+  // values when passed in to the JSON.parse.
+  //
+  if (data.charCodeAt(0) === 0xFEFF) data = data.slice(1);
+
+  try { return JSON.parse(data); }
+  catch (e) { return false; }
+}
+
+/**
+ * Find package.json files.
+ *
+ * @param {String|Object} root The root directory we should start searching in.
+ * @returns {Object} Iterator interface.
+ * @api public
+ */
+module.exports = function find(root) {
+  root = root || process.cwd();
+  if (typeof root !== "string") {
+    if (typeof root === "object" && typeof root.filename === 'string') {
+      root = root.filename;
+    } else {
+      throw new Error("Must pass a filename string or a module object to finder");
+    }
+  }
+  return {
+    /**
+     * Return the parsed package.json that we find in a parent folder.
+     *
+     * @returns {Object} Value, filename and indication if the iteration is done.
+     * @api public
+     */
+    next: function next() {
+      if (root.match(/^(\w:\\|\/)$/)) return {
+        value: undefined,
+        filename: undefined,
+        done: true
+      };
+
+      var file = path.join(root, 'package.json')
+        , data;
+
+      root = path.resolve(root, '..');
+
+      if (fs.existsSync(file) && (data = parse(fs.readFileSync(file)))) {
+        data.__path = file;
+
+        return {
+          value: data,
+          filename: file,
+          done: false
+        };
+      }
+
+      return next();
+    }
+  };
+};