testrawrfsdjhsrawr1 0.1.91

package/server/node_modules/node-os-utils/lib/mem.js

@@ -0,0 +1,176 @@
+/**
+ * @Author: 王澍（SunilWang）
+ * @Date: 2017-7-9 21:49:00
+ * @Last Modified by: 王澍（SunilWang）
+ * @Last Modified time: 2020-09-10 14:59:41
+ * @Description:
+ */
+var bucket = require('./bucket')
+var os = require('os')
+var fs = require('fs')
+var co = require('../util/co')
+var util = require('../util')
+var exec = require('./exec')
+
+var linuxFreeMemory = function () {
+  return new Promise(function (resolve) {
+    // https://github.com/SunilWang/node-os-utils/pull/11
+    // running this on an embedded linux device. This steps takes around 500ms. With this change we brought it down to a few milliseconds.
+    fs.readFile('/proc/meminfo', 'utf8', function (err, out) {
+      if (err) {
+        return resolve(bucket.options.NOT_SUPPORTED_VALUE)
+      }
+      var memInfo = {}
+      var usage = out.toString().trim().split('\n')
+      usage.forEach((line) => {
+        var pair = line.split(':')
+        memInfo[pair[0]] = parseInt(pair[1], 10)
+      })
+
+      var totalMem = parseInt(memInfo.MemTotal, 10) * 1024
+
+      // check if MemAvailable exists
+      if (!memInfo.MemAvailable) {
+        memInfo.MemAvailable = memInfo['MemFree'] + memInfo['Buffers'] + memInfo['Cached'] + memInfo['SReclaimable'] - memInfo['Shmem'];
+      }
+      var freeMem = memInfo.MemAvailable * 1024
+
+      // https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=34e431b0ae398fc54ea69ff85ec700722c9da773
+      // https://www.cnblogs.com/johnnyzen/p/8011309.html
+      if (os.release() < '3.14') {
+        freeMem =
+          ((memInfo.MemFree || 0) +
+            (memInfo.Buffers || 0) +
+            (memInfo.Cached || 0)) *
+          1024
+      }
+
+      return resolve({ totalMem, freeMem })
+    })
+  })
+}
+
+// learn from: https://github.com/X-Profiler/xtransit/blob/master/orders/system_log.js#L356
+var osxFreeMemory = co.wrap(function* () {
+  var totalMem = os.totalmem()
+  var mappings = {
+    'Pages purgeable': 'purgeable',
+    'Pages wired down': 'wired',
+    'Pages active': 'active',
+    'Pages inactive': 'inactive',
+    'Pages occupied by compressor': 'compressed',
+  }
+  var [vmStat, pagePageable] = yield Promise.all([
+    exec('vm_stat'),
+    exec('sysctl vm.page_pageable_internal_count'),
+  ])
+
+  vmStat = vmStat.toString().trim()
+  pagePageable = pagePageable.toString().trim()
+
+  // get page size
+  var pageSize = 4096
+  var matchdPageSize = /page size of (\d+) bytes/.exec(vmStat)
+
+  if (matchdPageSize && util.isNumber(matchdPageSize[1])) {
+    pageSize = Number(matchdPageSize[1])
+  }
+
+  // get page pageable
+  var [, pageableValue] = pagePageable.split(':')
+
+  if (!util.isNumber(pageableValue)) {
+    return {
+      totalMem,
+      freeMem: os.freemem(),
+    }
+  }
+
+  pageableValue = Number(pageableValue) * pageSize
+
+  // get vm stats
+  var lines = vmStat.split('\n').filter((x) => x !== '')
+  var stats = {}
+
+  lines.forEach((x) => {
+    var parts = x.split(':')
+    var key = parts[0]
+    var val = parts[1].replace('.', '').trim()
+
+    if (mappings[key]) {
+      var ky = mappings[key]
+      stats[ky] = val * pageSize
+    }
+  })
+
+  // get app memory
+  var appMemory = pageableValue - stats.purgeable
+  // get wired memory
+  var wiredMemory = stats.wired
+  // get compressed memory
+  var compressedMemory = stats.compressed
+  var used = appMemory + wiredMemory + compressedMemory
+
+  return {
+    totalMem,
+    freeMem: totalMem - used,
+  }
+})
+
+bucket.mem = {
+  info: co.wrap(function* () {
+    var totalMem = null
+    var freeMem = null
+    var memInfo = yield linuxFreeMemory()
+
+    if (bucket.isNotSupported(memInfo)) {
+      totalMem = os.totalmem()
+      freeMem = os.freemem()
+      if (os.platform() === 'darwin') {
+        var mem = yield osxFreeMemory()
+        totalMem = mem.totalMem
+        freeMem = mem.freeMem
+      }
+    } else {
+      totalMem = memInfo.totalMem
+      freeMem = memInfo.freeMem
+    }
+
+    var totalMemMb = parseFloat((totalMem / 1024 / 1024).toFixed(2))
+    var usedMemMb = parseFloat(((totalMem - freeMem) / 1024 / 1024).toFixed(2))
+    var freeMemMb = parseFloat((totalMemMb - usedMemMb).toFixed(2))
+    var usedMemPercentage = parseFloat((100 * ((totalMem - freeMem) / totalMem)).toFixed(2))
+    var freeMemPercentage = parseFloat((100 * (freeMem / totalMem)).toFixed(2))
+
+    return {
+      totalMemMb: totalMemMb,
+      usedMemMb: usedMemMb,
+      freeMemMb: freeMemMb,
+      usedMemPercentage: usedMemPercentage,
+      freeMemPercentage: freeMemPercentage,
+    }
+  }),
+  free: function () {
+    var self = this
+
+    return self.info().then(function (res) {
+      return Promise.resolve({
+        totalMemMb: res.totalMemMb,
+        freeMemMb: res.freeMemMb,
+      })
+    })
+  },
+  used: function () {
+    var self = this
+
+    return self.info().then(function (res) {
+      return Promise.resolve({
+        totalMemMb: res.totalMemMb,
+        usedMemMb: res.usedMemMb,
+      })
+    })
+  },
+  totalMem: function () {
+    return os.totalmem()
+  },
+}

