libp2p 0.36.0 → 0.36.2-199395d

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
-  }
-}

package/src/content-routing/index.js

@@ -1,163 +0,0 @@
-'use strict'
-
-const errCode = require('err-code')
-const { messages, codes } = require('../errors')
-const {
-  storeAddresses,
-  uniquePeers,
-  requirePeers,
-  maybeLimitSource
-} = require('./utils')
-const drain = require('it-drain')
-const merge = require('it-merge')
-const { pipe } = require('it-pipe')
-const { DHTContentRouting } = require('../dht/dht-content-routing')
-
-/**
- * @typedef {import('peer-id')} PeerId
- * @typedef {import('multiaddr').Multiaddr} Multiaddr
- * @typedef {import('multiformats/cid').CID} CID
- * @typedef {import('libp2p-interfaces/src/content-routing/types').ContentRouting} ContentRoutingModule
- */
-
-/**
- * @typedef {Object} GetData
- * @property {PeerId} from
- * @property {Uint8Array} val
- */
-
-class ContentRouting {
-  /**
-   * @class
-   * @param {import('..')} libp2p
-   */
-  constructor (libp2p) {
-    this.libp2p = libp2p
-    /** @type {ContentRoutingModule[]} */
-    this.routers = libp2p._modules.contentRouting || []
-    this.dht = libp2p._dht
-
-    // If we have the dht, add it to the available content routers
-    if (this.dht && libp2p._config.dht.enabled) {
-      this.routers.push(new DHTContentRouting(this.dht))
-    }
-  }
-
-  /**
-   * Iterates over all content routers in parallel to find providers of the given key.
-   *
-   * @param {CID} key - The CID key of the content to find
-   * @param {object} [options]
-   * @param {number} [options.timeout] - How long the query should run
-   * @param {number} [options.maxNumProviders] - maximum number of providers to find
-   * @returns {AsyncIterable<{ id: PeerId, multiaddrs: Multiaddr[] }>}
-   */
-  async * findProviders (key, options = {}) {
-    if (!this.routers.length) {
-      throw errCode(new Error('No content this.routers available'), codes.ERR_NO_ROUTERS_AVAILABLE)
-    }
-
-    yield * pipe(
-      merge(
-        ...this.routers.map(router => router.findProviders(key, options))
-      ),
-      (source) => storeAddresses(source, this.libp2p.peerStore),
-      (source) => uniquePeers(source),
-      (source) => maybeLimitSource(source, options.maxNumProviders),
-      (source) => requirePeers(source)
-    )
-  }
-
-  /**
-   * Iterates over all content routers in parallel to notify it is
-   * a provider of the given key.
-   *
-   * @param {CID} key - The CID key of the content to find
-   * @returns {Promise<void>}
-   */
-  async provide (key) {
-    if (!this.routers.length) {
-      throw errCode(new Error('No content routers available'), codes.ERR_NO_ROUTERS_AVAILABLE)
-    }
-
-    await Promise.all(this.routers.map((router) => router.provide(key)))
-  }
-
-  /**
-   * Store the given key/value pair in the DHT.
-   *
-   * @param {Uint8Array} key
-   * @param {Uint8Array} value
-   * @param {Object} [options] - put options
-   * @param {number} [options.minPeers] - minimum number of peers required to successfully put
-   * @returns {Promise<void>}
-   */
-  async put (key, value, options) {
-    if (!this.libp2p.isStarted() || !this.dht.isStarted) {
-      throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
-    }
-
-    await drain(this.dht.put(key, value, options))
-  }
-
-  /**
-   * Get the value to the given key.
-   * Times out after 1 minute by default.
-   *
-   * @param {Uint8Array} key
-   * @param {Object} [options] - get options
-   * @param {number} [options.timeout] - optional timeout (default: 60000)
-   * @returns {Promise<GetData>}
-   */
-  async get (key, options) {
-    if (!this.libp2p.isStarted() || !this.dht.isStarted) {
-      throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
-    }
-
-    for await (const event of this.dht.get(key, options)) {
-      if (event.name === 'VALUE') {
-        return { from: event.peerId, val: event.value }
-      }
-    }
-
-    throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
-  }
-
-  /**
-   * Get the `n` values to the given key without sorting.
-   *
-   * @param {Uint8Array} key
-   * @param {number} nVals
-   * @param {Object} [options] - get options
-   * @param {number} [options.timeout] - optional timeout (default: 60000)
-   */
-  async * getMany (key, nVals, options) { // eslint-disable-line require-await
-    if (!this.libp2p.isStarted() || !this.dht.isStarted) {
-      throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
-    }
-
-    if (!nVals) {
-      return
-    }
-
-    let gotValues = 0
-
-    for await (const event of this.dht.get(key, options)) {
-      if (event.name === 'VALUE') {
-        yield { from: event.peerId, val: event.value }
-
-        gotValues++
-
-        if (gotValues === nVals) {
-          break
-        }
-      }
-    }
-
-    if (gotValues === 0) {
-      throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
-    }
-  }
-}
-
-module.exports = ContentRouting

