@lopatnov/express-reverse-proxy 1.0.1 → 1.2.0

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

@@ -0,0 +1,180 @@
+'use strict'
+
+const log = require('debug')('interactor:pm2:interface')
+const path = require('path')
+const async = require('async')
+const fs = require('fs')
+const cst = require('../constants')
+
+module.exports = class PM2Interface {
+  constructor (rpc) {
+    log('PM2Interface instantiate')
+    this.rpc = rpc
+  }
+
+  getProcessByName (name, cb) {
+    var foundProc = []
+
+    this.rpc.getMonitorData({}, (err, list) => {
+      if (err) {
+        log('Error retrieving process list: ' + err)
+        return cb(err)
+      }
+
+      list.forEach((proc) => {
+        if (proc.pm2_env.name === name || proc.pm2_env.pm_exec_path === path.resolve(name.toString())) {
+          foundProc.push(proc)
+        }
+      })
+
+      return cb(null, foundProc)
+    })
+  }
+
+  /**
+   * Scale up/down a process
+   * @method scale
+   */
+  scale (opts, cb) {
+    const self = this
+    const appName = opts.name
+    let number = opts.number
+
+    function addProcs (proc, value, cb) {
+      (function ex (proc, number) {
+        if (number-- === 0) return cb()
+        log('Scaling up application')
+        self.rpc.duplicateProcessId(proc.pm2_env.pm_id, ex.bind(this, proc, number))
+      })(proc, number)
+    }
+
+    function rmProcs (procs, value, cb) {
+      let i = 0;
+
+      (function ex (procs, number) {
+        if (number++ === 0) return cb()
+        self.rpc.deleteProcessId(procs[i++].pm2_env.pm_id, ex.bind(this, procs, number))
+      })(procs, number)
+    }
+
+    let end = () => {
+      return cb ? cb(null, {success: true}) : log('Successfuly scale')
+    }
+
+    this.getProcessByName(appName, (err, procs) => {
+      if (err) {
+        return cb ? cb(err) : log(err)
+      }
+
+      if (!procs || procs.length === 0) {
+        log('Application %s not found', appName)
+        return cb ? cb(new Error('App not found')) : log('App not found')
+      }
+
+      let procNumber = procs.length
+
+      if (typeof (number) === 'string' && number.indexOf('+') >= 0) {
+        number = parseInt(number, 10)
+        return addProcs(procs[0], number, end)
+      } else if (typeof (number) === 'string' && number.indexOf('-') >= 0) {
+        number = parseInt(number, 10)
+        return rmProcs(procs, number, end)
+      } else {
+        number = parseInt(number, 10)
+        number = number - procNumber
+
+        if (number < 0) {
+          return rmProcs(procs, number, end)
+        } else if (number > 0) {
+          return addProcs(procs[0], number, end)
+        } else {
+          log('Nothing to do')
+          return cb ? cb(new Error('Same process number')) : log('Same process number')
+        }
+      }
+    })
+  }
+
+  /**
+   * Dump current processes managed by pm2 into DUMP_FILE_PATH file
+   * @method dump
+   * @param {} cb
+   * @return
+   */
+  dump (cb) {
+    var envArr = []
+
+    this.rpc.getMonitorData({}, (err, list) => {
+      if (err) {
+        return typeof cb === 'function' ? cb(err) : false
+      }
+
+      /**
+       * Description
+       * @method end
+       * @param {} err
+       * @return
+       */
+      const end = () => {
+        // Overwrite dump file, delete if broken and exit
+        try {
+          fs.writeFileSync(cst.DUMP_FILE_PATH, JSON.stringify(envArr, '', 2))
+        } catch (e) {
+          log('Dump error', e.stack || e)
+          return cb(e)
+        }
+        return (cb) ? cb(null, {success: true}) : true
+      }
+
+      async.each(list, (app, done) => {
+        delete app.pm2_env.instances
+        delete app.pm2_env.pm_id
+        if (!app.pm2_env.pmx_module) {
+          envArr.push(app.pm2_env)
+        }
+        done()
+      }, end)
+    })
+  }
+
+  _callWithProcessId (fn, params, cb) {
+    if (params.id === undefined) {
+      this.getProcessByName(params.name, (err, processes) => {
+        if (err) return cb(err)
+
+        // in case we don't find the process ourselves
+        // we believe pm2 will find it
+        if (processes.length === 0) {
+          return fn(Object.assign({ id: params.name }, params), cb)
+        }
+
+        async.eachOf(processes, (process, _key, localCb) => {
+          params.id = process.pm_id
+          fn(params, localCb)
+        }, cb)
+      })
+    } else {
+      fn(params, cb)
+    }
+  }
+
+  restart (params, cb) {
+    this._callWithProcessId(this.rpc.restartProcessId, params, cb)
+  }
+
+  reload (params, cb) {
+    this._callWithProcessId(this.rpc.reloadProcessId, params, cb)
+  }
+
+  reset (params, cb) {
+    this._callWithProcessId(
+      (newParams, cb) => this.rpc.resetMetaProcessId(newParams.id, cb),
+      params,
+      cb
+    )
+  }
+
+  ping (params, cb) {
+    this._callWithProcessId(this.rpc.ping, params, cb)
+  }
+}

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