package/server/node_modules/node-os-utils/lib/netstat.js

@@ -0,0 +1,182 @@
+/**
+ * author       : Sunil Wang
+ * createTime   : 2017/7/9 22:16
+ * description  :
+ */
+var bucket = require('./bucket')
+var co = require('../util/co')
+var exec = require('./exec')
+
+var ifconfig = {
+  breakIntoBlocks: function breakIntoBlocks (fullText) {
+    var blocks = []
+    var lines = fullText.split('\n')
+    var currentBlock = []
+    lines.forEach(function (line) {
+      if (line.length > 0 && ['\t', ' '].indexOf(line[0]) === -1 && currentBlock.length > 0) {
+        // start of a new block detected
+        blocks.push(currentBlock)
+        currentBlock = []
+      }
+      if (line.trim()) {
+        currentBlock.push(line)
+      }
+    })
+    if (currentBlock.length > 0) {
+      blocks.push(currentBlock)
+    }
+    return blocks
+  },
+
+  parseSingleBlock: function parseSingleBlock (block) {
+    var data = {}
+    block.forEach(function (line, i) {
+      var match = line.match(/^(\S+)\s+Link/)
+      if (i === 0) {
+        var match2 = line.match(/([a-zA-Z0-9]+):\s/)
+        if (match === null && match2) {
+          match = match2
+        }
+      }
+      if (match) { // eth0      Link encap:Ethernet  HWaddr 04:01:d3:db:fd:01
+        data.device = match[1] // eth0
+        var link = {}
+        match = line.match(/encap:(\S+)/)
+        if (match) {
+          link.encap = match[1]
+        }
+        match = line.match(/HWaddr\s+(\S+)/)
+        if (match) {
+          link.hwaddr = match[1]
+        }
+        data.link = link
+      } else {
+        var section = data.other || {}
+        if ((match = line.match(/collisions:(\S+)/))) {
+          section.collisions = parseInt(match[1])
+        }
+        if ((match = line.match(/txqueuelen:(\S+)/))) {
+          section.txqueuelen = parseInt(match[1])
+        }
+        if ((match = line.match(/RX bytes:(\S+)/))) {
+          section.rxBytes = parseInt(match[1])
+        }
+        if ((match = line.match(/RX packets (\S+) {2}bytes (\S+)/))) {
+          section.rxBytes = parseInt(match[2])
+        }
+        if ((match = line.match(/TX bytes:(\S+)/))) {
+          section.txBytes = parseInt(match[1])
+        }
+        if ((match = line.match(/TX packets (\S+) {2}bytes (\S+)/))) {
+          section.txBytes = parseInt(match[2])
+        }
+        data.other = section
+      }
+    })
+    return data
+  }
+}
+
+function ifconfigStats () {
+  return co(function * () {
+    var res = yield exec('ifconfig')
+
+    if(bucket.isNotSupported(res)) return res
+
+    var blocks = ifconfig.breakIntoBlocks(res)
+    var stats = []
+
+    blocks.forEach(function (block, index) {
+      blocks[index] = ifconfig.parseSingleBlock(block)
+      stats[index] = {
+        'interface': blocks[index].device,
+        'inputBytes': (blocks[index].other && blocks[index].other.rxBytes) || 0,
+        'outputBytes': (blocks[index].other && blocks[index].other.txBytes) || 0
+      }
+    })
+
+    return stats
+  })
+}
+
+bucket.netstat = {
+  stats: co.wrap(function * () {
+    var out = yield exec('ip -s link')
+
+    if(bucket.isNotSupported(out)) return ifconfigStats()
+
+    var names = new RegExp(/[0-9]+: ([\S]+): /g)
+    var RX = new RegExp(/ {4}RX: bytes {2}packets {2}errors {2}dropped overrun mcast\s*\n\s*([0-9]+) /gm)
+    var TX = new RegExp(/ {4}TX: bytes {2}packets {2}errors {2}dropped carrier collsns\s*\n\s*([0-9]+) /g)
+
+    var stats = []
+    var i = 0
+    var res = []
+
+    while ((res = names.exec(out)) !== null) {
+      stats[i++] = {
+        interface: res[1]
+      }
+    }
+
+    i = 0
+    while ((res = RX.exec(out)) !== null) {
+      stats[i++].inputBytes = res[1]
+    }
+
+    i = 0
+    while ((res = TX.exec(out)) !== null) {
+      stats[i++].outputBytes = res[1]
+    }
+
+    return stats
+  }),
+  inOut: function (interval) {
+    var self = this
+
+    if (!interval) {
+      interval = bucket.options.INTERVAL
+    }
+
+    return Promise.all([
+      self.stats(),
+      (function () {
+        return new Promise(function (resolve) {
+          setTimeout(function () {
+            self.stats().then(resolve)
+          }, interval)
+        })
+      })()
+    ]).then(function (stats) {
+      var oldStats = stats[0]
+      var newStats = stats[1]
+
+      var metrics = {
+        total: {
+          inputMb: 0,
+          outputMb: 0
+        }
+      }
+      var nbProblems = 0
+
+      for (var i = 0; i < oldStats.length; i++) {
+        if (oldStats[i].interface !== 'lo' && oldStats[i].interface !== 'lo0' && oldStats[i].inputBytes > 0 && oldStats[i].outputBytes > 0) {
+          metrics[oldStats[i].interface] = {}
+          metrics[oldStats[i].interface]['inputMb'] = parseFloat(((newStats[i].inputBytes - oldStats[i].inputBytes) / interval * 1000 / 1000000).toFixed(2))
+          metrics[oldStats[i].interface]['outputMb'] = parseFloat(((newStats[i].outputBytes - oldStats[i].outputBytes) / interval * 1000 / 1000000).toFixed(2))
+
+          metrics.total['inputMb'] += parseFloat(metrics[oldStats[i].interface]['inputMb'])
+          metrics.total['outputMb'] += parseFloat(metrics[oldStats[i].interface]['outputMb'])
+        } else {
+          nbProblems++
+        }
+      }
+
+      if (nbProblems === oldStats.length) {
+        return Promise.resolve(bucket.options.NOT_SUPPORTED_VALUE)
+      }
+
+      return Promise.resolve(metrics)
+    })
+  }
+}

