@lopatnov/express-reverse-proxy 1.2.0 → 2.0.0

package/node_modules/@pm2/agent/src/reverse/ReverseInteractor.js

@@ -1,128 +0,0 @@
-
-'use strict'
-
-const debug = require('debug')('interactor:reverse')
-
-/**
- * ReverseInteractor is the class that handle receiving event from KM
- * @param {Object} opts interactor options
- * @param {PM2} pm2 pm2 api
- * @param {WebsocketTransport} transport websocket transport used to receive data to KM
- */
-module.exports = class ReverseInteractor {
-  constructor (opts, ipm2, transport) {
-    this.ipm2 = ipm2
-    this.transport = transport
-    this.opts = opts
-    this.remoteMethodAlloweds = this.opts.PM2_REMOTE_METHOD_ALLOWED
-  }
-
-  start () {
-    debug('Reverse interactor is listening')
-    // action that trigger custom actions inside the code
-    this.transport.on('trigger:action', this._onCustomAction.bind(this))
-    this.transport.on('trigger:scoped_action', this._onCustomAction.bind(this))
-    // action that call pm2 api
-    this.transport.on('trigger:pm2:action', this._onPM2Action.bind(this))
-  }
-
-  stop () {
-    debug('Reverse interactor is no longer listening')
-    this.transport.removeAllListeners('trigger:action')
-    this.transport.removeAllListeners('trigger:scoped_action')
-    this.transport.removeAllListeners('trigger:pm2:action')
-  }
-
-  /**
-   * Listener for custom actions that can be triggered by KM, either scoped or normal
-   * @param {Object} data
-   * @param {Object} data.action_name name of the action triggered
-   * @param {Object} [data.app_name] name of the process where the action need to be run
-   * @param {Object} [data.process_id] id of the process where the action need to be run
-   * @param {Object} [data.opts] parameters used to call the method
-   * @param {Object} [data.uuid] uuid used to recognized the scoped action (scoped action only)
-   */
-  _onCustomAction (data) {
-    const type = data.uuid ? 'SCOPED' : 'REMOTE'
-
-    data.process_id = data.process_id !== undefined ? data.process_id : data.process.pm_id
-    debug('New %s action %s triggered for process %s', type, data.action_name, data.process_id)
-    // send the request to pmx via IPC
-    this.ipm2.msgProcess({
-      name: data.app_name,
-      id: data.process_id,
-      msg: data.action_name,
-      opts: data.opts || data.options || null,
-      action_name: data.action_name,
-      uuid: data.uuid
-    }, (err, res) => {
-      if (err) {
-        return this.transport.send('trigger:action:failure', {
-          success: false,
-          err: err.message || err,
-          id: data.process_id,
-          action_name: data.action_name
-        })
-      }
-      debug('Message received from AXM for proc_id : %s and action name %s', data.process_id, data.action_name)
-      return this.transport.send('trigger:action:success', {
-        success: true,
-        id: data.process_id,
-        action_name: data.action_name
-      })
-    })
-  }
-
-  /**
-   * Handle when KM call a pm2 action
-   * @param {Object} data
-   * @param {Object} data.method_name the name of the pm2 method
-   * @param {Object} data.parameters optional parameters used to call the method
-   */
-  _onPM2Action (data) {
-    // callback when the action has been executed
-    let callback = (err, res) => {
-      debug('PM2 action ended : pm2 %s (%s)', data.method_name, !err ? 'no error' : (err.message || err))
-      this.transport.send('trigger:pm2:result', {
-        ret: { err: err, data: res },
-        meta: {
-          method_name: data.method_name,
-          app_name: data.parameters.name,
-          machine_name: this.opts.MACHINE_NAME,
-          public_key: this.opts.PUBLIC_KEY
-        }
-      })
-    }
-    if (typeof data.method_name !== 'string') {
-      return debug('New PM2 action triggered with invalid method name: ', data.method_name)
-    }
-    if (this.remoteMethodAlloweds.indexOf(data.method_name) === -1) {
-      return callback(new Error('Method not allowed'))
-    }
-
-    debug('New PM2 action triggered : pm2 %s %j', data.method_name, data.parameters)
-
-    const method = data.method_name
-    let parameters = data.parameters
-    try {
-      parameters = JSON.parse(JSON.stringify(data.parameters))
-    } catch (err) {
-      console.error(err)
-    }
-
-    if (method === 'startLogging') {
-      global._logs = true
-      // Stop streaming logs automatically after timeout
-      clearTimeout(this._loggingTimeoutId)
-      this._loggingTimeoutId = setTimeout(function () {
-        global._logs = false
-      }, process.env.NODE_ENV === 'test' ? 10 : 120000)
-      return callback(null, 'Log streaming enabled')
-    } else if (method === 'stopLogging') {
-      global._logs = false
-      return callback(null, 'Log streaming disabled')
-    }
-
-    return this.ipm2.remote(method, parameters, callback)
-  }
-}

