@lopatnov/express-reverse-proxy 1.0.1 → 1.2.0

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

@@ -0,0 +1,452 @@
+'use strict'
+
+const fs = require('fs')
+const rpc = require('pm2-axon-rpc')
+const axon = require('pm2-axon')
+const log = require('debug')('interactor:daemon')
+const os = require('os')
+const cst = require('../constants.js')
+const ReverseInteractor = require('./reverse/ReverseInteractor.js')
+const PushInteractor = require('./push/PushInteractor.js')
+const Utility = require('./Utility.js')
+const PM2Client = require('./PM2Client.js')
+const TransporterInterface = require('./TransporterInterface.js')
+const domain = require('domain') // eslint-disable-line
+const WatchDog = require('./WatchDog')
+const InteractorClient = require('./InteractorClient')
+const semver = require('semver')
+const path = require('path')
+const pkg = require('../package.json')
+
+global._logs = false
+
+const InteractorDaemon = module.exports = class InteractorDaemon {
+  constructor () {
+    this.opts = this.retrieveConf()
+
+    log(`MACHINE_NAME=${this.opts.MACHINE_NAME}`)
+    log(`PUBLIC_KEY=${this.opts.PUBLIC_KEY}`)
+    log(`ROOT_URL=${cst.KEYMETRICS_ROOT_URL}`)
+
+    this.DAEMON_ACTIVE = false
+    this.transport = new TransporterInterface(this.opts, this)
+      .bind('websocket')
+    this.transport.on('error', (err) => {
+      return console.error('[NETWORK] Error : ' + err.message || err)
+    })
+    this.httpClient = new Utility.HTTPClient()
+    this._online = true
+
+    this._internalDebugger()
+  }
+
+  /**
+   * Use process.send() if connected
+   * @param {Object} data
+   */
+  sendToParent (data) {
+    if (!process.connected || !process.send) return console.log('Could not send data to parent')
+
+    try {
+      process.send(data)
+    } catch (e) {
+      console.trace('Parent process disconnected')
+    }
+  }
+
+  /**
+   * Get an interface for communicating with PM2 daemon
+   * @private
+   * @return {PM2Client}
+   */
+  getPM2Client () {
+    if (!this._ipm2) {
+      this._ipm2 = new PM2Client()
+    }
+    return this._ipm2
+  }
+
+  /**
+   * Terminate aconnections and exit
+   * @param {cb} callback called at the end
+   */
+  exit (err, cb) {
+    log('Exiting Interactor')
+    // clear workers
+    if (this._workerEndpoint) clearInterval(this._workerEndpoint)
+
+    // stop interactors
+    if (this.reverse) this.reverse.stop()
+    if (this.push) this.push.stop()
+
+    if (this._ipm2) this._ipm2.disconnect()
+    if (this.watchDog) this.watchDog.stop()
+    // stop transport
+    if (this.transport) this.transport.disconnect()
+
+    if (!err) {
+      try {
+        fs.unlinkSync(cst.INTERACTOR_RPC_PORT)
+        fs.unlinkSync(cst.INTERACTOR_PID_PATH)
+      } catch (err) {}
+    }
+
+    if (!this._rpc || !this._rpc.sock) {
+      return process.exit(cst.ERROR_EXIT)
+    }
+
+    if (typeof cb === 'function') {
+      cb()
+    }
+
+    setTimeout(() => {
+      this._rpc.sock.close(() => {
+        log('RPC server closed')
+        process.exit(err ? cst.ERROR_EXIT : cst.SUCCESS_EXIT)
+      })
+    }, 10)
+  }
+
+  /**
+   * Start a RPC server and expose it throught a socket file
+   */
+  startRPC (opts) {
+    log('Launching Interactor RPC server (bind to %s)', cst.INTERACTOR_RPC_PORT)
+    const rep = axon.socket('rep')
+    const rpcServer = new rpc.Server(rep)
+    const self = this
+    rep.bind(cst.INTERACTOR_RPC_PORT)
+
+    rpcServer.expose({
+      kill: function (cb) {
+        log('Shutdown request received via RPC')
+        return self.exit(null, cb)
+      },
+      getInfos: function (cb) {
+        if (self.opts && self.DAEMON_ACTIVE === true) {
+          return cb(null, {
+            machine_name: self.opts.MACHINE_NAME,
+            public_key: self.opts.PUBLIC_KEY,
+            secret_key: self.opts.SECRET_KEY,
+            remote_host: self.km_data.endpoints.web,
+            connected: self.transport.isConnected(),
+            transporters: self.transport.getActiveTransporters(),
+            socket_path: cst.INTERACTOR_RPC_PORT,
+            pm2_home_monitored: cst.PM2_HOME
+          })
+        } else {
+          return cb(null)
+        }
+      }
+    })
+    return rpcServer
+  }
+
+  /**
+   * Handle specific signals to launch memory / cpu profiling
+   * if available in node
+   */
+  _internalDebugger () {
+    // inspector isn't available under node 8
+    if (semver.satisfies(process.version, '<8')) return
+
+    const inspector = require('inspector')
+    const state = {
+      heap: false,
+      cpu: false,
+      session: null
+    }
+    const commands = {
+      heap: {
+        start: 'HeapProfiler.startSampling',
+        stop: 'HeapProfiler.stopSampling'
+      },
+      cpu: {
+        start: 'Profiler.start',
+        stop: 'Profiler.stop'
+      }
+    }
+
+    const handleSignal = type => {
+      return _ => {
+        if (state.session === null) {
+          state.session = new inspector.Session()
+          state.session.connect()
+        }
+
+        const isAlreadyEnabled = state[type]
+        const debuggerCommands = commands[type]
+        const profilerDomain = type === 'cpu' ? 'Profiler' : 'HeapProfiler'
+        const fileExt = type === 'heap' ? '.heapprofile' : '.cpuprofile'
+
+        if (isAlreadyEnabled) {
+          // stopping the profiling and writting it to disk if its running
+          console.log(`[DEBUG] Stopping ${type.toUpperCase()} Profiling`)
+          state.session.post(debuggerCommands.stop, (err, data) => {
+            const profile = data.profile
+            if (err) return console.error(err)
+            const randomId = Math.random().toString(36)
+            const profilePath = path.resolve(os.tmpdir(), `${type}-${randomId}${fileExt}`)
+
+            fs.writeFileSync(profilePath, JSON.stringify(profile))
+            console.log(`[DEBUG] Writing file in ${profilePath}`)
+            state[type] = false
+            state.session.post(`${profilerDomain}.disable`)
+          })
+        } else {
+          // start the profiling otherwise
+          console.log(`[DEBUG] Starting ${type.toUpperCase()} Profiling`)
+          state.session.post(`${profilerDomain}.enable`, _ => {
+            state.session.post(debuggerCommands.start)
+            state[type] = true
+          })
+        }
+      }
+    }
+
+    // use hook
+    process.on('SIGUSR1', handleSignal('cpu'))
+    process.on('SIGUSR2', handleSignal('heap'))
+  }
+
+  /**
+   * Retrieve metadata about the system
+   */
+  getSystemMetadata () {
+    return {
+      MACHINE_NAME: this.opts.MACHINE_NAME,
+      PUBLIC_KEY: this.opts.PUBLIC_KEY,
+      RECYCLE: this.opts.RECYCLE || false,
+      PM2_VERSION: process.env.PM2_VERSION,
+      MEMORY: os.totalmem() / 1000 / 1000,
+      HOSTNAME: os.hostname(),
+      CPUS: os.cpus()
+    }
+  }
+
+  /**
+   * Ping root url to retrieve node info
+   * @private
+   * @param {Function} cb invoked with <Error, Object> where Object is the response sended by the server
+   */
+  _pingRoot (cb) {
+    const data = this.getSystemMetadata()
+
+    this.httpClient.open({
+      url: this.opts.ROOT_URL + '/api/node/verifyPM2',
+      method: 'POST',
+      data: {
+        public_id: this.opts.PUBLIC_KEY,
+        private_id: this.opts.SECRET_KEY,
+        data: data
+      },
+      headers: {
+        'User-Agent': `PM2 Agent v${pkg.version}`
+      }
+    }, cb)
+  }
+
+  /**
+   * Ping root to verify retrieve and connect to the km endpoint
+   * @private
+   * @param {Function} cb invoked with <Error, Boolean>
+   */
+  _verifyEndpoint (cb) {
+    if (typeof cb !== 'function') cb = function () {}
+
+    this._pingRoot((err, data) => {
+      if (err) {
+        log('Got an a error on ping root', err)
+        return cb(err)
+      }
+
+      this.km_data = data
+
+      // Verify data integrity
+      if (data.disabled === true || data.pending === true) {
+        log('Interactor is disabled by admins')
+        return cb(new Error('Connection refused, you might have hit the limit of agents you can connect (send email at contact@keymetrics.io for more infos)'))
+      }
+      if (data.active === false) {
+        log('Interactor not active: %s', data.msg || 'no message')
+        return cb(null, data)
+      }
+      if (!data.endpoints) {
+        return cb(new Error(`Endpoints field not present (${JSON.stringify(data)})`))
+      }
+
+      this.DAEMON_ACTIVE = true
+      this.transport.connect(data.endpoints, cb)
+    })
+  }
+
+  /**
+   * Retrieve configuration from environnement
+   */
+  retrieveConf () {
+    let opts = {}
+
+    opts.MACHINE_NAME = process.env.PM2_MACHINE_NAME
+    opts.PUBLIC_KEY = process.env.PM2_PUBLIC_KEY
+    opts.PM2_BINARY_PATH = process.env.PM2_BINARY_PATH
+    opts.SECRET_KEY = process.env.PM2_SECRET_KEY
+    opts.RECYCLE = process.env.KM_RECYCLE ? JSON.parse(process.env.KM_RECYCLE) : false
+    opts.PM2_VERSION = process.env.PM2_VERSION || '0.0.0'
+    opts.AGENT_TRANSPORT_WEBSOCKET = process.env.AGENT_TRANSPORT_WEBSOCKET
+    opts.internal_ip = Utility.network.v4
+
+    opts.PM2_REMOTE_METHOD_ALLOWED = [
+      'restart',
+      'reload',
+      'reset',
+      'scale',
+      'startLogging',
+      'stopLogging',
+      'ping',
+      'launchSysMonitoring',
+      'deepUpdate'
+    ]
+
+    if (!opts.MACHINE_NAME) {
+      console.error('You must provide a PM2_MACHINE_NAME environment variable')
+      process.exit(cst.ERROR_EXIT)
+    } else if (!opts.PUBLIC_KEY) {
+      console.error('You must provide a PM2_PUBLIC_KEY environment variable')
+      process.exit(cst.ERROR_EXIT)
+    } else if (!opts.SECRET_KEY) {
+      console.error('You must provide a PM2_SECRET_KEY environment variable')
+      process.exit(cst.ERROR_EXIT)
+    }
+    return opts
+  }
+
+  /**
+   * Ping root url to retrieve node info
+   * @private
+   * @param {Function} cb invoked with <Error> [optional]
+   */
+  start (cb) {
+    let retries = 0
+    this._rpc = this.startRPC()
+    this.opts.ROOT_URL = cst.KEYMETRICS_ROOT_URL
+
+    const verifyEndpointCallback = (err, result) => {
+      if (err) {
+        log('Error while trying to retrieve endpoints : ' + (err.message || err))
+        if (retries++ < 30 && process.env.NODE_ENV !== 'test') {
+          log('Retrying to retrieve endpoints...')
+          return setTimeout(_ => {
+            return this._verifyEndpoint(verifyEndpointCallback)
+          }, 200 * retries)
+        }
+        this.sendToParent({ error: true, msg: err.message || err })
+        return this.exit(new Error('Error retrieving endpoints'))
+      }
+      if (result === false) {
+        log('False returned while trying to retrieve endpoints')
+        return this.exit(new Error('Error retrieving endpoints'))
+      }
+
+      // send data over IPC for CLI feedback
+      this.sendToParent({
+        error: false,
+        km_data: this.km_data,
+        online: true,
+        pid: process.pid,
+        machine_name: this.opts.MACHINE_NAME,
+        public_key: this.opts.PUBLIC_KEY,
+        secret_key: this.opts.SECRET_KEY,
+        reverse_interaction: this.opts.REVERSE_INTERACT
+      })
+
+      if (result && typeof result === 'object' &&
+          result.error === true && result.active === false) {
+        log(`Error when connecting: ${result.msg}`)
+        return this.exit(new Error(`Error when connecting: ${result.msg}`))
+      }
+
+      // start workers
+      this._workerEndpoint = setInterval(this._verifyEndpoint.bind(this, (err, result) => {
+        if (err) return
+        // We need to exit agent if bucket is disabled (trialing)
+        if (result && typeof result === 'object' && result.error === true && result.active === false) {
+          log(`Error when connecting: ${result.msg}, disconnecting transporters`)
+          return this.transport.disconnect()
+        }
+      }), 60000)
+      // start interactors
+      this.watchDog = WatchDog
+
+      setTimeout(() => {
+        log('>> PM2 Watchdog started')
+        this.watchDog.start({
+          pm2_binary_path: this.opts.PM2_BINARY_PATH,
+          conf: {
+            ipm2: this.getPM2Client()
+          }
+        })
+      }, 30 * 1000)
+
+      this.push = new PushInteractor(this.opts, this.getPM2Client(), this.transport)
+      this.reverse = new ReverseInteractor(this.opts, this.getPM2Client(), this.transport)
+      this.push.start()
+      this.reverse.start()
+      log('Interactor daemon started')
+      if (cb) {
+        setTimeout(cb, 20)
+      }
+    }
+    return this._verifyEndpoint(verifyEndpointCallback)
+  }
+}
+
+// If its the entry file launch the daemon
+// otherwise we just required it to use a function
+if (require.main === module) {
+  const d = domain.create()
+  let daemon = null
+
+  d.on('error', function (err) {
+    console.error('-- FATAL EXCEPTION happened --')
+    console.error(new Date())
+    console.error(err.stack)
+    console.log('Re-initiating Agent')
+
+    InteractorClient.getOrSetConf(cst, null, (err, infos) => {
+      if (err || !infos) {
+        if (err) {
+          console.error('[PM2 Agent] Failed to rescue agent :')
+          console.error(err || new Error(`Cannot find configuration to connect to backend`))
+          return process.exit(1)
+        }
+      }
+      console.log(`[PM2 Agent] Using (Public key: ${infos.public_key}) (Private key: ${infos.secret_key}) (Info node: ${infos.info_node})`)
+
+      // Exit anyway the errored agent
+      var timeout = setTimeout(_ => {
+        console.error('Daemonization of failsafe agent did not worked')
+        daemon.exit(err)
+      }, 2000)
+
+      InteractorClient.daemonize(cst, infos, (err) => {
+        if (err) {
+          log('[PM2 Agent] Failed to rescue agent :')
+          log(err)
+        } else {
+          log(`Succesfully launched new agent`)
+        }
+        clearTimeout(timeout)
+        daemon.exit(err)
+      })
+    })
+  })
+
+  d.run(_ => {
+    daemon = new InteractorDaemon()
+
+    process.title = `PM2 Agent v${pkg.version}: (${cst.PM2_HOME})`
+
+    log('[PM2 Agent] Launching agent')
+    daemon.start()
+  })
+}

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

