@zappinginc/zm2 6.0.14

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

@@ -0,0 +1,483 @@
+
+const cst = require('../../../constants')
+const Common = require('../../Common')
+const Configuration = require('../../Configuration')
+const UxHelpers = require('./helpers.js')
+const chalk = require('ansis')
+const Table = require('cli-tableau')
+const Passwd = require('../../tools/passwd.js')
+
+const List = {}
+
+const CONDENSED_MODE = (process.stdout.columns || 300) < 134
+
+/**
+ * Check if dump file contains same apps that the one managed by PM2
+ */
+function checkIfProcessAreDumped(list) {
+  try {
+    var dump_raw = require('fs').readFileSync(cst.DUMP_FILE_PATH)
+    var dump = JSON.parse(dump_raw)
+    var apps_dumped = dump.map(proc => proc.name)
+    var apps_running = list
+        .filter(proc => proc.pm2_env.pmx_module != true)
+        .map(proc => proc.name)
+    var diff = apps_dumped.filter(a => !apps_running.includes(a))
+    if (diff.length > 0) {
+      Common.warn(`Current process list is not synchronized with saved list. App ${chalk.bold(diff.join(' '))} differs. Type 'pm2 save' to synchronize.`)
+    }
+    else if (apps_dumped.length != apps_running.length) {
+      Common.warn(`Current process list is not synchronized with saved list. Type 'pm2 save' to synchronize.`)
+    }
+  } catch(e) {
+  }
+}
+
+var proc_id = 0
+
+/**
+ * List Applications and Modules managed by PM2
+ */
+function listModulesAndAppsManaged(list, commander) {
+  var name_col_size = 11
+
+  if (list && list.length > 0)
+    name_col_size = (list.reduce((p, c) => (p.name.length > c.name.length) ? p : c)).name.length + 5
+
+  var id_width = Math.max(
+    2 + (Math.max(...list.map((l) => String(l.pm2_env.pm_id || 0).length)) || 0),
+    4
+  );
+
+  var app_head = {
+    id: id_width,
+    name: name_col_size,
+    namespace: 13,
+    version: 9,
+    mode: 9,
+    pid: 10,
+    uptime: 8,
+    '↺': 6,
+    status: 11,
+    cpu: 10,
+    mem: 10,
+    user: 10,
+    watching: 10
+  }
+
+  var mod_head = {
+    id: id_width,
+    module: 30,
+    version: 15,
+    pid: 10,
+    status: 10,
+    '↺': 6,
+    cpu: 10,
+    mem: 10,
+    user: 10
+  }
+
+  if (CONDENSED_MODE) {
+    app_head = {
+      id: id_width,
+      name: 20,
+      mode: 10,
+      '↺': 6,
+      status: 11,
+      cpu: 10,
+      memory: 10
+    }
+
+    mod_head = {
+      id: id_width,
+      name: 20,
+      status: 10,
+      cpu: 10,
+      mem: 10
+    }
+  }
+
+  var app_table = new Table({
+    head : Object.keys(app_head),
+    colWidths: Object.keys(app_head).map(k => app_head[k]),
+    colAligns : ['left'],
+    style : {'padding-left' : 1, head : ['cyan', 'bold'], compact : true}
+  })
+
+  var module_table = new Table({
+    head : Object.keys(mod_head),
+    colWidths: Object.keys(mod_head).map(k => mod_head[k]),
+    colAligns : ['left'],
+    style : {'padding-left' : 1, head : ['cyan', 'bold'],  compact : true}
+  })
+
+  var sortField = 'name', sortOrder = 'asc', sort,
+      fields = {
+        name: 'pm2_env.name',
+        namespace: 'pm2_env.namespace',
+        pid: 'pid',
+        id: 'pm_id',
+        cpu: 'monit.cpu',
+        memory: 'monit.memory',
+        uptime: 'pm2_env.pm_uptime',
+        status: 'pm2_env.status'
+      }
+
+  if (commander && commander.sort) {
+    sort = commander.sort.split(':');
+
+    if(fields[sort[0].toLowerCase()]) {
+      sortField = sort[0].toLowerCase();
+      sortOrder = sort.length === 2 ? sort[1] : 'asc';
+    }
+  }
+
+  list.sort(function(a, b) {
+    var fieldA = UxHelpers.getNestedProperty(fields[sortField], a)
+    var fieldB = UxHelpers.getNestedProperty(fields[sortField], b)
+
+    if (sortOrder === 'desc') {
+      if (fieldA > fieldB)
+        return -1
+      if (fieldA < fieldB)
+        return 1
+    } else {
+      if (fieldA < fieldB)
+        return -1
+      if (fieldA > fieldB)
+        return 1
+    }
+    return 0
+  })
+
+  list.forEach(function(l) {
+    var obj = {}
+
+    if (l.pm2_env.pm_id > proc_id) {
+      proc_id = l.pm2_env.pm_id
+    }
+
+    var mode = l.pm2_env.exec_mode
+    var status = l.pm2_env.status
+    var key = l.pm2_env.pm_id
+    key = chalk.bold.cyan(key)
+
+    if (l.pm2_env.axm_options) {
+      var is_tracing_enabled = false
+
+      if (l.pm2_env.axm_options.tracing &&
+          typeof(l.pm2_env.axm_options.tracing) == 'boolean' &&
+          l.pm2_env.axm_options.tracing == true)
+        is_tracing_enabled = true
+
+      if (l.pm2_env.axm_options.tracing &&
+          l.pm2_env.axm_options.tracing.enabled &&
+          typeof(l.pm2_env.axm_options.tracing.enabled) == 'boolean' &&
+          l.pm2_env.axm_options.tracing.enabled == true)
+        is_tracing_enabled = true
+
+      if (is_tracing_enabled == true)
+        l.pm2_env.name = chalk.green('☵')  + ' ' + l.pm2_env.name
+
+      if (l.pm2_env._km_monitored)
+        l.pm2_env.name = chalk.bold.green('◉')  + ' ' + l.pm2_env.name
+    }
+
+    if (l.pm2_env.pmx_module == true) {
+      if (l.pm2_env.name == 'pm2-sysmonit') return
+      // pm2 ls for Modules
+      obj[key] = []
+
+      obj[key].push(l.name)
+
+      // Module version + PID
+      if (!CONDENSED_MODE) {
+        var pid = l.pm2_env.axm_options.pid ? l.pm2_env.axm_options.pid : l.pid
+        obj[key].push(l.pm2_env.version || 'N/A', pid)
+      }
+
+      // Status
+      obj[key].push(UxHelpers.colorStatus(status))
+
+      // Restart
+      if (!CONDENSED_MODE)
+        obj[key].push(l.pm2_env.restart_time ? l.pm2_env.restart_time : 0)
+
+      // CPU + Memory
+      obj[key].push(l.monit ? (l.monit.cpu + '%') : 'N/A', l.monit ? UxHelpers.bytesToSize(l.monit.memory, 1) : 'N/A' )
+
+      // User
+      if (!CONDENSED_MODE) {
+
+        if (l.pm2_env.uid && typeof(l.pm2_env.uid) == 'number') {
+          // Resolve user id to username
+          let users = Passwd.getUsers()
+          Object.keys(users).forEach(function(username) {
+            var user = users[username]
+            if (user.userId == l.pm2_env.uid) {
+              l.pm2_env.uid = user.username
+            }
+          })
+        }
+        obj[key].push(chalk.bold(l.pm2_env.uid || l.pm2_env.username))
+      }
+
+      UxHelpers.safe_push(module_table, obj)
+    }
+    else {
+      // pm2 ls for Applications
+      obj[key] = []
+
+      // PM2 ID
+      obj[key].push(l.pm2_env.name)
+
+      // Namespace
+      if (!CONDENSED_MODE)
+        obj[key].push(l.pm2_env.namespace)
+
+      // Version
+      if (!CONDENSED_MODE)
+        obj[key].push(l.pm2_env.version)
+
+      // Exec mode
+      obj[key].push(mode == 'fork_mode' ? chalk.inverse.bold('fork') : chalk.blue.bold('cluster'))
+
+      // PID
+      if (!CONDENSED_MODE)
+        obj[key].push(l.pid)
+
+      // Uptime
+      if (!CONDENSED_MODE)
+        obj[key].push((l.pm2_env.pm_uptime && status == 'online') ? UxHelpers.timeSince(l.pm2_env.pm_uptime) : 0)
+
+      // Restart
+      obj[key].push(l.pm2_env.restart_time ? l.pm2_env.restart_time : 0)
+
+      // Status
+      obj[key].push(UxHelpers.colorStatus(status))
+
+
+      // CPU
+      obj[key].push(l.monit ? l.monit.cpu + '%' : 'N/A')
+
+      // Memory
+      obj[key].push(l.monit ? UxHelpers.bytesToSize(l.monit.memory, 1) : 'N/A')
+
+      // User
+      if (!CONDENSED_MODE) {
+        if (l.pm2_env.uid && typeof(l.pm2_env.uid) == 'number') {
+          // Resolve user id to username
+          let users = Passwd.getUsers()
+          Object.keys(users).forEach(function(username) {
+            var user = users[username]
+            if (user.userId == l.pm2_env.uid) {
+              l.pm2_env.uid = user.username
+            }
+          })
+        }
+        obj[key].push(chalk.bold(l.pm2_env.uid || l.pm2_env.username))
+      }
+
+      // Watch status
+      if (!CONDENSED_MODE)
+        obj[key].push(l.pm2_env.watch ? chalk.green.bold('enabled') : chalk.gray('disabled'))
+
+      UxHelpers.safe_push(app_table, obj)
+    }
+
+  })
+
+  // Print Applications Managed
+  console.log(app_table.toString())
+
+  // Print Modules Managed
+  if (module_table.length > 0) {
+    console.log(chalk.bold(`Module${module_table.length > 1 ? 's' : ''}`))
+    console.log(module_table.toString())
+  }
+
+  proc_id++
+}
+
+// Container display
+function containersListing(sys_infos) {
+  var stacked_docker = (process.stdout.columns || 100) < 140
+
+  var docker_head = {
+    id: 4,
+    image: 50,
+    status: 10,
+    '↺': 6,
+    cpu: 10,
+    mem: 10,
+    'net I/O ⇵': 11,
+    'fs I/O ⇵': 11
+  }
+
+  if (stacked_docker) {
+    docker_head = {
+      id: 4,
+      image: 25,
+      status: 10,
+      cpu: 10,
+      mem: 10
+    }
+  }
+
+  var docker_table = new Table({
+    colWidths: Object.keys(docker_head).map(k => docker_head[k]),
+    head : Object.keys(docker_head),
+    colAligns : ['left'],
+    style : {'padding-left' : 1, head : ['cyan', 'bold'],  compact : true}
+  })
+
+  sys_infos.containers.forEach((c) => {
+    var cpu = c.stats.cpu_percent
+    var mem = c.stats.mem_percent == 0 ? '0' : c.stats.mem_percent
+    var id = chalk.bold.cyan(proc_id++)
+    var state = UxHelpers.colorStatus(c.state)
+
+    if (stacked_docker)
+      docker_table.push([id, c.image, state, `${cpu}%`, `${mem}mb`])
+    else {
+      docker_table.push([
+        id,
+        c.image,
+        state,
+        c.restartCount,
+        `${cpu == 0 ? '0' : cpu}%`,
+        `${mem}mb`,
+        `${c.stats.netIO.rx}/${isNaN(c.stats.netIO.tx) == true ? '0.0' : c.stats.netIO.tx}`,
+        `${c.stats.blockIO.r}/${c.stats.blockIO.w}`
+      ])
+    }
+  })
+
+  console.log(chalk.bold(`Container${sys_infos.containers.length > 1 ? 's' : ''}`))
+  console.log(docker_table.toString())
+}
+
+/**
+ * High resource processes
+ */
+function listHighResourcesProcesses(sys_infos) {
+  const CPU_MIN_SHOW = 60
+  const MEM_MIN_SHOW = 30
+
+  var sys_proc_head = ['id', 'cmd', 'pid', 'cpu', 'mem', 'uid']
+
+  var sys_proc_table = new Table({
+    colWidths: [4, CONDENSED_MODE ? 29 : 77, 10, 10, 10, 8],
+    head : sys_proc_head,
+    colAligns : ['left'],
+    style : {'padding-left' : 1, head : ['cyan', 'bold'],  compact : true}
+  })
+
+  sys_infos.processes.cpu_sorted = sys_infos.processes.cpu_sorted.filter((proc) => {
+    return proc.cpu > CPU_MIN_SHOW && proc.cmd.includes('node') === false &&
+      proc.cmd.includes('God Daemon') === false
+  })
+
+  sys_infos.processes.cpu_sorted.forEach(proc => {
+    var cpu = `${UxHelpers.colorizedMetric(proc.cpu, 40, 70, '%')}`
+    var mem = `${UxHelpers.colorizedMetric(proc.memory, 40, 70, '%')}`
+    var cmd = proc.cmd
+    sys_proc_table.push([chalk.bold.cyan(proc_id++), cmd, proc.pid, cpu, mem, proc.uid])
+  })
+
+  sys_infos.processes.mem_sorted = sys_infos.processes.mem_sorted.filter((proc) => {
+    return proc.memory > MEM_MIN_SHOW && proc.cmd.includes('node') == false
+  })
+
+  sys_infos.processes.mem_sorted.forEach((proc) => {
+    var cpu = `${UxHelpers.colorizedMetric(proc.cpu, 40, 70, '%')}`
+    var mem = `${UxHelpers.colorizedMetric(proc.memory, 40, 70, '%')}`
+    var cmd = proc.cmd
+    // if (proc.cmd.length > 50)
+    //   cmd = '…' + proc.cmd.slice(proc.cmd.length - 48, proc.cmd.length)
+    sys_proc_table.push([chalk.bold.cyan(proc_id++), cmd, proc.pid, cpu, mem, proc.uid])
+  })
+
+  if (sys_infos.processes.cpu_sorted.length >= 1 || sys_infos.processes.mem_sorted.length >= 1) {
+    console.log(chalk.bold('Intensive Processes'))
+    console.log(sys_proc_table.toString())
+  }
+}
+
+/**
+ * Sys info line
+ */
+function miniMonitBar(sys_infos) {
+  let sys_metrics = sys_infos.pm2_env.axm_monitor
+
+  let cpu = sys_metrics['CPU Usage']
+
+  if (typeof(cpu) == 'undefined') return
+
+  var sys_summary_line = `${chalk.bold.cyan('host metrics')} `
+  sys_summary_line += `| ${chalk.bold('cpu')}: ${UxHelpers.colorizedMetric(cpu.value, 40, 70, '%')}`
+
+  let temp = sys_metrics['CPU Temperature'].value
+  if (temp && temp != '-1') {
+    sys_summary_line += ` ${UxHelpers.colorizedMetric(temp, 50, 70, 'º')}`
+  }
+
+  let mem_total = sys_metrics['RAM Total'].value
+  let mem_available = sys_metrics['RAM Available'].value
+
+  if (mem_total) {
+    var perc_mem_usage = (((mem_available) / mem_total) * 100).toFixed(1)
+    sys_summary_line += ` | ${chalk.bold('mem free')}: ${UxHelpers.colorizedMetric(perc_mem_usage, 30, 10, '%')} `
+  }
+
+  let interfaces = Object.keys(sys_metrics).filter(m => m.includes('net') && m != 'net:default').map(i => i.split(':')[2]).filter((iface, i, self) => self.indexOf(iface) === i)
+
+  interfaces.forEach(iface => {
+    if (!sys_metrics[`net:rx_5:${iface}`]) return
+    sys_summary_line += `| ${chalk.bold(iface)}: `
+    sys_summary_line += `⇓ ${UxHelpers.colorizedMetric(sys_metrics[`net:rx_5:${iface}`].value, 10, 20, 'mb/s')} `
+    sys_summary_line += `⇑ ${UxHelpers.colorizedMetric(sys_metrics[`net:tx_5:${iface}`].value, 10, 20, 'mb/s')} `
+  })
+
+  if (CONDENSED_MODE == false) {
+    let read = sys_metrics['Disk Reads'].value
+    let write = sys_metrics['Disk Writes'].value
+
+    sys_summary_line += `| ${chalk.bold('disk')}: ⇓ ${UxHelpers.colorizedMetric(read, 10, 20, 'mb/s')}`
+    sys_summary_line += ` ⇑ ${UxHelpers.colorizedMetric(write, 10, 20, 'mb/s')} `
+
+    let disks = Object.keys(sys_metrics).filter(m => m.includes('fs:')).map(i => i.split(':')[2]).filter((iface, i, self) => self.indexOf(iface) === i)
+    var disk_nb = 0
+
+    disks.forEach(fs => {
+      let use = sys_metrics[`fs:use:${fs}`].value
+      if (use > 60)
+        sys_summary_line += `${chalk.gray(fs)} ${UxHelpers.colorizedMetric(use, 80, 90, '%')} `
+    })
+  }
+
+  sys_summary_line += '|'
+  console.log(sys_summary_line)
+}
+
+/**
+ * pm2 ls
+ * @method dispAsTable
+ * @param {Object} list
+ * @param {Object} system informations (via pm2 sysmonit/pm2 sysinfos)
+ */
+module.exports = function(list, commander) {
+  var pm2_conf = Configuration.getSync('pm2')
+
+  if (!list)
+    return console.log('list empty')
+
+  listModulesAndAppsManaged(list, commander)
+
+  let sysmonit = list.filter(proc => proc.name == 'pm2-sysmonit')
+  if (sysmonit && sysmonit[0])
+    miniMonitBar(sysmonit[0])
+
+  // Disable warning message of process list not saved
+  //checkIfProcessAreDumped(list)
+}