package/node_modules/@pm2/agent/src/transporters/Transporter.js

@@ -1,129 +0,0 @@
-'use strict'
-
-const log = require('debug')('interactor:transporter')
-const EventEmitter2 = require('eventemitter2').EventEmitter2
-const dns = require('dns')
-const cst = require('../../constants.js')
-
-module.exports = class Transporter extends EventEmitter2 {
-  constructor () {
-    super({
-      delimiter: ':',
-      wildcard: true
-    })
-  }
-
-  /**
-   * Disconnect and connect to a url
-   * @param {String} url where the client will connect [optionnal]
-   * @param {Function} cb invoked with <err>
-   */
-  reconnect (url, cb) {
-    log('Reconnect transporter')
-    this.disconnect()
-    this.connect(url, cb)
-  }
-
-  /**
-   * Broadcast the close event from websocket connection
-   * @private
-   * @param {Integer} code
-   * @param {String} reason
-   */
-  _onClose (code, reason) {
-    log('Closed transporter')
-    this.disconnect()
-    this._reconnect()
-    this.emit('close', code, reason)
-  }
-
-  /**
-   * Broadcast the error event from websocket connection
-   * and eventually close the connection if it isnt already
-   * @private
-   * @param {Error} err
-   */
-  _onError (err) {
-    log(`Error with transporter: ${err.message}`)
-    // close connection if needed
-    this.disconnect()
-    this._reconnect()
-    this.emit('error', err)
-  }
-
-  /**
-   * Worker that will empty the packet queue if the connection works.
-   * @private
-   */
-  _emptyQueue () {
-    // create the queue if it doesn't exist
-    if (!this.queue) {
-      this.queue = []
-      return
-    }
-    if (this.queue.length === 0) return
-    if (!this.isConnected()) return
-
-    log('Emptying queue (size : %d)', this.queue.length)
-
-    // re-send all of the data
-    while (this.queue.length > 0) {
-      if (!this.isConnected()) return
-      let packet = this.queue[0]
-      this.send(packet.channel, packet.data)
-      this.queue.shift()
-    }
-  }
-
-  /**
-   * Is internet reachable via DNS
-   * @private
-   * @param {Function} cb invoked with <boolean>
-   */
-  _checkInternet (cb) {
-    dns.lookup('google.com', (err) => {
-      if (err && (err.code === 'ENOTFOUND' || err.code === 'EAI_AGAIN')) {
-        if (this._online) {
-          log('Internet is unreachable (DNS)')
-        }
-        this._online = false
-      } else {
-        if (!this._online) {
-          log('Internet is reachable again')
-        }
-        this._online = true
-      }
-      return cb(this._online)
-    })
-  }
-
-  /**
-   * Strategy to reconnect to remote endpoint as soon as possible
-   *  -> test internet connection with dns request (if fail retry in 2 sec)
-   *  -> try to connect to endpoint (if fail retry in 5 sec)
-   */
-  _reconnect () {
-    if (this._reconnecting === true) return
-    this._reconnecting = true
-
-    log('Trying to reconnect to remote endpoint')
-    this._checkInternet((online) => {
-      if (!online && !cst.PM2_DEBUG) {
-        log('Internet down, retry in 2 seconds ..')
-        this._reconnecting = false
-        return setTimeout(this._reconnect.bind(this), process.env.NODE_ENV === 'test' ? 1 : 2000)
-      }
-      this.connect((err) => {
-        if (err || !this.isConnected()) {
-          log('Endpoint down, retry in 5 seconds ...')
-          this._reconnecting = false
-          return setTimeout(this._reconnect.bind(this), process.env.NODE_ENV === 'test' ? 1 : 5000)
-        }
-
-        log('Connection etablished with remote endpoint')
-        this._reconnecting = false
-        this._emptyQueue()
-      })
-    })
-  }
-}

package/node_modules/@pm2/agent/src/transporters/WebsocketTransport.js