package/src/content-routing/utils.js

@@ -1,89 +0,0 @@
-'use strict'
-
-const errCode = require('err-code')
-const filter = require('it-filter')
-const map = require('it-map')
-const take = require('it-take')
-
-/**
- * @typedef {import('peer-id')} PeerId
- * @typedef {import('multiaddr').Multiaddr} Multiaddr
- */
-
-/**
- * Store the multiaddrs from every peer in the passed peer store
- *
- * @param {AsyncIterable<{ id: PeerId, multiaddrs: Multiaddr[] }>} source
- * @param {import('../peer-store/types').PeerStore} peerStore
- */
-async function * storeAddresses (source, peerStore) {
-  yield * map(source, async (peer) => {
-    // ensure we have the addresses for a given peer
-    await peerStore.addressBook.add(peer.id, peer.multiaddrs)
-
-    return peer
-  })
-}
-
-/**
- * Filter peers by unique peer id
- *
- * @param {AsyncIterable<{ id: PeerId, multiaddrs: Multiaddr[] }>} source
- */
-function uniquePeers (source) {
-  /** @type Set<string> */
-  const seen = new Set()
-
-  return filter(source, (peer) => {
-    // dedupe by peer id
-    if (seen.has(peer.id.toString())) {
-      return false
-    }
-
-    seen.add(peer.id.toString())
-
-    return true
-  })
-}
-
-/**
- * Require at least `min` peers to be yielded from `source`
- *
- * @param {AsyncIterable<{ id: PeerId, multiaddrs: Multiaddr[] }>} source
- * @param {number} min
- */
-async function * requirePeers (source, min = 1) {
-  let seen = 0
-
-  for await (const peer of source) {
-    seen++
-
-    yield peer
-  }
-
-  if (seen < min) {
-    throw errCode(new Error('not found'), 'NOT_FOUND')
-  }
-}
-
-/**
- * If `max` is passed, only take that number of peers from the source
- * otherwise take all the peers
- *
- * @param {AsyncIterable<{ id: PeerId, multiaddrs: Multiaddr[] }>} source
- * @param {number} [max]
- */
-function maybeLimitSource (source, max) {
-  if (max) {
-    return take(source, max)
-  }
-
-  return source
-}
-
-module.exports = {
-  storeAddresses,
-  uniquePeers,
-  requirePeers,
-  maybeLimitSource
-}

package/src/dht/dht-content-routing.js

@@ -1,44 +0,0 @@
-'use strict'
-
-const drain = require('it-drain')
-
-/**
- * @typedef {import('peer-id')} PeerId
- * @typedef {import('libp2p-interfaces/src/content-routing/types').ContentRouting} ContentRoutingModule
- * @typedef {import('multiformats/cid').CID} CID
- */
-
-/**
- * Wrapper class to convert events into returned values
- *
- * @implements {ContentRoutingModule}
- */
-class DHTContentRouting {
-  /**
-   * @param {import('libp2p-kad-dht').DHT} dht
-   */
-  constructor (dht) {
-    this._dht = dht
-  }
-
-  /**
-   * @param {CID} cid
-   */
-  async provide (cid) {
-    await drain(this._dht.provide(cid))
-  }
-
-  /**
-   * @param {CID} cid
-   * @param {*} options
-   */
-  async * findProviders (cid, options) {
-    for await (const event of this._dht.findProviders(cid, options)) {
-      if (event.name === 'PROVIDER') {
-        yield * event.providers
-      }
-    }
-  }
-}
-
-module.exports = { DHTContentRouting }

package/src/dht/dht-peer-routing.js

@@ -1,51 +0,0 @@
-'use strict'
-
-const errCode = require('err-code')
-const { messages, codes } = require('../errors')
-
-/**
- * @typedef {import('peer-id')} PeerId
- * @typedef {import('libp2p-interfaces/src/peer-routing/types').PeerRouting} PeerRoutingModule
- */
-
-/**
- * Wrapper class to convert events into returned values
- *
- * @implements {PeerRoutingModule}
- */
-class DHTPeerRouting {
-  /**
-   * @param {import('libp2p-kad-dht').DHT} dht
-   */
-  constructor (dht) {
-    this._dht = dht
-  }
-
-  /**
-   * @param {PeerId} peerId
-   * @param {any} options
-   */
-  async findPeer (peerId, options = {}) {
-    for await (const event of this._dht.findPeer(peerId, options)) {
-      if (event.name === 'FINAL_PEER') {
-        return event.peer
-      }
-    }
-
-    throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
-  }
-
-  /**
-   * @param {Uint8Array} key
-   * @param {any} options
-   */
-  async * getClosestPeers (key, options = {}) {
-    for await (const event of this._dht.getClosestPeers(key, options)) {
-      if (event.name === 'PEER_RESPONSE') {
-        yield * event.closer
-      }
-    }
-  }
-}
-
-module.exports = { DHTPeerRouting }