@@ -0,0 +1,112 @@
+'use strict'
+
+const axon = require('pm2-axon')
+const cst = require('../constants.js')
+const rpc = require('pm2-axon-rpc')
+const log = require('debug')('interactor:pm2:client')
+const EventEmitter = require('events').EventEmitter
+const PM2Interface = require('./PM2Interface')
+
+/**
+ * PM2 API Wrapper used to setup connection with the daemon
+ * @param {Object} opts options
+ * @param {String} opts.sub_port socket file of the PM2 bus [optionnal]
+ * @param {String} opts.rpc_port socket file of the PM2 RPC server [optionnal]
+ */
+module.exports = class PM2Client extends EventEmitter {
+  constructor (opts) {
+    super()
+    const subSocket = (opts && opts.sub_port) || cst.DAEMON_PUB_PORT
+    const rpcSocket = (opts && opts.rpc_port) || cst.DAEMON_RPC_PORT
+
+    const sub = axon.socket('sub-emitter')
+    this.sub_sock = sub.connect(subSocket)
+    this.bus = sub
+
+    const req = axon.socket('req')
+    this.rpc_sock = req.connect(rpcSocket)
+    this.rpc_client = new rpc.Client(req)
+
+    this.rpc = {}
+
+    this.rpc_sock.on('connect', _ => {
+      log('PM2 API Wrapper connected to PM2 Daemon via RPC')
+      this.generateMethods(_ => {
+        this.pm2Interface = new PM2Interface(this.rpc)
+        this.emit('ready')
+      })
+    })
+
+    this.rpc_sock.on('close', _ => {
+      log('pm2 rpc closed')
+      this.emit('closed')
+    })
+
+    this.rpc_sock.on('reconnect attempt', _ => {
+      log('pm2 rpc reconnecting')
+      this.emit('reconnecting')
+    })
+
+    this.sub_sock.on('connect', _ => {
+      log('bus ready')
+      this.emit('bus:ready')
+    })
+
+    this.sub_sock.on('close', _ => {
+      log('bus closed')
+      this.emit('bus:closed')
+    })
+
+    this.sub_sock.on('reconnect attempt', _ => {
+      log('bus reconnecting')
+      this.emit('bus:reconnecting')
+    })
+  }
+
+  /**
+   * Disconnect socket connections. This will allow Node to exit automatically.
+   * Further calls to PM2 from this object will throw an error.
+   */
+  disconnect () {
+    this.sub_sock.close()
+    this.rpc_sock.close()
+  }
+
+  /**
+   * Generate method by requesting exposed methods by PM2
+   * You can now control/interact with PM2
+   */
+  generateMethods (cb) {
+    log('Requesting and generating RPC methods')
+    this.rpc_client.methods((err, methods) => {
+      if (err) return cb(err)
+      Object.keys(methods).forEach((key) => {
+        let method = methods[key]
+
+        log('+-- Creating %s method', method.name);
+
+        ((name) => {
+          const self = this
+          this.rpc[name] = function () {
+            let args = Array.prototype.slice.call(arguments)
+            args.unshift(name)
+            self.rpc_client.call.apply(self.rpc_client, args)
+          }
+        })(method.name)
+      })
+      return cb()
+    })
+  }
+
+  remote (method, parameters, cb) {
+    log('remote send %s', method, parameters)
+    if (typeof this.pm2Interface[method] === 'undefined') {
+      return cb(new Error('Deprecated or invalid method'))
+    }
+    this.pm2Interface[method](parameters, cb)
+  }
+
+  msgProcess (data, cb) {
+    this.rpc.msgProcess(data, cb)
+  }
+}