libp2p 0.36.0 → 0.36.2-1473044

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 }