@lopatnov/express-reverse-proxy 1.3.0 → 3.0.0

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

@@ -1,180 +0,0 @@
-'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

@@ -1,173 +0,0 @@
-'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
-  }
-}