package/server/node_modules/node-os-utils/lib/openfiles.js

@@ -0,0 +1,25 @@
+/**
+ * author       : Sunil Wang
+ * createTime   : 2017/7/10 10:26
+ * description  :
+ */
+var bucket = require('./bucket')
+var fs = require('fs')
+
+bucket.openfiles = {
+  openFd: function () {
+    return new Promise(function (resolve) {
+      fs.readFile('/proc/sys/fs/file-nr', function (err, out) {
+        if (err) {
+          return resolve(bucket.options.NOT_SUPPORTED_VALUE)
+        }
+
+        var result = out.toString().replace(/\n/g, '').split(' ')[0]
+
+        result = parseInt(result, 10)
+
+        return resolve(result)
+      })
+    })
+  }
+}

package/server/node_modules/node-os-utils/lib/os.js

@@ -0,0 +1,148 @@
+/**
+ * author       : Sunil Wang
+ * createTime   : 2017/7/10 10:36
+ * description  :
+ */
+var bucket = require('./bucket')
+var fs = require('fs')
+var os = require('os')
+var co = require('../util/co')
+var exec = require('./exec')
+
+var originalOperatingSystem = {
+  checkLastResort: co.wrap(function * (){
+    return exec('uname -sr')
+  }),
+  darwin: function () {
+    var self = this
+
+    return co(function * (){
+      var res = yield exec('sw_vers')
+
+      if(bucket.isNotSupported(res)) return self.checkLastResort()
+
+      var version = res.match(/[\n\r].*ProductVersion:\s*([^\n\r]*)/)[1]
+      var distribution = res.match(/.*ProductName:\s*([^\n\r]*)/)[1]
+
+      return distribution + ' ' + version
+    })
+  },
+  linux: function () {
+    var self = this
+
+    // Debian, Ubuntu, CentOS
+    return new Promise(function (resolve) {
+      fs.readFile('/etc/issue', function (err, out) {
+        if (err) {
+          return self.checkLastResort(resolve)
+        }
+        out = out.toString()
+        var version = out.match(/[\d]+(\.[\d][\d]?)?/)
+
+        if (version !== null) {
+          version = version[0]
+        }
+        var distribution = out.match(/[\w]*/)[0]
+
+        if (version !== null && distribution !== null) {
+          var resultOs = distribution + ' ' + version
+          return resolve(resultOs)
+        } else if (distribution !== null && distribution !== '') {
+          return resolve(distribution)
+        } else if (version === null) {
+          fs.readFile('/etc/redhat-release', function (err, out) {
+            if (err) {
+              return self.checkLastResort(resolve)
+            }
+
+            out = out.toString()
+            version = out.match(/[\d]+(\.[\d][\d]?)?/)
+
+            if (version !== null) {
+              version = version[0]
+            }
+
+            var resultOs = 'Red Hat ' + version
+            return resolve(resultOs)
+          })
+        }
+      })
+    })
+  }
+}
+
+bucket.os = {
+  oos: function () {
+    var platform = os.platform()
+
+    if (platform === 'linux') {
+      return originalOperatingSystem.linux()
+    }
+
+    if (platform === 'darwin') {
+      return originalOperatingSystem.darwin()
+    }
+
+    return originalOperatingSystem.checkLastResort()
+  },
+  platform: function () {
+    return os.platform()
+  },
+  uptime: function () {
+    // seconds
+    return os.uptime()
+  },
+  ip: function () {
+    var platform = os.platform()
+    var interfaces = os.networkInterfaces()
+    var ip = ''
+    var i = 0
+    try {
+
+      if (platform === 'linux' && interfaces.eth0) {
+        for (i = 0; i < interfaces.eth0.length; i++) {
+          if (os.networkInterfaces().eth0[i].family === 'IPv4') {
+            ip = os.networkInterfaces().eth0[i].address
+            break
+          }
+        }
+
+        return ip
+      }
+
+      if (platform === 'darwin') {
+        for (i = 0; i < interfaces.en0.length; i++) {
+          if (os.networkInterfaces().en0[i].family === 'IPv4') {
+            ip = os.networkInterfaces().en0[i].address
+            break
+          }
+        }
+
+        return ip
+      }
+
+      for (i in interfaces) {
+        var item = interfaces[i]
+        for (var j in item) {
+          if (item[j]['internal'] === false && item[j]['family'] === 'IPv4') {
+            ip = item[j]['address']
+            break
+          }
+        }
+      }
+    } catch (error){
+      ip = 'LOCALHOST'
+    }
+
+    return ip
+  },
+  hostname: function () {
+    return os.hostname()
+  },
+  type: function () {
+    return os.type()
+  },
+  arch: function () {
+    return os.arch()
+  }
+}

