@lopatnov/express-reverse-proxy 1.1.1 → 1.2.0

package/node_modules/@pm2/agent/src/Utility.js

@@ -0,0 +1,395 @@
+'use strict'
+
+const os = require('os')
+const crypto = require('crypto')
+const dayjs = require('dayjs')
+const url = require('url')
+const ProxyAgent = require('proxy-agent')
+const cst = require('../constants.js')
+
+const interfaceType = {
+  v4: {
+    default: '127.0.0.1',
+    family: 'IPv4'
+  },
+  v6: {
+    default: '::1',
+    family: 'IPv6'
+  }
+}
+
+/**
+ * Search for public network adress
+ * @param {String} type the type of network interface, can be either 'v4' or 'v6'
+ */
+const retrieveAddress = (type) => {
+  let interfce = interfaceType[type]
+  let ret = interfce.default
+  let interfaces = os.networkInterfaces()
+
+  Object.keys(interfaces).forEach(function (el) {
+    interfaces[el].forEach(function (el2) {
+      if (!el2.internal && el2.family === interfce.family) {
+        ret = el2.address
+      }
+    })
+  })
+  return ret
+}
+
+/**
+ * Simple cache implementation
+ *
+ * @param {Object} opts cache options
+ * @param {Function} opts.miss function called when a key isn't found in the cache
+ */
+class Cache {
+  constructor (opts) {
+    this._cache = {}
+    this._miss = opts.miss
+    this._ttl_time = opts.ttl
+    this._ttl = {}
+
+    if (opts.ttl) {
+      this._worker = setInterval(this.worker.bind(this), 1000)
+    }
+  }
+
+  worker () {
+    let keys = Object.keys(this._ttl)
+    for (let i = 0; i < keys.length; i++) {
+      let key = keys[i]
+      let value = this._ttl[key]
+      if (dayjs().isAfter(value)) {
+        delete this._cache[key]
+        delete this._ttl[key]
+      }
+    }
+  }
+
+  /**
+   * Get a value from the cache
+   *
+   * @param {String} key
+   */
+  get (key) {
+    if (!key) return null
+    let value = this._cache[key]
+    if (value) return value
+
+    value = this._miss(key)
+
+    if (value) {
+      this.set(key, value)
+    }
+    return value
+  }
+
+  /**
+   * Set a value in the cache
+   *
+   * @param {String} key
+   * @param {Mixed} value
+   */
+  set (key, value) {
+    if (!key || !value) return false
+    this._cache[key] = value
+    if (this._ttl_time) {
+      this._ttl[key] = dayjs().add(this._ttl_time, 'seconds')
+    }
+    return true
+  }
+
+  reset () {
+    this._cache = null
+    this._cache = {}
+    this._ttl = null
+    this._ttl = {}
+  }
+}
+
+/**
+ * StackTraceParser is used to parse callsite from stacktrace
+ * and get from FS the context of the error (if available)
+ *
+ * @param {Cache} cache cache implementation used to query file from FS and get context
+ */
+class StackTraceParser {
+  constructor (opts) {
+    this._cache = opts.cache
+    this._context_size = opts.context
+  }
+
+  isAbsolute (path) {
+    if (process.platform === 'win32') {
+      // https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56
+      let splitDeviceRe = /^([a-zA-Z]:|[\\/]{2}[^\\/]+[\\/]+[^\\/]+)?([\\/])?([\s\S]*?)$/
+      let result = splitDeviceRe.exec(path)
+      let device = result[1] || ''
+      let isUnc = Boolean(device && device.charAt(1) !== ':')
+      // UNC paths are always absolute
+      return Boolean(result[2] || isUnc)
+    } else {
+      return path.charAt(0) === '/'
+    }
+  }
+
+  parse (stack) {
+    if (!stack || stack.length === 0) return false
+
+    for (var i = 0, len = stack.length; i < len; i++) {
+      var callsite = stack[i]
+
+      // avoid null values
+      if (typeof callsite !== 'object') continue
+      if (!callsite.file_name || !callsite.line_number) continue
+
+      var type = this.isAbsolute(callsite.file_name) || callsite.file_name[0] === '.' ? 'user' : 'core'
+
+      // only use the callsite if its inside user space
+      if (!callsite || type === 'core' || callsite.file_name.indexOf('node_modules') > -1 ||
+          callsite.file_name.indexOf('vxx') > -1) {
+        continue
+      }
+
+      // get the whole context (all lines) and cache them if necessary
+      var context = this._cache.get(callsite.file_name)
+      var source = []
+      if (context && context.length > 0) {
+        // get line before the call
+        var preLine = callsite.line_number - this._context_size - 1
+        var pre = context.slice(preLine > 0 ? preLine : 0, callsite.line_number - 1)
+        if (pre && pre.length > 0) {
+          pre.forEach(function (line) {
+            source.push(line.replace(/\t/g, '  '))
+          })
+        }
+        // get the line where the call has been made
+        if (context[callsite.line_number - 1]) {
+          source.push(context[callsite.line_number - 1].replace(/\t/g, '  ').replace('  ', '>>'))
+        }
+        // and get the line after the call
+        var postLine = callsite.line_number + this._context_size
+        var post = context.slice(callsite.line_number, postLine)
+        if (post && post.length > 0) {
+          post.forEach(function (line) {
+            source.push(line.replace(/\t/g, '  '))
+          })
+        }
+      }
+      return {
+        context: source.length > 0 ? source.join('\n') : 'cannot retrieve source context',
+        callsite: [ callsite.file_name, callsite.line_number ].join(':')
+      }
+    }
+    return false
+  }
+
+  attachContext (error) {
+    if (!error) return error
+
+    // if pmx attached callsites we can parse them to retrieve the context
+    if (typeof (error.stackframes) === 'object') {
+      let result = this.parse(error.stackframes)
+      // no need to send it since there is already the stacktrace
+      delete error.stackframes
+      delete error.__error_callsites
+
+      if (result) {
+        error.callsite = result.callsite
+        error.context = result.context
+      }
+    }
+    // if the stack is here we can parse it directly from the stack string
+    // only if the context has been retrieved from elsewhere
+    if (typeof error.stack === 'string' && !error.callsite) {
+      let siteRegex = /(\/[^\\\n]*)/g
+      let tmp
+      let stack = []
+
+      // find matching groups
+      while ((tmp = siteRegex.exec(error.stack))) {
+        stack.push(tmp[1])
+      }
+
+      // parse each callsite to match the format used by the stackParser
+      stack = stack.map((callsite) => {
+        // remove the trailing ) if present
+        if (callsite[callsite.length - 1] === ')') {
+          callsite = callsite.substr(0, callsite.length - 1)
+        }
+        let location = callsite.split(':')
+
+        return location.length < 3 ? callsite : {
+          file_name: location[0],
+          line_number: parseInt(location[1])
+        }
+      })
+
+      let finalCallsite = this.parse(stack)
+      if (finalCallsite) {
+        error.callsite = finalCallsite.callsite
+        error.context = finalCallsite.context
+      }
+    }
+    return error
+  }
+}
+
+// EWMA = ExponentiallyWeightedMovingAverage from
+// https://github.com/felixge/node-measured/blob/master/lib/util/ExponentiallyMovingWeightedAverage.js
+// Copyright Felix Geisendörfer <felix@debuggable.com> under MIT license
+class EWMA {
+  constructor () {
+    this._timePeriod = 60000
+    this._tickInterval = 5000
+    this._alpha = 1 - Math.exp(-this._tickInterval / this._timePeriod)
+    this._count = 0
+    this._rate = 0
+    this._interval = setInterval(_ => {
+      this.tick()
+    }, this._tickInterval)
+    this._interval.unref()
+  }
+
+  update (n) {
+    this._count += n || 1
+  }
+
+  tick () {
+    let instantRate = this._count / this._tickInterval
+    this._count = 0
+    this._rate += (this._alpha * (instantRate - this._rate))
+  }
+
+  rate (timeUnit) {
+    return (this._rate || 0) * timeUnit
+  }
+}
+
+class Cipher {
+  static get CIPHER_ALGORITHM () {
+    return 'aes256'
+  }
+
+  /**
+   * Decipher data using 256 bits key (AES)
+   * @param {Hex} data input data
+   * @param {String} key 256 bits key
+   * @return {Object} deciphered data parsed as json object
+   */
+  static decipherMessage (msg, key) {
+    try {
+      let decipher = crypto.createDecipher(Cipher.CIPHER_ALGORITHM, key)
+      let decipheredMessage = decipher.update(msg, 'hex', 'utf8')
+      decipheredMessage += decipher.final('utf8')
+      return JSON.parse(decipheredMessage)
+    } catch (err) {
+      console.error(err)
+      return null
+    }
+  }
+
+  /**
+   * Cipher data using 256 bits key (AES)
+   * @param {String} data input data
+   * @param {String} key 256 bits key
+   * @return {Hex} ciphered data
+   */
+  static cipherMessage (data, key) {
+    try {
+      // stringify if not already done (fail safe)
+      if (typeof data !== 'string') {
+        data = JSON.stringify(data)
+      }
+
+      let cipher = crypto.createCipher(Cipher.CIPHER_ALGORITHM, key)
+      let cipheredData = cipher.update(data, 'utf8', 'hex')
+      cipheredData += cipher.final('hex')
+      return cipheredData
+    } catch (err) {
+      console.error(err)
+    }
+  }
+}
+
+/**
+ * HTTP wrapper
+ */
+class HTTPClient {
+  /**
+   * Return native module (HTTP/HTTPS)
+   * @param {String} url
+   */
+  getModule (url) {
+    return url.match(/https:\/\//) ? require('https') : require('http')
+  }
+  /**
+   * Send an HTTP request and return data or error if status > 200
+   * @param {Object} opts
+   * @param {String} opts.url
+   * @param {String} opts.method
+   * @param {Object} [opts.data]
+   * @param {Object} [opts.headers]
+   * @param {Function} cb invoked with <err, body>
+   */
+  open (opts, cb) {
+    const http = this.getModule(opts.url)
+    const parsedUrl = url.parse(opts.url)
+    let data = null
+    const options = {
+      hostname: parsedUrl.hostname,
+      path: parsedUrl.path,
+      port: parsedUrl.port,
+      method: opts.method,
+      headers: opts.headers,
+      agent: cst.PROXY ? new ProxyAgent(cst.PROXY) : undefined
+    }
+
+    if (opts.data) {
+      data = JSON.stringify(opts.data)
+      options.headers = Object.assign({
+        'Content-Type': 'application/json',
+        'Content-Length': data.length
+      }, opts.headers)
+    }
+
+    const req = http.request(options, (res) => {
+      let body = ''
+
+      res.setEncoding('utf8')
+      res.on('data', (chunk) => {
+        body += chunk.toString()
+      })
+      res.on('end', () => {
+        try {
+          let jsonData = JSON.parse(body)
+          return cb(null, jsonData)
+        } catch (err) {
+          return cb(err)
+        }
+      })
+    })
+    req.on('error', cb)
+
+    if (data) {
+      req.write(data)
+    }
+    req.end()
+  }
+}
+
+module.exports = {
+  EWMA: EWMA,
+  Cache: Cache,
+  StackTraceParser: StackTraceParser,
+  serialize: require('fclone'),
+  network: {
+    getIP: retrieveAddress,
+    v4: retrieveAddress('v4'),
+    v6: retrieveAddress('v6')
+  },
+  HTTPClient: HTTPClient,
+  Cipher: Cipher,
+  clone: require('fclone')
+}

package/node_modules/@pm2/agent/src/WatchDog.js

@@ -0,0 +1,70 @@
+'use strict'
+
+const debug = require('debug')('interactor:watchdog')
+const child = require('child_process')
+const path = require('path')
+const RECONNECT_TENTATIVES_BEFORE_RESURRECT = 6
+
+process.env.PM2_AGENT_ONLINE = true
+
+module.exports = class WatchDog {
+  static start (p) {
+    this.pm2_binary_path = p.pm2_binary_path
+    this.ipm2 = p.conf.ipm2
+    this.relaunching = false
+    this.autoDumpTime = 5 * 60 * 1000
+
+    /**
+     * Handle PM2 connection state changes
+     */
+    this.ipm2.on('ready', _ => {
+      debug('Connected to PM2')
+      this.relaunching = false
+      this.autoDump()
+    })
+
+    debug('Launching')
+
+    this.reconnect_tentatives = 0
+
+    this.ipm2.on('reconnecting', _ => {
+      debug('PM2 is disconnected - Relaunching PM2')
+
+      if (this.dump_interval) {
+        clearInterval(this.dump_interval)
+      }
+
+      if (this.reconnect_tentatives++ >= RECONNECT_TENTATIVES_BEFORE_RESURRECT &&
+          this.relaunching === false) {
+        this.relaunching = true
+        this.resurrect()
+      }
+    })
+  }
+
+  static stop() {
+    clearInterval(this.dump_interval)
+  }
+
+  static resurrect () {
+    debug(`Trying to launch PM2: ${path.resolve(__dirname, '../../../../bin/pm2')}`)
+    child.exec(`node ${this.pm2_binary_path} resurrect`, (err, sto, ste) => {
+      if (err) console.error(err)
+      console.log(sto, ste)
+      this.reconnect_tentatives = 0
+      setTimeout(_ => {
+        this.relaunching = false
+      }, 10 * 1000)
+    })
+  }
+
+  static autoDump () {
+    this.dump_interval = setInterval(_ => {
+      if (this.relaunching === true) return
+
+      this.ipm2.pm2Interface.dump(function (err) {
+        return err ? debug('Error when dumping', err) : debug('PM2 process list dumped')
+      })
+    }, this.autoDumpTime)
+  }
+}

package/node_modules/@pm2/agent/src/push/DataRetriever.js

@@ -0,0 +1,77 @@
+'use strict'
+
+const os = require('os')
+const pkg = require('../../package.json')
+const constants = require('../../constants')
+const path = require('path')
+const hostname = os.hostname()
+const platform = os.platform()
+const username = process.env.SUDO_USER || process.env.C9_USER || process.env.LOGNAME ||
+      process.env.USER || process.env.LNAME || process.env.USERNAME
+
+module.exports = class DataRetriever {
+  /**
+   * Normalize each process metdata
+   * @param {Object} processes process list extracted from pm2 daemon
+   * @param {Object} conf interactor configuration
+   */
+  static status (processes, conf) {
+    processes = processes || []
+    const formattedProcs = processes
+          .filter(proc => !proc.pm2_env.name.match(/_old_/))
+          .map((proc) => {
+
+            // proc.pm2_env.axm_actions = proc.pm2_env.axm_actions.concat(conf.PM2_REMOTE_METHOD_ALLOWED.map(method => {
+            //   return {action_name: method, action_type: 'internal'}
+            // }))
+
+            return {
+              pid: proc.pid,
+              name: proc.pm2_env.name,
+              interpreter: proc.pm2_env.exec_interpreter,
+              args: proc.pm2_env.node_args,
+              path: proc.pm2_env.pm_exec_path,
+              restart_time: proc.pm2_env.restart_time,
+              created_at: proc.pm2_env.created_at,
+              exec_mode: proc.pm2_env.exec_mode,
+              pm_uptime: proc.pm2_env.pm_uptime,
+              status: proc.pm2_env.status,
+              pm_id: proc.pm2_env.pm_id,
+              unique_id: proc.pm2_env.unique_id,
+
+              cpu: Math.floor(proc.monit.cpu) || 0,
+              memory: Math.floor(proc.monit.memory) || 0,
+
+              versioning: proc.pm2_env.versioning || null,
+
+              node_env: proc.pm2_env.NODE_ENV || null,
+
+              axm_actions: proc.pm2_env.axm_actions || [],
+              axm_monitor: proc.pm2_env.axm_monitor || {},
+              //axm_options: proc.pm2_env.axm_options || {},
+              axm_options: {},
+              axm_dynamic: proc.pm2_env.dynamic || {}
+            }
+          })
+
+    return {
+      process: formattedProcs,
+      server: {
+        username: username,
+        hostname: hostname,
+        uptime: os.uptime(),
+        platform: platform,
+        pm2_version: conf.PM2_VERSION,
+        pm2_agent_version: pkg.version,
+        node_version: process.version,
+        unique_id: constants.UNIQUE_SERVER_ID,
+        //loadavg: os.loadavg(),
+        //total_mem: os.totalmem(),
+        //free_mem: os.freemem(),
+        //cpu: cpuMeta,
+        //type: os.type(),
+        //interaction: conf.REVERSE_INTERACT,
+      }
+    }
+  }
+}