libp2p 0.36.2 → 0.37.0

package/src/connection-manager/index.js

@@ -1,374 +0,0 @@
-'use strict'
-
-const debug = require('debug')
-const log = Object.assign(debug('libp2p:connection-manager'), {
-  error: debug('libp2p:connection-manager:err')
-})
-
-const errcode = require('err-code')
-const mergeOptions = require('merge-options')
-const LatencyMonitor = require('./latency-monitor')
-// @ts-ignore retimer does not have types
-const retimer = require('retimer')
-
-const { EventEmitter } = require('events')
-const trackedMap = require('../metrics/tracked-map')
-const PeerId = require('peer-id')
-
-const {
-  codes: { ERR_INVALID_PARAMETERS }
-} = require('../errors')
-
-const defaultOptions = {
-  maxConnections: Infinity,
-  minConnections: 0,
-  maxData: Infinity,
-  maxSentData: Infinity,
-  maxReceivedData: Infinity,
-  maxEventLoopDelay: Infinity,
-  pollInterval: 2000,
-  autoDialInterval: 10000,
-  movingAverageInterval: 60000,
-  defaultPeerValue: 1
-}
-
-const METRICS_COMPONENT = 'connection-manager'
-const METRICS_PEER_CONNECTIONS = 'peer-connections'
-const METRICS_PEER_VALUES = 'peer-values'
-
-/**
- * @typedef {import('../')} Libp2p
- * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
- */
-
-/**
- * @typedef {Object} ConnectionManagerOptions
- * @property {number} [maxConnections = Infinity] - The maximum number of connections allowed.
- * @property {number} [minConnections = 0] - The minimum number of connections to avoid pruning.
- * @property {number} [maxData = Infinity] - The max data (in and out), per average interval to allow.
- * @property {number} [maxSentData = Infinity] - The max outgoing data, per average interval to allow.
- * @property {number} [maxReceivedData = Infinity] - The max incoming data, per average interval to allow.
- * @property {number} [maxEventLoopDelay = Infinity] - The upper limit the event loop can take to run.
- * @property {number} [pollInterval = 2000] - How often, in milliseconds, metrics and latency should be checked.
- * @property {number} [movingAverageInterval = 60000] - How often, in milliseconds, to compute averages.
- * @property {number} [defaultPeerValue = 1] - The value of the peer.
- * @property {boolean} [autoDial = true] - Should preemptively guarantee connections are above the low watermark.
- * @property {number} [autoDialInterval = 10000] - How often, in milliseconds, it should preemptively guarantee connections are above the low watermark.
- */
-
-/**
- *
- * @fires ConnectionManager#peer:connect Emitted when a new peer is connected.
- * @fires ConnectionManager#peer:disconnect Emitted when a peer is disconnected.
- */
-class ConnectionManager extends EventEmitter {
-  /**
-   * Responsible for managing known connections.
-   *
-   * @class
-   * @param {Libp2p} libp2p
-   * @param {ConnectionManagerOptions} options
-   */
-  constructor (libp2p, options = {}) {
-    super()
-
-    this._libp2p = libp2p
-    this._peerId = libp2p.peerId.toB58String()
-
-    this._options = mergeOptions.call({ ignoreUndefined: true }, defaultOptions, options)
-    if (this._options.maxConnections < this._options.minConnections) {
-      throw errcode(new Error('Connection Manager maxConnections must be greater than minConnections'), ERR_INVALID_PARAMETERS)
-    }
-
-    log('options: %j', this._options)
-
-    /**
-     * Map of peer identifiers to their peer value for pruning connections.
-     *
-     * @type {Map<string, number>}
-     */
-    this._peerValues = trackedMap({
-      component: METRICS_COMPONENT,
-      metric: METRICS_PEER_VALUES,
-      metrics: this._libp2p.metrics
-    })
-
-    /**
-     * Map of connections per peer
-     *
-     * @type {Map<string, Connection[]>}
-     */
-    this.connections = trackedMap({
-      component: METRICS_COMPONENT,
-      metric: METRICS_PEER_CONNECTIONS,
-      metrics: this._libp2p.metrics
-    })
-
-    this._started = false
-    this._timer = null
-    this._checkMetrics = this._checkMetrics.bind(this)
-
-    this._latencyMonitor = new LatencyMonitor({
-      latencyCheckIntervalMs: this._options.pollInterval,
-      dataEmitIntervalMs: this._options.pollInterval
-    })
-
-    // This emitter gets listened to a lot
-    this.setMaxListeners(Infinity)
-  }
-
-  /**
-   * Get current number of open connections.
-   */
-  get size () {
-    return Array.from(this.connections.values())
-      .reduce((accumulator, value) => accumulator + value.length, 0)
-  }
-
-  /**
-   * Starts the Connection Manager. If Metrics are not enabled on libp2p
-   * only event loop and connection limits will be monitored.
-   */
-  start () {
-    if (this._libp2p.metrics) {
-      this._timer = this._timer || retimer(this._checkMetrics, this._options.pollInterval)
-    }
-
-    // latency monitor
-    this._latencyMonitor.start()
-    this._onLatencyMeasure = this._onLatencyMeasure.bind(this)
-    this._latencyMonitor.on('data', this._onLatencyMeasure)
-
-    this._started = true
-    log('started')
-  }
-
-  /**
-   * Stops the Connection Manager
-   *
-   * @async
-   */
-  async stop () {
-    this._timer && this._timer.clear()
-
-    this._latencyMonitor.removeListener('data', this._onLatencyMeasure)
-    this._latencyMonitor.stop()
-
-    this._started = false
-    await this._close()
-    log('stopped')
-  }
-
-  /**
-   * Cleans up the connections
-   *
-   * @async
-   */
-  async _close () {
-    // Close all connections we're tracking
-    const tasks = []
-    for (const connectionList of this.connections.values()) {
-      for (const connection of connectionList) {
-        tasks.push(connection.close())
-      }
-    }
-
-    await Promise.all(tasks)
-    this.connections.clear()
-  }
-
-  /**
-   * Sets the value of the given peer. Peers with lower values
-   * will be disconnected first.
-   *
-   * @param {PeerId} peerId
-   * @param {number} value - A number between 0 and 1
-   * @returns {void}
-   */
-  setPeerValue (peerId, value) {
-    if (value < 0 || value > 1) {
-      throw new Error('value should be a number between 0 and 1')
-    }
-    this._peerValues.set(peerId.toB58String(), value)
-  }
-
-  /**
-   * Checks the libp2p metrics to determine if any values have exceeded
-   * the configured maximums.
-   *
-   * @private
-   */
-  async _checkMetrics () {
-    if (this._libp2p.metrics) {
-      try {
-        const movingAverages = this._libp2p.metrics.global.movingAverages
-        // @ts-ignore moving averages object types
-        const received = movingAverages.dataReceived[this._options.movingAverageInterval].movingAverage()
-        await this._checkMaxLimit('maxReceivedData', received)
-        // @ts-ignore moving averages object types
-        const sent = movingAverages.dataSent[this._options.movingAverageInterval].movingAverage()
-        await this._checkMaxLimit('maxSentData', sent)
-        const total = received + sent
-        await this._checkMaxLimit('maxData', total)
-        log('metrics update', total)
-      } finally {
-        this._timer = retimer(this._checkMetrics, this._options.pollInterval)
-      }
-    }
-  }
-
-  /**
-   * Tracks the incoming connection and check the connection limit
-   *
-   * @param {Connection} connection
-   */
-  async onConnect (connection) {
-    if (!this._started) {
-      // This can happen when we are in the process of shutting down the node
-      await connection.close()
-      return
-    }
-
-    const peerId = connection.remotePeer
-    const peerIdStr = peerId.toB58String()
-    const storedConn = this.connections.get(peerIdStr)
-
-    this.emit('peer:connect', connection)
-
-    if (storedConn) {
-      storedConn.push(connection)
-    } else {
-      this.connections.set(peerIdStr, [connection])
-    }
-
-    await this._libp2p.peerStore.keyBook.set(peerId, peerId.pubKey)
-
-    if (!this._peerValues.has(peerIdStr)) {
-      this._peerValues.set(peerIdStr, this._options.defaultPeerValue)
-    }
-
-    await this._checkMaxLimit('maxConnections', this.size)
-  }
-
-  /**
-   * Removes the connection from tracking
-   *
-   * @param {Connection} connection
-   * @returns {void}
-   */
-  onDisconnect (connection) {
-    if (!this._started) {
-      // This can happen when we are in the process of shutting down the node
-      return
-    }
-
-    const peerId = connection.remotePeer.toB58String()
-    let storedConn = this.connections.get(peerId)
-
-    if (storedConn && storedConn.length > 1) {
-      storedConn = storedConn.filter((conn) => conn.id !== connection.id)
-      this.connections.set(peerId, storedConn)
-    } else if (storedConn) {
-      this.connections.delete(peerId)
-      this._peerValues.delete(connection.remotePeer.toB58String())
-      this.emit('peer:disconnect', connection)
-
-      this._libp2p.metrics && this._libp2p.metrics.onPeerDisconnected(connection.remotePeer)
-    }
-  }
-
-  /**
-   * Get a connection with a peer.
-   *
-   * @param {PeerId} peerId
-   * @returns {Connection|null}
-   */
-  get (peerId) {
-    const connections = this.getAll(peerId)
-    if (connections.length) {
-      return connections[0]
-    }
-    return null
-  }
-
-  /**
-   * Get all open connections with a peer.
-   *
-   * @param {PeerId} peerId
-   * @returns {Connection[]}
-   */
-  getAll (peerId) {
-    if (!PeerId.isPeerId(peerId)) {
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
-    }
-
-    const id = peerId.toB58String()
-    const connections = this.connections.get(id)
-
-    // Return all open connections
-    if (connections) {
-      return connections.filter(connection => connection.stat.status === 'open')
-    }
-    return []
-  }
-
-  /**
-   * If the event loop is slow, maybe close a connection
-   *
-   * @private
-   * @param {*} summary - The LatencyMonitor summary
-   */
-  _onLatencyMeasure (summary) {
-    this._checkMaxLimit('maxEventLoopDelay', summary.avgMs)
-      .catch(err => {
-        log.error(err)
-      })
-  }
-
-  /**
-   * If the `value` of `name` has exceeded its limit, maybe close a connection
-   *
-   * @private
-   * @param {string} name - The name of the field to check limits for
-   * @param {number} value - The current value of the field
-   */
-  async _checkMaxLimit (name, value) {
-    const limit = this._options[name]
-    log('checking limit of %s. current value: %d of %d', name, value, limit)
-    if (value > limit) {
-      log('%s: limit exceeded: %s, %d', this._peerId, name, value)
-      await this._maybeDisconnectOne()
-    }
-  }
-
-  /**
-   * If we have more connections than our maximum, close a connection
-   * to the lowest valued peer.
-   *
-   * @private
-   */
-  async _maybeDisconnectOne () {
-    if (this._options.minConnections < this.connections.size) {
-      const peerValues = Array.from(new Map([...this._peerValues.entries()].sort((a, b) => a[1] - b[1])))
-      log('%s: sorted peer values: %j', this._peerId, peerValues)
-      const disconnectPeer = peerValues[0]
-      if (disconnectPeer) {
-        const peerId = disconnectPeer[0]
-        log('%s: lowest value peer is %s', this._peerId, peerId)
-        log('%s: closing a connection to %j', this._peerId, peerId)
-        for (const connections of this.connections.values()) {
-          if (connections[0].remotePeer.toB58String() === peerId) {
-            connections[0].close().catch(err => {
-              log.error(err)
-            })
-            // TODO: should not need to invoke this manually
-            this.onDisconnect(connections[0])
-            break
-          }
-        }
-      }
-    }
-  }
-}
-
-module.exports = ConnectionManager

