@zappinginc/zm2 6.0.14

package/lib/API/UX/helpers.js

@@ -0,0 +1,213 @@
+const chalk = require('ansis')
+const Helpers = {}
+
+/**
+ * Converts Byte to Human readable size
+ * @method bytesToSize
+ * @param {} bytes
+ * @param {} precision
+ * @return
+ */
+Helpers.bytesToSize = function(bytes, precision) {
+  var kilobyte = 1024
+  var megabyte = kilobyte * 1024
+  var gigabyte = megabyte * 1024
+  var terabyte = gigabyte * 1024
+
+  if ((bytes >= 0) && (bytes < kilobyte)) {
+    return bytes + 'b '
+  } else if ((bytes >= kilobyte) && (bytes < megabyte)) {
+    return (bytes / kilobyte).toFixed(precision) + 'kb '
+  } else if ((bytes >= megabyte) && (bytes < gigabyte)) {
+    return (bytes / megabyte).toFixed(precision) + 'mb '
+  } else if ((bytes >= gigabyte) && (bytes < terabyte)) {
+    return (bytes / gigabyte).toFixed(precision) + 'gb '
+  } else if (bytes >= terabyte) {
+    return (bytes / terabyte).toFixed(precision) + 'tb '
+  } else {
+    return bytes + 'b '
+  }
+}
+
+
+/**
+ * Color Process state
+ * @method colorStatus
+ * @param {} status
+ * @return
+ */
+Helpers.colorStatus = function(status) {
+  switch (status) {
+
+  case 'online':
+    return chalk.green.bold('online')
+    break
+  case 'running':
+    return chalk.green.bold('online')
+    break
+  case 'restarting':
+    return chalk.yellow.bold('restart')
+    break
+  case 'created':
+    return chalk.yellow.bold('created')
+    break
+  case 'launching':
+    return chalk.blue.bold('launching')
+    break
+  default:
+    return chalk.red.bold(status)
+  }
+}
+
+/**
+ * Safe Push
+ */
+Helpers.safe_push = function() {
+  var argv = arguments
+  var table = argv[0]
+
+  for (var i = 1; i < argv.length; ++i) {
+    var elem = argv[i]
+    if (elem[Object.keys(elem)[0]] === undefined
+        || elem[Object.keys(elem)[0]] === null) {
+      elem[Object.keys(elem)[0]] = 'N/A'
+    }
+    else if (Array.isArray(elem[Object.keys(elem)[0]])) {
+      elem[Object.keys(elem)[0]].forEach(function(curr, j) {
+        if (curr === undefined || curr === null)
+          elem[Object.keys(elem)[0]][j] = 'N/A'
+      })
+    }
+    table.push(elem)
+  }
+}
+
+/**
+ * Description
+ * @method timeSince
+ * @param {} date
+ * @return BinaryExpression
+ */
+Helpers.timeSince = function(date) {
+  var seconds = Math.floor((new Date() - date) / 1000)
+
+  var interval = Math.floor(seconds / 31536000)
+
+  if (interval > 1) {
+    return interval + 'Y'
+  }
+  interval = Math.floor(seconds / 2592000)
+  if (interval > 1) {
+    return interval + 'M'
+  }
+  interval = Math.floor(seconds / 86400)
+  if (interval > 1) {
+    return interval + 'D'
+  }
+  interval = Math.floor(seconds / 3600)
+  if (interval > 1) {
+    return interval + 'h'
+  }
+  interval = Math.floor(seconds / 60)
+  if (interval > 1) {
+    return interval + 'm'
+  }
+  return Math.floor(seconds) + 's'
+}
+
+/**
+ * Colorize Metrics
+ *
+ * @param {Number} value current value
+ * @param {Number} warn value threshold
+ * @param {Number} alert value threshold
+ * @param {String} prefix value prefix
+ * @return {String} value
+ */
+Helpers.colorizedMetric = function(value, warn, alert, prefix) {
+  var inverted = false
+  if (alert < warn)
+    inverted = true
+
+  if (!prefix) prefix = ''
+  if (isNaN(value) === true)
+    return 'N/A'
+  if (value == 0)
+    return 0 + prefix
+  if (inverted == true) {
+    if (value > warn)
+      return chalk.green(value + prefix)
+    if (value <= warn && value >= alert)
+      return chalk.bold.yellow(value + prefix)
+    return chalk.bold.red(value + prefix)
+  }
+  if (value < warn)
+    return chalk.green(value + prefix)
+  if (value >= warn && value <= alert)
+    return chalk.bold.yellow(value + prefix)
+  return chalk.bold.red(value + prefix)
+}
+
+/**
+ * Get nested property
+ *
+ * @param {String} propertyName
+ * @param {Object} obj
+ * @returns {String} property value
+ */
+Helpers.getNestedProperty = function(propertyName, obj) {
+  var parts = propertyName.split('.'),
+      length = parts.length,
+      property = obj || {}
+
+  for (var i = 0; i < length; i++ ) {
+    property = property[parts[i]]
+  }
+
+  return property
+}
+
+Helpers.openEditor = function (file, opts, cb) {
+  var spawn = require('child_process').spawn
+
+  if (typeof opts === 'function') {
+    cb = opts
+    opts = {}
+  }
+
+  if (!opts) opts = {}
+
+  var ed = /^win/.test(process.platform) ? 'notepad' : 'vim'
+  var editor = opts.editor || process.env.VISUAL || process.env.EDITOR || ed
+  var args = editor.split(/\s+/)
+  var bin = args.shift()
+
+  var ps = spawn(bin, args.concat([ file ]), {
+    windowsHide: true,
+    stdio: 'inherit'
+  })
+
+  ps.on('exit', function (code, sig) {
+    if (typeof cb === 'function') cb(code, sig)
+  })
+}
+
+
+Helpers.dispKeys = function(kv, target_module) {
+  Object.keys(kv).forEach(function(key) {
+
+    if (target_module != null && target_module != key)
+      return false
+
+    if (typeof(kv[key]) == 'object') {
+      var obj = {}
+
+      console.log(chalk.bold('Module: ') + chalk.bold.blue(key))
+      Object.keys(kv[key]).forEach(function(sub_key) {
+        console.log(`$ pm2 set ${key}:${sub_key} ${kv[key][sub_key]}`)
+      })
+    }
+  })
+}
+
+module.exports = Helpers