@@ -1,204 +0,0 @@
-'use strict'
-
-const WebSocket = require('ws')
-const ProxyAgent = require('proxy-agent')
-const log = require('debug')('interactor:websocket')
-const cst = require('../../constants.js')
-const pkg = require('../../package.json')
-const Transporter = require('./Transporter')
-const jsonPatch = require('fast-json-patch')
-const fs = require('fs')
-/**
- * Websocket Transport used to communicate with KM
- * @param {Object} opts options
- * @param {Daemon} daemon Interactor instance
- */
-module.exports = class WebsocketTransport extends Transporter {
-  constructor (opts, daemon) {
-    super()
-    log('WebsocketTransporter constructed')
-    this.opts = opts
-    this._daemon = daemon
-    this._ws = null
-    this.queue = []
-    this._last_status = null
-    this._resend_status = false
-    this._worker = setInterval(this._emptyQueue.bind(this), process.env.NODE_ENV === 'test' ? 2 : 10000)
-    this._heartbeater = setInterval(this._heartbeat.bind(this), 5000)
-  }
-
-  /**
-   * Send heartbeat to websocket server (every 5 sec)
-   */
-  _heartbeat () {
-    if (!this.isConnected()) return false
-    return this._ws.ping()
-  }
-
-  /**
-   * Connect the websocket client to a url
-   * @param {String} url where the client will connect
-   * @param {Function} cb invoked with <err>
-   */
-  connect (url, cb) {
-    if (typeof url === 'function') {
-      cb = url
-      url = this.endpoint
-    }
-    this.endpoint = url
-
-    if (!url) return cb(new Error('Websocket URL is not defined!'))
-
-    log('Connecting websocket transporter to %s...', url)
-    this._ws = new WebSocket(url, {
-      perMessageDeflate: process.env.WS_GZIP || false,
-      headers: {
-        'X-KM-PUBLIC': this.opts.PUBLIC_KEY,
-        'X-KM-SECRET': this.opts.SECRET_KEY,
-        'X-KM-SERVER': this.opts.MACHINE_NAME,
-        'X-PM2-VERSION': this.opts.PM2_VERSION || '0.0.0',
-        'X-PROTOCOL-VERSION': cst.PROTOCOL_VERSION,
-        'User-Agent': `PM2 Agent v${pkg.version}`
-      },
-      agent: cst.PROXY ? new ProxyAgent(cst.PROXY) : undefined
-    })
-
-    let onError = (err) => {
-      log('Error on websocket connect', err)
-      return cb(err)
-    }
-    this._ws.once('error', onError)
-    this._ws.once('open', () => {
-      this._resend_status = true
-      log(`Connected to ${url}`)
-      if (!this._ws) return false // an error occurred
-      this._ws.removeListener('error', onError)
-      this._ws.on('close', this._onClose.bind(this))
-      this._ws.on('error', this._onError.bind(this))
-      return cb()
-    })
-
-    this._ws.on('message', this._onMessage.bind(this))
-    this._ws.on('ping', (data) => {
-      this._ws.pong()
-    })
-    this._ws.on('pong', (data) => {})
-  }
-
-  /**
-   * Disconnect clients
-   */
-  disconnect () {
-    log('Disconnect websocket transporter')
-    if (this.isConnected()) {
-      this._ws.close(1000, 'Disconnecting')
-    }
-    this._ws = null
-  }
-
-  /**
-   * Are push and reverse connections ready
-   * @return {Boolean}
-   */
-  isConnected () {
-    return this._ws && this._ws.readyState === 1
-  }
-
-  /**
-   * Send data to endpoints
-   * @param {String} channel
-   * @param {Object} data
-   */
-  send (channel, data) {
-    if (!channel || !data) {
-      return log('Trying to send message without all necessary fields')
-    }
-    if (!this.isConnected()) {
-      if (!this._reconnecting) this._reconnect()
-
-      // do not buffer status/monitoring packet
-      if (channel === 'status' || channel === 'monitoring') return
-
-      log('Trying to send data while not connected, buffering ...')
-
-      // remove last element if the queue is full
-      if (this.queue.length >= cst.PACKET_QUEUE_SIZE) {
-        this.queue.shift()
-      }
-      return this.queue.push({ channel: channel, data: data })
-    }
-
-    if (channel === 'status' && process.env.WS_JSON_PATCH) {
-      if (this._last_status == null || this._resend_status == true) {
-        if (this._resend_status)
-          log('Sending fresh new status')
-        this._resend_status = false
-        this._last_status = data
-      }
-      else {
-        let patch = jsonPatch.compare(this._last_status, data)
-
-        let packet = {
-          payload: patch,
-          channel: 'status:patch'
-        }
-
-        this._last_status = data
-
-
-        if (process.env.WS_JSON_PATCH_BENCH) {
-          fs.writeFileSync('status', JSON.stringify(data))
-          fs.writeFileSync('patch', JSON.stringify(packet))
-        }
-
-        return this._ws.send(JSON.stringify(packet), (err) => {
-          packet = null
-          if (err) {
-            this.emit('error', err)
-          }
-        })
-      }
-    }
-
-    log('Sending packet over for channel %s', channel)
-    let packet = {
-      payload: data,
-      channel: channel
-    }
-    this._ws.send(JSON.stringify(packet), {
-      compress: cst.COMPRESS_PROTOCOL || false
-    }, (err) => {
-      packet = null
-      if (err) {
-        this.emit('error', err)
-        // buffer the packet to send it when the connection will be up again
-        this.queue.push({ channel: channel, data: data })
-      }
-    })
-  }
-
-  /**
-   * Message received from keymetrics
-   * @private
-   * @param {String} json packet
-   */
-  _onMessage (data) {
-    try {
-      data = JSON.parse(data)
-    } catch (err) {
-      return log('Bad packet received from remote : %s', err.message || err)
-    }
-
-    if (process.env.WS_JSON_PATCH && data.channel == 'status:resend') {
-      log(`Wrong patch sent to backend, resending fresh status`)
-      this._resend_status = true
-    }
-
-    // ensure that all required field are present
-    if (!data || !data.payload || !data.channel) {
-      return log('Received message without all necessary fields')
-    }
-    log('Recevied data on channel %s', data.channel)
-    this.emit(data.channel, data.payload)
-  }
-}