package/src/connection-manager/latency-monitor.js

@@ -1,264 +0,0 @@
-// @ts-nocheck
-'use strict'
-
-/**
- * This code is based on `latency-monitor` (https://github.com/mlucool/latency-monitor) by `mlucool` (https://github.com/mlucool), available under Apache License 2.0 (https://github.com/mlucool/latency-monitor/blob/master/LICENSE)
- */
-
-const { EventEmitter } = require('events')
-const VisibilityChangeEmitter = require('./visibility-change-emitter')
-const debug = require('debug')('latency-monitor:LatencyMonitor')
-
-/**
- * @typedef {Object} SummaryObject
- * @property {number} events How many events were called
- * @property {number} minMS What was the min time for a cb to be called
- * @property {number} maxMS What was the max time for a cb to be called
- * @property {number} avgMs What was the average time for a cb to be called
- * @property {number} lengthMs How long this interval was in ms
- *
- * @typedef {Object} LatencyMonitorOptions
- * @property {number} [latencyCheckIntervalMs=500] - How often to add a latency check event (ms)
- * @property {number} [dataEmitIntervalMs=5000] - How often to summarize latency check events. null or 0 disables event firing
- * @property {Function} [asyncTestFn] - What cb-style async function to use
- * @property {number} [latencyRandomPercentage=5] - What percent (+/-) of latencyCheckIntervalMs should we randomly use? This helps avoid alignment to other events.
- */
-
-/**
- * A class to monitor latency of any async function which works in a browser or node. This works by periodically calling
- * the asyncTestFn and timing how long it takes the callback to be called. It can also periodically emit stats about this.
- * This can be disabled and stats can be pulled via setting dataEmitIntervalMs = 0.
- *
- * @extends {EventEmitter}
- *
- * The default implementation is an event loop latency monitor. This works by firing periodic events into the event loop
- * and timing how long it takes to get back.
- *
- * @example
- * const monitor = new LatencyMonitor();
- * monitor.on('data', (summary) => console.log('Event Loop Latency: %O', summary));
- *
- * @example
- * const monitor = new LatencyMonitor({latencyCheckIntervalMs: 1000, dataEmitIntervalMs: 60000, asyncTestFn:ping});
- * monitor.on('data', (summary) => console.log('Ping Pong Latency: %O', summary));
- */
-class LatencyMonitor extends EventEmitter {
-  /**
-   * @class
-   * @param {LatencyMonitorOptions} [options]
-   */
-  constructor ({ latencyCheckIntervalMs, dataEmitIntervalMs, asyncTestFn, latencyRandomPercentage } = {}) {
-    super()
-    const that = this
-
-    // 0 isn't valid here, so its ok to use ||
-    that.latencyCheckIntervalMs = latencyCheckIntervalMs || 500 // 0.5s
-    that.latencyRandomPercentage = latencyRandomPercentage || 10
-    that._latecyCheckMultiply = 2 * (that.latencyRandomPercentage / 100.0) * that.latencyCheckIntervalMs
-    that._latecyCheckSubtract = that._latecyCheckMultiply / 2
-
-    that.dataEmitIntervalMs = (dataEmitIntervalMs === null || dataEmitIntervalMs === 0)
-      ? undefined
-      : dataEmitIntervalMs || 5 * 1000 // 5s
-    debug('latencyCheckIntervalMs: %s dataEmitIntervalMs: %s',
-      that.latencyCheckIntervalMs, that.dataEmitIntervalMs)
-    if (that.dataEmitIntervalMs) {
-      debug('Expecting ~%s events per summary', that.latencyCheckIntervalMs / that.dataEmitIntervalMs)
-    } else {
-      debug('Not emitting summaries')
-    }
-
-    that.asyncTestFn = asyncTestFn // If there is no asyncFn, we measure latency
-  }
-
-  start () {
-    // If process: use high resolution timer
-    if (globalThis.process && globalThis.process.hrtime) { // eslint-disable-line no-undef
-      debug('Using process.hrtime for timing')
-      this.now = globalThis.process.hrtime // eslint-disable-line no-undef
-      this.getDeltaMS = (startTime) => {
-        const hrtime = this.now(startTime)
-        return (hrtime[0] * 1000) + (hrtime[1] / 1000000)
-      }
-      // Let's try for a timer that only monotonically increases
-    } else if (typeof window !== 'undefined' && window.performance && window.performance.now) {
-      debug('Using performance.now for timing')
-      this.now = window.performance.now.bind(window.performance)
-      this.getDeltaMS = (startTime) => Math.round(this.now() - startTime)
-    } else {
-      debug('Using Date.now for timing')
-      this.now = Date.now
-      this.getDeltaMS = (startTime) => this.now() - startTime
-    }
-
-    this._latencyData = this._initLatencyData()
-
-    // We check for isBrowser because of browsers set max rates of timeouts when a page is hidden,
-    // so we fall back to another library
-    // See: http://stackoverflow.com/questions/6032429/chrome-timeouts-interval-suspended-in-background-tabs
-    if (isBrowser()) {
-      this._visibilityChangeEmitter = new VisibilityChangeEmitter()
-
-      this._visibilityChangeEmitter.on('visibilityChange', (pageInFocus) => {
-        if (pageInFocus) {
-          this._startTimers()
-        } else {
-          this._emitSummary()
-          this._stopTimers()
-        }
-      })
-    }
-
-    if (!this._visibilityChangeEmitter || this._visibilityChangeEmitter.isVisible()) {
-      this._startTimers()
-    }
-  }
-
-  stop () {
-    this._stopTimers()
-  }
-
-  /**
-   * Start internal timers
-   *
-   * @private
-   */
-  _startTimers () {
-    // Timer already started, ignore this
-    if (this._checkLatencyID) {
-      return
-    }
-    this._checkLatency()
-    if (this.dataEmitIntervalMs) {
-      this._emitIntervalID = setInterval(() => this._emitSummary(), this.dataEmitIntervalMs)
-      if (typeof this._emitIntervalID.unref === 'function') {
-        this._emitIntervalID.unref() // Doesn't block exit
-      }
-    }
-  }
-
-  /**
-   * Stop internal timers
-   *
-   * @private
-   */
-  _stopTimers () {
-    if (this._checkLatencyID) {
-      clearTimeout(this._checkLatencyID)
-      this._checkLatencyID = undefined
-    }
-    if (this._emitIntervalID) {
-      clearInterval(this._emitIntervalID)
-      this._emitIntervalID = undefined
-    }
-  }
-
-  /**
-   * Emit summary only if there were events. It might not have any events if it was forced via a page hidden/show
-   *
-   * @private
-   */
-  _emitSummary () {
-    const summary = this.getSummary()
-    if (summary.events > 0) {
-      this.emit('data', summary)
-    }
-  }
-
-  /**
-   * Calling this function will end the collection period. If a timing event was already fired and somewhere in the queue,
-   * it will not count for this time period
-   *
-   * @returns {SummaryObject}
-   */
-  getSummary () {
-    // We might want to adjust for the number of expected events
-    // Example: first 1 event it comes back, then such a long blocker that the next emit check comes
-    // Then this fires - looks like no latency!!
-    const latency = {
-      events: this._latencyData.events,
-      minMs: this._latencyData.minMs,
-      maxMs: this._latencyData.maxMs,
-      avgMs: this._latencyData.events
-        ? this._latencyData.totalMs / this._latencyData.events
-        : Number.POSITIVE_INFINITY,
-      lengthMs: this.getDeltaMS(this._latencyData.startTime)
-    }
-    this._latencyData = this._initLatencyData() // Clear
-
-    debug('Summary: %O', latency)
-    return latency
-  }
-
-  /**
-   * Randomly calls an async fn every roughly latencyCheckIntervalMs (plus some randomness). If no async fn is found,
-   * it will simply report on event loop latency.
-   *
-   * @private
-   */
-  _checkLatency () {
-    const that = this
-    // Randomness is needed to avoid alignment by accident to regular things in the event loop
-    const randomness = (Math.random() * that._latecyCheckMultiply) - that._latecyCheckSubtract
-
-    // We use this to ensure that in case some overlap somehow, we don't take the wrong startTime/offset
-    const localData = {
-      deltaOffset: Math.ceil(that.latencyCheckIntervalMs + randomness),
-      startTime: that.now()
-    }
-
-    const cb = () => {
-      // We are already stopped, ignore this datapoint
-      if (!this._checkLatencyID) {
-        return
-      }
-      const deltaMS = that.getDeltaMS(localData.startTime) - localData.deltaOffset
-      that._checkLatency() // Start again ASAP
-
-      // Add the data point. If this gets complex, refactor it
-      that._latencyData.events++
-      that._latencyData.minMs = Math.min(that._latencyData.minMs, deltaMS)
-      that._latencyData.maxMs = Math.max(that._latencyData.maxMs, deltaMS)
-      that._latencyData.totalMs += deltaMS
-      debug('MS: %s Data: %O', deltaMS, that._latencyData)
-    }
-    debug('localData: %O', localData)
-
-    this._checkLatencyID = setTimeout(() => {
-      // This gets rid of including event loop
-      if (that.asyncTestFn) {
-        // Clear timing related things
-        localData.deltaOffset = 0
-        localData.startTime = that.now()
-        that.asyncTestFn(cb)
-      } else {
-        // setTimeout is not more accurate than 1ms, so this will ensure positive numbers. Add 1 to emitted data to remove.
-        // This is not the best, but for now it'll be just fine. This isn't meant to be sub ms accurate.
-        localData.deltaOffset -= 1
-        // If there is no function to test, we mean check latency which is a special case that is really cb => cb()
-        // We avoid that for the few extra function all overheads. Also, we want to keep the timers different
-        cb()
-      }
-    }, localData.deltaOffset)
-
-    if (typeof this._checkLatencyID.unref === 'function') {
-      this._checkLatencyID.unref() // Doesn't block exit
-    }
-  }
-
-  _initLatencyData () {
-    return {
-      startTime: this.now(),
-      minMs: Number.POSITIVE_INFINITY,
-      maxMs: Number.NEGATIVE_INFINITY,
-      events: 0,
-      totalMs: 0
-    }
-  }
-}
-
-function isBrowser () {
-  return typeof window !== 'undefined'
-}
-
-module.exports = LatencyMonitor

package/src/constants.js

@@ -1,18 +0,0 @@
-'use strict'
-
-module.exports = {
-  DIAL_TIMEOUT: 30e3, // How long in ms a dial attempt is allowed to take
-  MAX_PARALLEL_DIALS: 100, // Maximum allowed concurrent dials
-  MAX_PER_PEER_DIALS: 4, // Allowed parallel dials per DialRequest
-  MAX_ADDRS_TO_DIAL: 25, // Maximum number of allowed addresses to attempt to dial
-  METRICS: {
-    computeThrottleMaxQueueSize: 1000,
-    computeThrottleTimeout: 2000,
-    movingAverageIntervals: [
-      60 * 1000, // 1 minute
-      5 * 60 * 1000, // 5 minutes
-      15 * 60 * 1000 // 15 minutes
-    ],
-    maxOldPeersRetention: 50
-  }
-}