package/server/node_modules/node-os-utils/lib/osCmd.js

@@ -0,0 +1,20 @@
+/**
+ * author       : Sunil Wang
+ * createTime   : 2017/7/9 19:08
+ * description  :
+ */
+var bucket = require('./bucket')
+var exec = require('./exec')
+var wrapExec = exec.wrapExec
+
+bucket.osCmd = {
+  topCpu: wrapExec('ps -eo pcpu,user,args --no-headers | sort -k 1 -n | tail -n 10 | sort -k 1 -nr | cut -c 1-70'),
+  topMem: wrapExec('ps -eo pmem,pid,cmd | sort -k 1 -n | tail -n 10 | sort -k 1 -nr | cut -c 1-70'),
+  vmstats: wrapExec('vmstat -S m'),
+  processesUsers: wrapExec('ps hax -o user | sort | uniq -c'),
+  diskUsage: wrapExec('df -h'),
+  who: wrapExec('who'),
+  whoami: wrapExec('whoami'),
+  openPorts: wrapExec('lsof -Pni4 | grep ESTABLISHED'),
+  ifconfig: wrapExec('ifconfig')
+}

package/server/node_modules/node-os-utils/lib/proc.js

@@ -0,0 +1,38 @@
+/**
+ * author       : Sunil Wang
+ * createTime   : 2017/7/10 14:31
+ * description  :
+ */
+var bucket = require('./bucket')
+var exec = require('./exec')
+var os = require('os')
+var co = require('../util/co')
+
+bucket.proc = {
+  totalProcesses: co.wrap(function * () {
+    var res = yield exec("top -bn1 | awk 'NR > 7 && $8 ~ /R|S|D|T/ { print $12 }'")
+
+    if(bucket.isNotSupported(res)){
+      if (os.platform() === 'darwin') {
+        var nb = yield exec('ps -A')
+
+        nb = nb.toString().split('\n')
+
+        return nb.length - 1
+      }
+
+      return res
+    }
+
+    var resultProc = (res.split('\n')).length
+
+    return resultProc
+  }),
+  zombieProcesses: co.wrap(function * () {
+    var res = yield exec("top -bn1 | awk 'NR > 7 && $8 ~ /Z/ { print $12 }'")
+
+    if(bucket.isNotSupported(res)) return res
+
+    return (res.split('\n')).length
+  })
+}