@@ -0,0 +1,173 @@
+'use strict'
+
+const EventEmitter2 = require('eventemitter2').EventEmitter2
+const async = require('async')
+const log = require('debug')('interactor:interface')
+const path = require('path')
+const config = require(path.join(__dirname, '../config')).transporters
+
+module.exports = class TransporterInterface extends EventEmitter2 {
+  /**
+   * Construct new transporter interface with default options and daemon
+   * @param {Object} opts [optionnal] Default options
+   * @param {InteractorDaemon} Daemon needed by transports
+   */
+  constructor (opts, daemon) {
+    log('New transporter interface')
+
+    super({
+      delimiter: ':',
+      wildcard: true
+    })
+    this.opts = opts || {}
+    this.daemon = daemon
+    this.transporters = new Map()
+    this.transportersEndpoints = new Map()
+    this.endpoints = new Map()
+    this.config = config
+    return this
+  }
+
+  /**
+   * Add transporter
+   * @param {String} name of the transporter (in ./transporters/)
+   * @param {Object} opts [optionnal] custom options
+   */
+  bind (name, opts) {
+    if (!opts) opts = {}
+    if (!this.config[name] || !this.config[name].enabled) return this
+    log('Bind [%s] transport to transporter interface', name)
+    let Transport = this._loadTransporter(name)
+    this.transporters.set(name, new Transport(Object.assign(opts, this.opts), this.daemon))
+    this.transportersEndpoints.set(name, this.config[name].endpoints || {})
+    this._bindEvents(name)
+    return this
+  }
+
+  /**
+   * Disconnect each transporters
+   */
+  disconnect () {
+    log('Disconnect all transporters')
+    this.transporters.forEach(transporter => {
+      transporter.disconnect()
+    })
+  }
+
+  /**
+   * Connect each transporters with new endpoints
+   * @param {Object} endpoints
+   * @param {Function} callback
+   */
+  connect (endpoints, cb) {
+    async.each(this.transporters, (data, next) => {
+      let name = data[0]
+      let transport = data[1]
+      // Isn't connected, connect it
+      if (!transport.isConnected()) {
+        log(`Connecting to: ${JSON.stringify(endpoints)}`)
+        transport.connect(this._buildConnectParamsFromEndpoints(name, endpoints), next)
+      // Endpoints have changed, reconnect
+      } else if (JSON.stringify(endpoints) !== JSON.stringify(this.endpoints)) {
+        log(`Received new endpoints to connect transporters: ${JSON.stringify(endpoints)}`)
+        transport.reconnect(this._buildConnectParamsFromEndpoints(name, endpoints), next)
+      // No changes
+      } else {
+        return next(null)
+      }
+    }, (err) => {
+      // Save endpoints
+      this.endpoints = endpoints
+      cb(err)
+    })
+  }
+
+  /**
+   * Send to each transporters
+   */
+  send (channel, data) {
+    if (process.env.VERBOSE)
+      console.log(`channel=${channel}: data=${JSON.stringify(data, '', 2)}`)
+    this.transporters.forEach(transporter => {
+      transporter.send(channel, data)
+    })
+  }
+
+  /**
+   * Require transporter
+   * @param {String} name of the transporter (in ./transporters/)
+   * @private
+   */
+  _loadTransporter (name) {
+    return require('./transporters/' + this._getTransportName(name))
+  }
+
+  /**
+   * Resolve transporter name
+   * @param {String} name of the transporter (in ./transporters/)
+   * @private
+   */
+  _getTransportName (name) {
+    name = name.toLowerCase()
+    name = name.charAt(0).toUpperCase() + name.slice(1)
+    return name + 'Transport'
+  }
+
+  /**
+   * Emit event on transporter event
+   * @param {String} name of the transporter
+   * @private
+   */
+  _bindEvents (name) {
+    const self = this
+    this.transporters.get(name).on('**', function (data) {
+      log('Received event from %s transporter', name)
+      self.emit(this.event, data)
+    })
+  }
+
+  /**
+   * Return an object used to connect() transport
+   * based on transporter endpoints options
+   * @param {String} transporter's name
+   * @param {Object} endpoints
+   * @private
+   */
+  _buildConnectParamsFromEndpoints (name, endpoints) {
+    if (!endpoints) endpoints = {}
+    const opts = this.transportersEndpoints.get(name)
+    if (typeof opts === 'string') {
+      return endpoints[opts] || opts
+    }
+    let params = {}
+    for (let key in opts) {
+      params[key] = endpoints[opts[key]] || opts[key]
+    }
+    return params
+  }
+
+  /**
+   * Is at least one transporter connected
+   * @return {Boolean}
+   */
+  isConnected () {
+    for (let transporter of this.transporters.values()) {
+      if (transporter.isConnected()) return true
+    }
+    return false
+  }
+
+  /**
+   * Get active transporters that are pushing data
+   * @return {String[]}
+   */
+  getActiveTransporters () {
+    let connected = []
+    for (let entry of this.transporters.values()) {
+      if (entry.isConnected()) {
+        connected.push(entry.constructor.name)
+      }
+    }
+    return connected
+  }
+}