libp2p 0.36.0 → 0.36.2-1473044

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

@@ -0,0 +1,43 @@
+import drain from 'it-drain'
+import errCode from 'err-code'
+import type { DHT } from '@libp2p/interfaces/dht'
+import type { ContentRouting } from '@libp2p/interfaces/content-routing'
+import type { CID } from 'multiformats/cid'
+import type { AbortOptions } from '@libp2p/interfaces'
+
+/**
+ * Wrapper class to convert events into returned values
+ */
+export class DHTContentRouting implements ContentRouting {
+  private readonly dht: DHT
+
+  constructor (dht: DHT) {
+    this.dht = dht
+  }
+
+  async provide (cid: CID) {
+    await drain(this.dht.provide(cid))
+  }
+
+  async * findProviders (cid: CID, options: AbortOptions = {}) {
+    for await (const event of this.dht.findProviders(cid, options)) {
+      if (event.name === 'PROVIDER') {
+        yield * event.providers
+      }
+    }
+  }
+
+  async put (key: Uint8Array, value: Uint8Array, options?: AbortOptions): Promise<void> {
+    await drain(this.dht.put(key, value, options))
+  }
+
+  async get (key: Uint8Array, options?: AbortOptions): Promise<Uint8Array> {
+    for await (const event of this.dht.get(key, options)) {
+      if (event.name === 'VALUE') {
+        return event.value
+      }
+    }
+
+    throw errCode(new Error('Not found'), 'ERR_NOT_FOUND')
+  }
+}

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

@@ -0,0 +1,35 @@
+import errCode from 'err-code'
+import { messages, codes } from '../errors.js'
+import type { PeerRouting } from '@libp2p/interfaces/peer-routing'
+import type { DHT } from '@libp2p/interfaces/dht'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { AbortOptions } from '@libp2p/interfaces'
+
+/**
+ * Wrapper class to convert events into returned values
+ */
+export class DHTPeerRouting implements PeerRouting {
+  private readonly dht: DHT
+
+  constructor (dht: DHT) {
+    this.dht = dht
+  }
+
+  async findPeer (peerId: PeerId, options: AbortOptions = {}) {
+    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)
+  }
+
+  async * getClosestPeers (key: Uint8Array, options: AbortOptions = {}) {
+    for await (const event of this.dht.getClosestPeers(key, options)) {
+      if (event.name === 'PEER_RESPONSE') {
+        yield * event.closer
+      }
+    }
+  }
+}

package/src/dialer/auto-dialer.ts

@@ -0,0 +1,40 @@
+import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import { logger } from '@libp2p/logger'
+import type { Components } from '@libp2p/interfaces/components'
+
+const log = logger('libp2p:dialer:auto-dialer')
+
+export interface AutoDialerInit {
+  enabled: boolean
+  minConnections: number
+}
+
+export class AutoDialer {
+  private readonly components: Components
+  private readonly enabled: boolean
+  private readonly minConnections: number
+
+  constructor (components: Components, init: AutoDialerInit) {
+    this.components = components
+    this.enabled = init.enabled
+    this.minConnections = init.minConnections
+  }
+
+  public handle (evt: CustomEvent<PeerInfo>) {
+    const { detail: peer } = evt
+
+    // If auto dialing is on and we have no connection to the peer, check if we should dial
+    if (this.enabled && this.components.getConnectionManager().getConnection(peer.id) == null) {
+      const minConnections = this.minConnections ?? 0
+
+      if (minConnections > this.components.getConnectionManager().getConnectionList().length) {
+        log('auto-dialing discovered peer %p', peer.id)
+
+        void this.components.getDialer().dial(peer.id)
+          .catch(err => {
+            log.error('could not connect to discovered peer %p with %o', peer.id, err)
+          })
+      }
+    }
+  }
+}

package/src/dialer/{dial-request.js → dial-request.ts}