package/node_modules/@pm2/agent/src/utils/BinaryHeap.js

@@ -1,135 +0,0 @@
-'use strict'
-
-// Hacked https://github.com/felixge/node-measured
-
-// Based on http://en.wikipedia.org/wiki/Binary_Heap
-// as well as http://eloquentjavascript.net/appendix2.html
-module.exports = BinaryHeap
-function BinaryHeap (options) {
-  options = options || {}
-
-  this._elements = options.elements || []
-  this._score = options.score || this._score
-}
-
-BinaryHeap.prototype.add = function (/* elements */) {
-  for (var i = 0; i < arguments.length; i++) {
-    var element = arguments[i]
-
-    this._elements.push(element)
-    this._bubble(this._elements.length - 1)
-  }
-}
-
-BinaryHeap.prototype.first = function () {
-  return this._elements[0]
-}
-
-BinaryHeap.prototype.removeFirst = function () {
-  var root = this._elements[0]
-  var last = this._elements.pop()
-
-  if (this._elements.length > 0) {
-    this._elements[0] = last
-    this._sink(0)
-  }
-
-  return root
-}
-
-BinaryHeap.prototype.clone = function () {
-  return new BinaryHeap({
-    elements: this.toArray(),
-    score: this._score
-  })
-}
-
-BinaryHeap.prototype.toSortedArray = function () {
-  var array = []
-  var clone = this.clone()
-
-  while (true) {
-    var element = clone.removeFirst()
-    if (element === undefined) break
-
-    array.push(element)
-  }
-
-  return array
-}
-
-BinaryHeap.prototype.toArray = function () {
-  return [].concat(this._elements)
-}
-
-BinaryHeap.prototype.size = function () {
-  return this._elements.length
-}
-
-BinaryHeap.prototype._bubble = function (bubbleIndex) {
-  var bubbleElement = this._elements[bubbleIndex]
-  var bubbleScore = this._score(bubbleElement)
-
-  while (bubbleIndex > 0) {
-    var parentIndex = this._parentIndex(bubbleIndex)
-    var parentElement = this._elements[parentIndex]
-    var parentScore = this._score(parentElement)
-
-    if (bubbleScore <= parentScore) break
-
-    this._elements[parentIndex] = bubbleElement
-    this._elements[bubbleIndex] = parentElement
-    bubbleIndex = parentIndex
-  }
-}
-
-BinaryHeap.prototype._sink = function (sinkIndex) {
-  var sinkElement = this._elements[sinkIndex]
-  var sinkScore = this._score(sinkElement)
-  var length = this._elements.length
-
-  while (true) {
-    var swapIndex = null
-    var swapScore = null
-    var swapElement = null
-    var childIndexes = this._childIndexes(sinkIndex)
-
-    for (var i = 0; i < childIndexes.length; i++) {
-      var childIndex = childIndexes[i]
-
-      if (childIndex >= length) break
-
-      var childElement = this._elements[childIndex]
-      var childScore = this._score(childElement)
-
-      if (childScore > sinkScore) {
-        if (swapScore === null || swapScore < childScore) {
-          swapIndex = childIndex
-          swapScore = childScore
-          swapElement = childElement
-        }
-      }
-    }
-
-    if (swapIndex === null) break
-
-    this._elements[swapIndex] = sinkElement
-    this._elements[sinkIndex] = swapElement
-    sinkIndex = swapIndex
-  }
-}
-
-BinaryHeap.prototype._parentIndex = function (index) {
-  return Math.floor((index - 1) / 2)
-}
-
-BinaryHeap.prototype._childIndexes = function (index) {
-  return [
-    2 * index + 1,
-    2 * index + 2
-  ]
-}
-
-BinaryHeap.prototype._score = function (element) {
-  return element.valueOf()
-}