package/server/node_modules/node-os-utils/lib/users.js

@@ -0,0 +1,18 @@
+/**
+ * author       : Sunil Wang
+ * createTime   : 2017/7/10 10:17
+ * description  :
+ */
+var bucket = require('./bucket')
+var exec = require('./exec')
+var co = require('../util/co')
+
+bucket.users = {
+  openedCount: co.wrap(function * () {
+    var res = yield exec('who | grep -v localhost | wc -l')
+
+    if(bucket.isNotSupported(res)) return res
+
+    return parseInt(res, 10)
+  })
+}

package/server/node_modules/node-os-utils/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "node-os-utils",
+  "version": "1.3.5",
+  "description": "An operating system utility library.",
+  "main": "index.js",
+  "scripts": {
+    "test": "node_modules/.bin/mocha test/test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SunilWang/node-os-utils.git"
+  },
+  "author": {
+    "name": "SunilWang",
+    "email": "ahwangshu@qq.com"
+  },
+  "keywords": [
+    "os",
+    "operating system",
+    "server",
+    "netstat",
+    "memory",
+    "cpu",
+    "monitor",
+    "stats",
+    "processes",
+    "openfiles",
+    "harddrive"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/SunilWang/node-os-utils/issues"
+  },
+  "homepage": "https://github.com/SunilWang/node-os-utils#readme",
+  "devDependencies": {
+    "mocha": "^6.2.3"
+  },
+  "dependencies": {}
+}

package/server/node_modules/node-os-utils/test/test.js

@@ -0,0 +1,55 @@
+/* eslint-disable no-undef */
+/**
+ * author       : Sunil Wang
+ * createTime   : 2017/7/10 14:51
+ * description  :
+ */
+
+var osu = require('../')
+var assert = require('assert')
+
+describe('cpu', function () {
+  it('returns cpu average and count', function (done) {
+    this.timeout(5000)
+
+    var cpu = osu.cpu
+    var info = cpu.average()
+    var count = cpu.count()
+    assert.ok(count > 0)
+    assert.ok(Object.keys(info).length > 0)
+    done()
+  })
+
+  it.skip('returns cpu usage', function (done) {
+    this.timeout(5000)
+
+    var cpu = osu.cpu
+
+    cpu.usage().then((num) => {
+      assert.ok(num > 0)
+      done()
+    })
+  })
+})
+
+describe('drive', function () {
+  it('returns drive info', function (done) {
+    var drive = osu.drive
+
+    drive.info().then((info) => {
+      assert.ok(Object.keys(info).length > 0)
+      done()
+    })
+  })
+})
+
+describe('memory', function () {
+  it('returns memory info', function (done) {
+    var men = osu.mem
+
+    men.info().then((info) => {
+      assert.ok(Object.keys(info).length > 0)
+      done()
+    })
+  })
+})