@@ -1,91 +1,102 @@
-'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 {
+import errCode from 'err-code'
+import { anySignal } from 'any-signal'
+import FIFO from 'p-fifo'
+// @ts-expect-error setMaxListeners is missing from the node 16 types
+import { setMaxListeners } from 'events'
+import { codes } from '../errors.js'
+import { logger } from '@libp2p/logger'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { Connection } from '@libp2p/interfaces/connection'
+import type { AbortOptions } from '@libp2p/interfaces'
+import type { DefaultDialer } from './index.js'
+
+const log = logger('libp2p:dialer:dial-request')
+
+export interface DialAction {
+  (m: Multiaddr, options: AbortOptions): Promise<Connection>
+}
+
+export interface DialRequestOptions {
+  addrs: Multiaddr[]
+  dialAction: DialAction
+  dialer: DefaultDialer
+}
+
+export class DialRequest {
+  private readonly addrs: Multiaddr[]
+  private readonly dialer: DefaultDialer
+  private readonly dialAction: DialAction
+
   /**
    * 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
-  }) {
+  constructor (options: DialRequestOptions) {
+    const {
+      addrs,
+      dialAction,
+      dialer
+    } = options
+
     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 = {}) {
+  async run (options: AbortOptions = {}): Promise<Connection> {
     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 tokenHolder = new FIFO<number>()
+
+    for (const token of tokens) {
+      void tokenHolder.push(token).catch(err => {
+        log.error(err)
+      })
+    }
+
     const dialAbortControllers = this.addrs.map(() => {
       const controller = new AbortController()
       try {
         // fails on node < 15.4
-        setMaxListeners && setMaxListeners(Infinity, controller.signal)
+        setMaxListeners?.(Infinity, controller.signal)
       } catch {}
 
       return controller
     })
+
+    if (options.signal != null) {
+      try {
+        // fails on node < 15.4
+        setMaxListeners?.(Infinity, options.signal)
+      } catch {}
+    }
+
     let completedDials = 0
 
     try {
-      return await pAny(this.addrs.map(async (addr, i) => {
+      return await Promise.any(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 })
+          conn = await this.dialAction(addr, { ...options, signal: (options.signal != null) ? 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)
+            void tokenHolder.push(token).catch(err => {
+              log.error(err)
+            })
           } else {
             this.dialer.releaseToken(tokens.splice(tokens.indexOf(token), 1)[0])
           }
@@ -99,5 +110,3 @@ class DialRequest {
     }
   }
 }
-
-module.exports = DialRequest

package/src/dialer/index.ts

@@ -0,0 +1,371 @@
+import { logger } from '@libp2p/logger'
+import all from 'it-all'
+import filter from 'it-filter'
+import { pipe } from 'it-pipe'
+import errCode from 'err-code'
+import { Multiaddr } from '@multiformats/multiaddr'
+import { TimeoutController } from 'timeout-abort-controller'
+import { AbortError } from '@libp2p/interfaces/errors'
+import { anySignal } from 'any-signal'
+// @ts-expect-error setMaxListeners is missing from the node 16 types
+import { setMaxListeners } from 'events'
+import { DialAction, DialRequest } from './dial-request.js'
+import { publicAddressesFirst } from '@libp2p/utils/address-sort'
+import { trackedMap } from '@libp2p/tracked-map'
+import { codes } from '../errors.js'
+import {
+  DIAL_TIMEOUT,
+  MAX_PARALLEL_DIALS,
+  MAX_PER_PEER_DIALS,
+  MAX_ADDRS_TO_DIAL
+} from '../constants.js'
+import type { Connection } from '@libp2p/interfaces/connection'
+import type { AbortOptions, Startable } from '@libp2p/interfaces'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import { getPeer } from '../get-peer.js'
+import sort from 'it-sort'
+import type { Components } from '@libp2p/interfaces/components'
+import type { Dialer, DialerInit } from '@libp2p/interfaces/dialer'
+import map from 'it-map'
+import type { AddressSorter } from '@libp2p/interfaces/peer-store'
+
+const log = logger('libp2p:dialer')
+
+const METRICS_COMPONENT = 'dialler'
+const METRICS_PENDING_DIALS = 'pending-dials'
+const METRICS_PENDING_DIAL_TARGETS = 'pending-dial-targets'
+
+export interface DialTarget {
+  id: string
+  addrs: Multiaddr[]
+}
+
+export interface PendingDial {
+  dialRequest: DialRequest
+  controller: TimeoutController
+  promise: Promise<Connection>
+  destroy: () => void
+}
+
+export interface PendingDialTarget {
+  resolve: (value: any) => void
+  reject: (err: Error) => void
+}
+
+export class DefaultDialer implements Dialer, Startable {
+  private readonly components: Components
+  private readonly addressSorter: AddressSorter
+  private readonly maxAddrsToDial: number
+  private readonly timeout: number
+  private readonly maxDialsPerPeer: number
+  public tokens: number[]
+  public pendingDials: Map<string, PendingDial>
+  public pendingDialTargets: Map<string, PendingDialTarget>
+  private started: boolean
+
+  constructor (components: Components, init: DialerInit = {}) {
+    this.components = components
+    this.started = false
+    this.addressSorter = init.addressSorter ?? publicAddressesFirst
+    this.maxAddrsToDial = init.maxAddrsToDial ?? MAX_ADDRS_TO_DIAL
+    this.timeout = init.dialTimeout ?? DIAL_TIMEOUT
+    this.maxDialsPerPeer = init.maxDialsPerPeer ?? MAX_PER_PEER_DIALS
+    this.tokens = [...new Array(init.maxParallelDials ?? MAX_PARALLEL_DIALS)].map((_, index) => index)
+    this.pendingDials = trackedMap({
+      component: METRICS_COMPONENT,
+      metric: METRICS_PENDING_DIALS,
+      metrics: init.metrics
+    })
+    this.pendingDialTargets = trackedMap({
+      component: METRICS_COMPONENT,
+      metric: METRICS_PENDING_DIAL_TARGETS,
+      metrics: init.metrics
+    })
+
+    for (const [key, value] of Object.entries(init.resolvers ?? {})) {
+      Multiaddr.resolvers.set(key, value)
+    }
+  }
+
+  isStarted () {
+    return this.started
+  }
+
+  async start () {
+    this.started = true
+  }
+
+  /**
+   * Clears any pending dials
+   */
+  async stop () {
+    this.started = false
+
+    for (const dial of this.pendingDials.values()) {
+      try {
+        dial.controller.abort()
+      } catch (err: any) {
+        log.error(err)
+      }
+    }
+    this.pendingDials.clear()
+
+    for (const pendingTarget of this.pendingDialTargets.values()) {
+      pendingTarget.reject(new AbortError('Dialer was destroyed'))
+    }
+    this.pendingDialTargets.clear()
+  }
+
+  /**
+   * Connects to a given `peer` by dialing all of its known addresses.
+   * The dial to the first address that is successfully able to upgrade a connection
+   * will be used.
+   */
+  async dial (peer: PeerId | Multiaddr, options: AbortOptions = {}): Promise<Connection> {
+    const { id, multiaddrs } = getPeer(peer)
+
+    if (this.components.getPeerId().equals(id)) {
+      throw errCode(new Error('Tried to dial self'), codes.ERR_DIALED_SELF)
+    }
+
+    log('check multiaddrs %p', id)
+
+    if (multiaddrs != null && multiaddrs.length > 0) {
+      log('storing multiaddrs %p', id, multiaddrs)
+      await this.components.getPeerStore().addressBook.add(id, multiaddrs)
+    }
+
+    if (await this.components.getConnectionGater().denyDialPeer(id)) {
+      throw errCode(new Error('The dial request is blocked by gater.allowDialPeer'), codes.ERR_PEER_DIAL_INTERCEPTED)
+    }
+
+    log('dial to %p', id)
+
+    const existingConnection = this.components.getConnectionManager().getConnection(id)
+
+    if (existingConnection != null) {
+      log('had an existing connection to %p', id)
+
+      return existingConnection
+    }
+
+    log('creating dial target for %p', id)
+
+    const dialTarget = await this._createCancellableDialTarget(id)
+
+    if (dialTarget.addrs.length === 0) {
+      throw errCode(new Error('The dial request has no valid addresses'), codes.ERR_NO_VALID_ADDRESSES)
+    }
+
+    const pendingDial = this.pendingDials.get(dialTarget.id) ?? this._createPendingDial(dialTarget, options)
+
+    try {
+      const connection = await pendingDial.promise
+      log('dial succeeded to %s', dialTarget.id)
+      return connection
+    } catch (err: any) {
+      log('dial failed to %s', dialTarget.id, err)
+      // Error is a timeout
+      if (pendingDial.controller.signal.aborted) {
+        err.code = codes.ERR_TIMEOUT
+      }
+      log.error(err)
+      throw err
+    } finally {
+      pendingDial.destroy()
+    }
+  }
+
+  async dialProtocol (peer: PeerId | Multiaddr, protocols: string | string[], options: AbortOptions = {}) {
+    if (protocols == null) {
+      throw errCode(new Error('no protocols were provided to open a stream'), codes.ERR_INVALID_PROTOCOLS_FOR_STREAM)
+    }
+
+    protocols = Array.isArray(protocols) ? protocols : [protocols]
+
+    if (protocols.length === 0) {
+      throw errCode(new Error('no protocols were provided to open a stream'), codes.ERR_INVALID_PROTOCOLS_FOR_STREAM)
+    }
+
+    const connection = await this.dial(peer, options)
+
+    return await connection.newStream(protocols)
+  }
+
+  /**
+   * Connects to a given `peer` by dialing all of its known addresses.
+   * The dial to the first address that is successfully able to upgrade a connection
+   * will be used.
+   */
+  async _createCancellableDialTarget (peer: PeerId): Promise<DialTarget> {
+    // Make dial target promise cancellable
+    const id = `${(parseInt(String(Math.random() * 1e9), 10)).toString()}${Date.now()}`
+    const cancellablePromise = new Promise<DialTarget>((resolve, reject) => {
+      this.pendingDialTargets.set(id, { resolve, reject })
+    })
+
+    try {
+      const dialTarget = await Promise.race([
+        this._createDialTarget(peer),
+        cancellablePromise
+      ])
+
+      return dialTarget
+    } finally {
+      this.pendingDialTargets.delete(id)
+    }
+  }
+
+  /**
+   * Creates a DialTarget. The DialTarget is used to create and track
+   * the DialRequest to a given peer.
+   * If a multiaddr is received it should be the first address attempted.
+   * Multiaddrs not supported by the available transports will be filtered out.
+   */
+  async _createDialTarget (peer: PeerId): Promise<DialTarget> {
+    const knownAddrs = await pipe(
+      await this.components.getPeerStore().addressBook.get(peer),
+      (source) => filter(source, async (address) => {
+        return !(await this.components.getConnectionGater().denyDialMultiaddr(peer, address.multiaddr))
+      }),
+      (source) => sort(source, this.addressSorter),
+      (source) => map(source, (address) => {
+        const ma = address.multiaddr
+
+        if (peer.toString() === ma.getPeerId()) {
+          return ma
+        }
+
+        return ma.encapsulate(`/p2p/${peer.toString()}`)
+      }),
+      async (source) => await all(source)
+    )
+
+    const addrs: Multiaddr[] = []
+    for (const a of knownAddrs) {
+      const resolvedAddrs = await this._resolve(a)
+      resolvedAddrs.forEach(ra => addrs.push(ra))
+    }
+
+    // Multiaddrs not supported by the available transports will be filtered out.
+    const supportedAddrs = addrs.filter(a => this.components.getTransportManager().transportForMultiaddr(a))
+
+    if (supportedAddrs.length > this.maxAddrsToDial) {
+      await this.components.getPeerStore().delete(peer)
+      throw errCode(new Error('dial with more addresses than allowed'), codes.ERR_TOO_MANY_ADDRESSES)
+    }
+
+    return {
+      id: peer.toString(),
+      addrs: supportedAddrs
+    }
+  }
+
+  /**
+   * Creates a PendingDial that wraps the underlying DialRequest
+   */
+  _createPendingDial (dialTarget: DialTarget, options: AbortOptions = {}): PendingDial {
+    /**
+     * @param {Multiaddr} addr
+     * @param {{ signal: { aborted: any; }; }} options
+     */
+    const dialAction: DialAction = async (addr, options = {}) => {
+      if (options.signal?.aborted === true) {
+        throw errCode(new Error('already aborted'), codes.ERR_ALREADY_ABORTED)
+      }
+
+      return await this.components.getTransportManager().dial(addr, options)
+    }
+
+    const dialRequest = new DialRequest({
+      addrs: dialTarget.addrs,
+      dialAction,
+      dialer: this
+    })
+
+    // Combine the timeout signal and options.signal, if provided
+    const timeoutController = new TimeoutController(this.timeout)
+
+    const signals = [timeoutController.signal]
+    ;(options.signal != null) && signals.push(options.signal)
+    const signal = anySignal(signals)
+
+    // this signal will potentially be used while dialing lots of
+    // peers so prevent MaxListenersExceededWarning appearing in the console
+    try {
+      // fails on node < 15.4
+      setMaxListeners?.(Infinity, signal)
+    } catch {}
+
+    const pendingDial = {
+      dialRequest,
+      controller: timeoutController,
+      promise: dialRequest.run({ ...options, signal }),
+      destroy: () => {
+        timeoutController.clear()
+        this.pendingDials.delete(dialTarget.id)
+      }
+    }
+    this.pendingDials.set(dialTarget.id, pendingDial)
+
+    return pendingDial
+  }
+
+  getTokens (num: number) {
+    const total = Math.min(num, this.maxDialsPerPeer, this.tokens.length)
+    const tokens = this.tokens.splice(0, total)
+    log('%d tokens request, returning %d, %d remaining', num, total, this.tokens.length)
+    return tokens
+  }
+
+  releaseToken (token: number) {
+    // Guard against duplicate releases
+    if (this.tokens.includes(token)) {
+      return
+    }
+
+    log('token %d released', token)
+    this.tokens.push(token)
+  }
+
+  /**
+   * Resolve multiaddr recursively
+   */
+  async _resolve (ma: Multiaddr): Promise<Multiaddr[]> {
+    // TODO: recursive logic should live in multiaddr once dns4/dns6 support is in place
+    // Now only supporting resolve for dnsaddr
+    const resolvableProto = ma.protoNames().includes('dnsaddr')
+
+    // Multiaddr is not resolvable? End recursion!
+    if (!resolvableProto) {
+      return [ma]
+    }
+
+    const resolvedMultiaddrs = await this._resolveRecord(ma)
+    const recursiveMultiaddrs = await Promise.all(resolvedMultiaddrs.map(async (nm) => {
+      return await this._resolve(nm)
+    }))
+
+    const addrs = recursiveMultiaddrs.flat()
+    return addrs.reduce<Multiaddr[]>((array, newM) => {
+      if (array.find(m => m.equals(newM)) == null) {
+        array.push(newM)
+      }
+      return array
+    }, ([]))
+  }
+
+  /**
+   * Resolve a given multiaddr. If this fails, an empty array will be returned
+   */
+  async _resolveRecord (ma: Multiaddr): Promise<Multiaddr[]> {
+    try {
+      ma = new Multiaddr(ma.toString()) // Use current multiaddr module
+      const multiaddrs = await ma.resolve()
+      return multiaddrs
+    } catch (err) {
+      log.error(`multiaddr ${ma.toString()} could not be resolved`, err)
+      return []
+    }
+  }
+}