libp2p 0.36.2 → 0.37.0-b09eb8f

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 }

package/src/dialer/dial-request.js

@@ -1,103 +0,0 @@
-'use strict'
-
-const errCode = require('err-code')
-const { anySignal } = require('any-signal')
-// @ts-ignore p-fifo does not export types
-const FIFO = require('p-fifo')
-const pAny = require('p-any')
-// @ts-expect-error setMaxListeners is missing from the types
-const { setMaxListeners } = require('events')
-const { codes } = require('../errors')
-
-/**
- * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
- * @typedef {import('./')} Dialer
- * @typedef {import('multiaddr').Multiaddr} Multiaddr
- */
-
-/**
- * @typedef {Object} DialOptions
- * @property {AbortSignal} signal
- *
- * @typedef {Object} DialRequestOptions
- * @property {Multiaddr[]} addrs
- * @property {(m: Multiaddr, options: DialOptions) => Promise<Connection>} dialAction
- * @property {Dialer} dialer
- */
-
-class DialRequest {
-  /**
-   * Manages running the `dialAction` on multiple provided `addrs` in parallel
-   * up to a maximum determined by the number of tokens returned
-   * from `dialer.getTokens`. Once a DialRequest is created, it can be
-   * started using `DialRequest.run(options)`. Once a single dial has succeeded,
-   * all other dials in the request will be cancelled.
-   *
-   * @class
-   * @param {DialRequestOptions} options
-   */
-  constructor ({
-    addrs,
-    dialAction,
-    dialer
-  }) {
-    this.addrs = addrs
-    this.dialer = dialer
-    this.dialAction = dialAction
-  }
-
-  /**
-   * @async
-   * @param {object} [options]
-   * @param {AbortSignal} [options.signal] - An AbortController signal
-   * @returns {Promise<Connection>}
-   */
-  async run (options = {}) {
-    const tokens = this.dialer.getTokens(this.addrs.length)
-    // If no tokens are available, throw
-    if (tokens.length < 1) {
-      throw errCode(new Error('No dial tokens available'), codes.ERR_NO_DIAL_TOKENS)
-    }
-
-    const tokenHolder = new FIFO()
-    tokens.forEach(token => tokenHolder.push(token))
-    const dialAbortControllers = this.addrs.map(() => {
-      const controller = new AbortController()
-      try {
-        // fails on node < 15.4
-        setMaxListeners && setMaxListeners(Infinity, controller.signal)
-      } catch {}
-
-      return controller
-    })
-    let completedDials = 0
-
-    try {
-      return await pAny(this.addrs.map(async (addr, i) => {
-        const token = await tokenHolder.shift() // get token
-        let conn
-        try {
-          const signal = dialAbortControllers[i].signal
-          conn = await this.dialAction(addr, { ...options, signal: options.signal ? anySignal([signal, options.signal]) : signal })
-          // Remove the successful AbortController so it is not aborted
-          dialAbortControllers.splice(i, 1)
-        } finally {
-          completedDials++
-          // If we have more or equal dials remaining than tokens, recycle the token, otherwise release it
-          if (this.addrs.length - completedDials >= tokens.length) {
-            tokenHolder.push(token)
-          } else {
-            this.dialer.releaseToken(tokens.splice(tokens.indexOf(token), 1)[0])
-          }
-        }
-
-        return conn
-      }))
-    } finally {
-      dialAbortControllers.map(c => c.abort()) // success/failure happened, abort everything else
-      tokens.forEach(token => this.dialer.releaseToken(token)) // release tokens back to the dialer
-    }
-  }
-}
-
-module.exports = DialRequest