package/lib/API/UX/index.js

@@ -0,0 +1,9 @@
+
+const UX = {
+  helpers: require('./helpers.js'),
+  describe: require('./pm2-describe.js'),
+  list: require('./pm2-ls.js'),
+  list_min: require('./pm2-ls-minimal.js')
+}
+
+module.exports = UX

package/lib/API/UX/pm2-describe.js

@@ -0,0 +1,193 @@
+const Table = require('cli-tableau')
+const chalk = require('ansis')
+const UxHelpers = require('./helpers.js')
+const Common = require('../../Common.js')
+
+var postModuleInfos = function(module_name, human_info) {
+  var table = new Table({
+    style : {'padding-left' : 1, head : ['cyan', 'bold'], compact : true}
+  })
+
+  var disp = {}
+
+  human_info.unshift(['Module name', module_name])
+  human_info.forEach(function(info) {
+    var obj = {}
+    obj[chalk.bold.cyan(info[0])] = info[1]
+    table.push(obj)
+  })
+
+  console.log()
+  console.log(chalk.bold.inverse(' Module %s infos '), module_name)
+  console.log(table.toString())
+}
+
+/**
+ * Description
+ * @method describeTable
+ * @param {Object} proc process list
+ */
+module.exports = function(proc) {
+  var table = new Table({
+    style : {'padding-left' : 1, head : ['cyan', 'bold'], compact : true}
+  })
+
+  var pm2_env = proc.pm2_env
+
+  var created_at = 'N/A'
+
+  if (pm2_env.axm_options && pm2_env.axm_options.human_info) {
+    postModuleInfos(pm2_env.name, pm2_env.axm_options.human_info)
+  }
+
+  try {
+    if (pm2_env.created_at != null)
+      created_at = new Date(pm2_env.created_at).toISOString()
+  } catch (e) {
+  }
+
+  console.log(chalk.bold.inverse(' Describing process with id %d - name %s '), pm2_env.pm_id, pm2_env.name)
+  UxHelpers.safe_push(table,
+            { 'status' : UxHelpers.colorStatus(pm2_env.status) },
+            { 'name': pm2_env.name },
+            { 'namespace': pm2_env.namespace },
+            { 'version': pm2_env.version },
+            { 'restarts' : pm2_env.restart_time },
+            { 'uptime' : (pm2_env.pm_uptime && pm2_env.status == 'online') ? UxHelpers.timeSince(pm2_env.pm_uptime) : 0 },
+            { 'script path' : pm2_env.pm_exec_path },
+            { 'script args' : pm2_env.args ? (typeof pm2_env.args == 'string' ? JSON.parse(pm2_env.args.replace(/'/g, '"')):pm2_env.args).join(' ') : null },
+            { 'error log path' : pm2_env.pm_err_log_path },
+            { 'out log path' : pm2_env.pm_out_log_path },
+            { 'pid path' : pm2_env.pm_pid_path },
+
+            { 'interpreter' : pm2_env.exec_interpreter },
+            { 'interpreter args' : pm2_env.node_args.length != 0 ? pm2_env.node_args : null },
+
+            { 'script id' : pm2_env.pm_id },
+            { 'exec cwd' : pm2_env.pm_cwd },
+
+            { 'exec mode' : pm2_env.exec_mode },
+            { 'node.js version' : pm2_env.node_version },
+            { 'node env': pm2_env.env.NODE_ENV },
+            { 'watch & reload' : pm2_env.watch ? chalk.green.bold('✔') : '✘' },
+            { 'unstable restarts' : pm2_env.unstable_restarts },
+            { 'created at' : created_at }
+           )
+
+  if ('pm_log_path' in pm2_env){
+    table.splice(6, 0, {'entire log path': pm2_env.pm_log_path})
+  }
+
+  if ('cron_restart' in pm2_env){
+    table.splice(5, 0, {'cron restart': pm2_env.cron_restart})
+  }
+
+  console.log(table.toString())
+
+  /**
+   * Module conf display
+   */
+  if (pm2_env.axm_options &&
+      pm2_env.axm_options.module_conf &&
+      Object.keys(pm2_env.axm_options.module_conf).length > 0) {
+    var table_conf = new Table({
+      style : {'padding-left' : 1, head : ['cyan', 'bold'], compact : true}
+    })
+    console.log('Process configuration')
+
+    Object.keys(pm2_env.axm_options.module_conf).forEach(function(key) {
+      var tmp = {}
+      tmp[key] = pm2_env.axm_options.module_conf[key]
+      UxHelpers.safe_push(table_conf, tmp)
+    })
+
+    console.log(table_conf.toString())
+  }
+
+  /**
+   * Versioning metadata
+   */
+  if (pm2_env.versioning) {
+
+    var table2 = new Table({
+      style : {'padding-left' : 1, head : ['cyan', 'bold'], compact : true}
+    })
+
+    console.log(chalk.inverse.bold(' Revision control metadata '))
+    UxHelpers.safe_push(table2,
+              { 'revision control' : pm2_env.versioning.type },
+              { 'remote url' : pm2_env.versioning.url },
+              { 'repository root' : pm2_env.versioning.repo_path },
+              { 'last update' : pm2_env.versioning.update_time },
+              { 'revision' : pm2_env.versioning.revision },
+              { 'comment' :  pm2_env.versioning.comment ? pm2_env.versioning.comment.trim().slice(0, 60) : '' },
+              { 'branch' :  pm2_env.versioning.branch }
+             )
+    console.log(table2.toString())
+  }
+
+  if (pm2_env.axm_actions && Object.keys(pm2_env.axm_actions).length > 0) {
+    var table_actions = new Table({
+      style : {'padding-left' : 1, head : ['cyan', 'bold'], compact : true}
+    })
+
+    console.log(chalk.inverse.bold(' Actions available '))
+    pm2_env.axm_actions.forEach(function(action_set) {
+      UxHelpers.safe_push(table_actions, [action_set.action_name])
+    })
+
+    console.log(table_actions.toString())
+    Common.printOut(chalk.white.italic(' Trigger via: pm2 trigger %s <action_name>\n'), pm2_env.name)
+  }
+
+  if (pm2_env.axm_monitor && Object.keys(pm2_env.axm_monitor).length > 0) {
+    var table_probes = new Table({
+      style : {'padding-left' : 1, head : ['cyan', 'bold'], compact : true}
+    })
+
+    console.log(chalk.inverse.bold(' Code metrics value '))
+    Object.keys(pm2_env.axm_monitor).forEach(function(key) {
+      var obj = {}
+      var metric_name = pm2_env.axm_monitor[key].hasOwnProperty("value") ? pm2_env.axm_monitor[key].value : pm2_env.axm_monitor[key]
+      var metric_unit = pm2_env.axm_monitor[key].hasOwnProperty("unit") ? pm2_env.axm_monitor[key].unit : ''
+      var value = `${metric_name} ${metric_unit}`
+      obj[key] = value
+      UxHelpers.safe_push(table_probes, obj)
+    })
+
+    console.log(table_probes.toString())
+  }
+
+  var table_env = new Table({
+    style : {'padding-left' : 1, head : ['cyan', 'bold'], compact : true}
+  })
+
+  console.log(chalk.inverse.bold(' Divergent env variables from local env '))
+
+  var _env = Common.safeExtend({}, pm2_env)
+  var diff_env = {}
+
+  Object.keys(process.env).forEach(k => {
+    if (!_env[k] || _env[k] != process.env[k]) {
+      diff_env[k] = process.env[k]
+    }
+  })
+
+  Object.keys(diff_env).forEach(function(key) {
+    var obj = {}
+    if (_env[key]) {
+      // 1. fix env value is not a String and slice is undeinfed
+      // 2. fix process.stdout.columns is undefined and causes empty string output
+      // 3. columns defaults to 300 - same as specified in pm2-ls
+      obj[key] = String(_env[key]).slice(0, (process.stdout.columns || 300) - 60)
+      UxHelpers.safe_push(table_env, obj)
+    }
+  })
+
+  console.log(table_env.toString())
+  console.log()
+  Common.printOut(chalk.white.italic(' Add your own code metrics: http://bit.ly/code-metrics'))
+  Common.printOut(chalk.white.italic(' Use `pm2 logs %s [--lines 1000]` to display logs'), pm2_env.name)
+  Common.printOut(chalk.white.italic(' Use `pm2 env %s` to display environment variables'), pm2_env.pm_id)
+  Common.printOut(chalk.white.italic(' Use `pm2 monit` to monitor CPU and Memory usage'), pm2_env.name)
+}

package/lib/API/UX/pm2-ls-minimal.js

@@ -0,0 +1,31 @@
+
+const UxHelpers = require('./helpers.js')
+const p = require('path')
+
+/**
+ * Minimal display via pm2 ls -m
+ * @method miniDisplay
+ * @param {Object} list process list
+ */
+module.exports = function(list) {
+  list.forEach(function(l) {
+
+    var mode = l.pm2_env.exec_mode.split('_mode')[0]
+    var status = l.pm2_env.status
+    var key = l.pm2_env.name || p.basename(l.pm2_env.pm_exec_path.script)
+
+    console.log('+--- %s', key)
+    console.log('namespace : %s', l.pm2_env.namespace)
+    console.log('version : %s', l.pm2_env.version)
+    console.log('pid : %s', l.pid)
+    console.log('pm2 id : %s', l.pm2_env.pm_id)
+    console.log('status : %s', status)
+    console.log('mode : %s', mode)
+    console.log('restarted : %d', l.pm2_env.restart_time ? l.pm2_env.restart_time : 0)
+    console.log('uptime : %s', (l.pm2_env.pm_uptime && status == 'online') ? UxHelpers.timeSince(l.pm2_env.pm_uptime) : 0)
+    console.log('memory usage : %s', l.monit ? UxHelpers.bytesToSize(l.monit.memory, 1) : '')
+    console.log('error log : %s', l.pm2_env.pm_err_log_path)
+    console.log('watching : %s', l.pm2_env.watch ? 'yes' : 'no')
+    console.log('PID file : %s\n', l.pm2_env.pm_pid_path)
+  })
+}