package/node_modules/@pm2/agent/src/utils/EDS.js

@@ -1,111 +0,0 @@
-'use strict'
-// Hacked https://github.com/felixge/node-measured
-
-var BinaryHeap = require('./BinaryHeap')
-var units = require('./units')
-
-module.exports = ExponentiallyDecayingSample
-function ExponentiallyDecayingSample (options) {
-  options = options || {}
-
-  this._elements = new BinaryHeap({
-    score: function (element) {
-      return -element.priority
-    }
-  })
-
-  this._rescaleInterval = options.rescaleInterval || ExponentiallyDecayingSample.RESCALE_INTERVAL
-  this._alpha = options.alpha || ExponentiallyDecayingSample.ALPHA
-  this._size = options.size || ExponentiallyDecayingSample.SIZE
-  this._random = options.random || this._random
-  this._landmark = null
-  this._nextRescale = null
-  this._mean = null
-}
-
-ExponentiallyDecayingSample.RESCALE_INTERVAL = 1 * units.HOURS
-ExponentiallyDecayingSample.ALPHA = 0.015
-ExponentiallyDecayingSample.SIZE = 1028
-
-ExponentiallyDecayingSample.prototype.update = function (value, timestamp) {
-  var now = Date.now()
-  if (!this._landmark) {
-    this._landmark = now
-    this._nextRescale = this._landmark + this._rescaleInterval
-  }
-
-  timestamp = timestamp || now
-
-  var newSize = this._elements.size() + 1
-
-  var element = {
-    priority: this._priority(timestamp - this._landmark),
-    value: value
-  }
-
-  if (newSize <= this._size) {
-    this._elements.add(element)
-  } else if (element.priority > this._elements.first().priority) {
-    this._elements.removeFirst()
-    this._elements.add(element)
-  }
-
-  if (now >= this._nextRescale) this._rescale(now)
-}
-
-ExponentiallyDecayingSample.prototype.toSortedArray = function () {
-  return this._elements
-    .toSortedArray()
-    .map(function (element) {
-      return element.value
-    })
-}
-
-ExponentiallyDecayingSample.prototype.toArray = function () {
-  return this._elements
-    .toArray()
-    .map(function (element) {
-      return element.value
-    })
-}
-
-ExponentiallyDecayingSample.prototype._weight = function (age) {
-  // We divide by 1000 to not run into huge numbers before reaching a
-  // rescale event.
-  return Math.exp(this._alpha * (age / 1000))
-}
-
-ExponentiallyDecayingSample.prototype._priority = function (age) {
-  return this._weight(age) / this._random()
-}
-
-ExponentiallyDecayingSample.prototype._random = function () {
-  return Math.random()
-}
-
-ExponentiallyDecayingSample.prototype._rescale = function (now) {
-  now = now || Date.now()
-
-  var self = this
-  var oldLandmark = this._landmark
-  this._landmark = now || Date.now()
-  this._nextRescale = now + this._rescaleInterval
-
-  var factor = self._priority(-(self._landmark - oldLandmark))
-
-  this._elements
-    .toArray()
-    .forEach(function (element) {
-      element.priority *= factor
-    })
-}
-
-ExponentiallyDecayingSample.prototype.avg = function (now) {
-  var sum = 0
-  this._elements
-    .toArray()
-    .forEach(function (element) {
-      sum += element.value
-    })
-  return (sum / this._elements.size())
-}