libp2p 0.43.4 → 0.44.0

package/src/connection-manager/dialer/dial-request.ts

@@ -1,144 +0,0 @@
-import { CodeError } from '@libp2p/interfaces/errors'
-import { anySignal } from 'any-signal'
-import FIFO from 'p-fifo'
-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/interface-connection'
-import type { AbortOptions } from '@libp2p/interfaces'
-import type { Dialer } from '@libp2p/interface-connection-manager'
-
-const log = logger('libp2p:dialer:dial-request')
-
-export interface DialAction {
-  (m: Multiaddr, options: AbortOptions): Promise<Connection>
-}
-
-export interface DialRequestOptions {
-  addrs: Multiaddr[]
-  dialAction: DialAction
-  dialer: Dialer
-}
-
-export class DialRequest {
-  private readonly addrs: Multiaddr[]
-  private readonly dialer: Dialer
-  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.
-   */
-  constructor (options: DialRequestOptions) {
-    const {
-      addrs,
-      dialAction,
-      dialer
-    } = options
-
-    this.addrs = addrs
-    this.dialer = dialer
-    this.dialAction = dialAction
-  }
-
-  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 new CodeError('No dial tokens available', codes.ERR_NO_DIAL_TOKENS)
-    }
-
-    const tokenHolder = new FIFO<number>()
-
-    for (const token of tokens) {
-      void tokenHolder.push(token).catch(err => {
-        log.error(err)
-      })
-    }
-
-    const dialAbortControllers: Array<(AbortController | undefined)> = this.addrs.map(() => {
-      const controller = new AbortController()
-      try {
-        // fails on node < 15.4
-        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
-    let done = false
-
-    try {
-      return await Promise.any(this.addrs.map(async (addr, i) => {
-        const token = await tokenHolder.shift() // get token
-        // End attempt once another attempt succeeded
-        if (done) {
-          this.dialer.releaseToken(tokens.splice(tokens.indexOf(token), 1)[0])
-          throw new CodeError('dialAction already succeeded', codes.ERR_ALREADY_SUCCEEDED)
-        }
-
-        const controller = dialAbortControllers[i]
-        if (controller == null) {
-          throw new CodeError('dialAction did not come with an AbortController', codes.ERR_INVALID_PARAMETERS)
-        }
-        let conn
-        try {
-          const signal = controller.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[i] = undefined
-        } 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) {
-            void tokenHolder.push(token).catch(err => {
-              log.error(err)
-            })
-          } else {
-            this.dialer.releaseToken(tokens.splice(tokens.indexOf(token), 1)[0])
-          }
-        }
-
-        if (conn == null) {
-          // Notify Promise.any that attempt was not successful
-          // to prevent from returning undefined despite there
-          // were successful dial attempts
-          throw new CodeError('dialAction led to empty object', codes.ERR_TRANSPORT_DIAL_FAILED)
-        } else {
-          // This dial succeeded, don't attempt anything else
-          done = true
-        }
-
-        return conn
-      }))
-    } catch (err: any) {
-      // if we only dialed one address, unwrap the AggregateError
-      if (this.addrs.length === 1 && err.name === 'AggregateError') {
-        throw err.errors[0]
-      }
-
-      throw err
-    } finally {
-      // success/failure happened, abort everything else
-      dialAbortControllers.forEach(c => {
-        if (c !== undefined) {
-          c.abort()
-        }
-      })
-      tokens.forEach(token => { this.dialer.releaseToken(token) }) // release tokens back to the dialer
-    }
-  }
-}

package/src/connection-manager/dialer/index.ts

@@ -1,461 +0,0 @@
-import { logger } from '@libp2p/logger'
-import { CodeError } from '@libp2p/interfaces/errors'
-import { isMultiaddr, Multiaddr, Resolver, multiaddr, resolvers } from '@multiformats/multiaddr'
-import { TimeoutController } from 'timeout-abort-controller'
-import { anySignal } from 'any-signal'
-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/interface-connection'
-import type { AbortOptions } from '@libp2p/interfaces'
-import type { Startable } from '@libp2p/interfaces/startable'
-import { isPeerId, PeerId } from '@libp2p/interface-peer-id'
-import { getPeerAddress, PeerAddress } from '../../get-peer.js'
-import type { AddressSorter, PeerStore } from '@libp2p/interface-peer-store'
-import type { Metrics } from '@libp2p/interface-metrics'
-import type { Dialer } from '@libp2p/interface-connection-manager'
-import type { TransportManager } from '@libp2p/interface-transport'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
-
-const log = logger('libp2p:dialer')
-
-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 interface DialerInit {
-  /**
-   * Sort the known addresses of a peer before trying to dial
-   */
-  addressSorter?: AddressSorter
-
-  /**
-   * Number of max concurrent dials
-   */
-  maxParallelDials?: number
-
-  /**
-   * Number of max addresses to dial for a given peer
-   */
-  maxAddrsToDial?: number
-
-  /**
-   * How long a dial attempt is allowed to take
-   */
-  dialTimeout?: number
-
-  /**
-   * Number of max concurrent dials per peer
-   */
-  maxDialsPerPeer?: number
-
-  /**
-   * Multiaddr resolvers to use when dialing
-   */
-  resolvers?: Record<string, Resolver>
-}
-
-export interface DefaultDialerComponents {
-  peerId: PeerId
-  metrics?: Metrics
-  peerStore: PeerStore
-  transportManager: TransportManager
-  connectionGater: ConnectionGater
-}
-
-export class DefaultDialer implements Startable, Dialer {
-  private readonly components: DefaultDialerComponents
-  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, AbortController>
-  private started: boolean
-
-  constructor (components: DefaultDialerComponents, init: DialerInit = {}) {
-    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.components = components
-    this.pendingDials = trackedMap({
-      name: 'libp2p_dialler_pending_dials',
-      metrics: components.metrics
-    })
-    this.pendingDialTargets = trackedMap({
-      name: 'libp2p_dialler_pending_dial_targets',
-      metrics: components.metrics
-    })
-
-    for (const [key, value] of Object.entries(init.resolvers ?? {})) {
-      resolvers.set(key, value)
-    }
-  }
-
-  isStarted (): boolean {
-    return this.started
-  }
-
-  async start (): Promise<void> {
-    this.started = true
-  }
-
-  /**
-   * Clears any pending dials
-   */
-  async stop (): Promise<void> {
-    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.abort()
-    }
-    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 (peerIdOrMultiaddr: PeerId | Multiaddr | Multiaddr[], options: AbortOptions = {}): Promise<Connection> {
-    const peerAddress = getPeerAddress(peerIdOrMultiaddr)
-
-    if (peerAddress.peerId != null) {
-      if (this.components.peerId.equals(peerAddress.peerId)) {
-        throw new CodeError('Tried to dial self', codes.ERR_DIALED_SELF)
-      }
-
-      if (peerAddress.multiaddrs.length > 0) {
-        log('storing multiaddrs %p', peerAddress.peerId, peerAddress.multiaddrs)
-        await this.components.peerStore.addressBook.add(peerAddress.peerId, peerAddress.multiaddrs)
-      }
-
-      if ((await this.components.connectionGater.denyDialPeer?.(peerAddress.peerId)) === true) {
-        throw new CodeError('The dial request is blocked by gater.allowDialPeer', codes.ERR_PEER_DIAL_INTERCEPTED)
-      }
-    }
-
-    log('creating dial target for %p', peerAddress.peerId)
-    return await this.createDialTarget(peerAddress, options)
-  }
-
-  async createDialTarget (peerAddress: PeerAddress, options: AbortOptions = {}): Promise<Connection> {
-    // resolving multiaddrs can involve dns lookups so allow them to be aborted
-    const controller = new AbortController()
-    const controllerId = randomId()
-
-    this.pendingDialTargets.set(controllerId, controller)
-
-    let signal = controller.signal
-
-    // merge with the passed signal, if any
-    if (options.signal != null) {
-      signal = anySignal([signal, options.signal])
-    }
-
-    let dialTarget: DialTarget
-
-    try {
-      dialTarget = await this._createDialTarget(peerAddress, {
-        ...options,
-        signal
-      })
-    } finally {
-      // done resolving the multiaddrs so remove the abort controller
-      this.pendingDialTargets.delete(controllerId)
-    }
-
-    if (dialTarget.addrs.length === 0) {
-      throw new CodeError('The dial request has no valid addresses', codes.ERR_NO_VALID_ADDRESSES)
-    }
-
-    // try to join an in-flight dial for this peer if one is available
-    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) {
-        const error = new CodeError(err.message, codes.ERR_TIMEOUT)
-        log.error(error)
-        throw error
-      }
-      log.error(err)
-      throw err
-    } finally {
-      pendingDial.destroy()
-    }
-  }
-
-  /**
-   * Get the current dial targets which are pending
-   */
-  getPendingDialTargets (): Map<string, AbortController> {
-    return this.pendingDialTargets
-  }
-
-  /**
-   * Returns true if the peer id is in the pending dials
-   */
-  hasPendingDial (peerId: PeerId | Multiaddr): boolean {
-    if (isMultiaddr(peerId)) {
-      return this.pendingDials.has(peerId.getPeerId() ?? '')
-    }
-
-    return this.pendingDials.has(peerId.toString())
-  }
-
-  /**
-   * 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 only address attempted.
-   *
-   * Multiaddrs not supported by the available transports will be filtered out.
-   */
-  async _createDialTarget (peerIdOrMultiaddr: PeerAddress, options: AbortOptions): Promise<DialTarget> {
-    let addrs: Multiaddr[] = [
-      ...peerIdOrMultiaddr.multiaddrs
-    ]
-
-    // load addresses if only a peer id was passed, otherwise just dial the passed multiaddrs
-    if (peerIdOrMultiaddr.peerId != null && peerIdOrMultiaddr.multiaddrs.length === 0) {
-      addrs.push(...await this._loadAddresses(peerIdOrMultiaddr.peerId))
-    }
-
-    // resolve addresses - this can result in a one-to-many translation when dnsaddrs are resolved
-    addrs = (await Promise.all(
-      addrs.map(async (ma) => await this._resolve(ma, options))
-    ))
-      .flat()
-
-    // Multiaddrs not supported by the available transports will be filtered out.
-    const filteredAddrs = addrs.filter(ma => Boolean(this.components.transportManager.transportForMultiaddr(ma)))
-
-    // deduplicate addresses
-    const dedupedAddrs = [...new Set(filteredAddrs.map(ma => ma.toString()))]
-    let dedupedMultiaddrs = dedupedAddrs.map(ma => multiaddr(ma))
-
-    if (dedupedMultiaddrs.length > this.maxAddrsToDial) {
-      log('addresses after filtering', dedupedMultiaddrs.map(ma => ma.toString()))
-      throw new CodeError('dial with more addresses than allowed', codes.ERR_TOO_MANY_ADDRESSES)
-    }
-
-    if (dedupedMultiaddrs.length === 0) {
-      log('addresses before filtering', addrs.map(ma => ma.toString()))
-      log('addresses after filtering', dedupedMultiaddrs.map(ma => ma.toString()))
-    }
-
-    const peerId = isPeerId(peerIdOrMultiaddr.peerId) ? peerIdOrMultiaddr.peerId : undefined
-
-    if (peerId != null) {
-      const peerIdMultiaddr = `/p2p/${peerId.toString()}`
-      dedupedMultiaddrs = dedupedMultiaddrs.map(addr => {
-        const addressPeerId = addr.getPeerId()
-        const lastProto = addr.protos().pop()
-
-        // do not append peer id to path multiaddrs
-        if (lastProto?.path === true) {
-          return addr
-        }
-
-        if (addressPeerId == null) {
-          return addr.encapsulate(peerIdMultiaddr)
-        }
-
-        return addr
-      })
-    }
-
-    return {
-      id: peerId == null ? randomId() : peerId.toString(),
-      addrs: dedupedMultiaddrs
-    }
-  }
-
-  /**
-   * Loads a list of addresses from the peer store for the passed peer id
-   */
-  async _loadAddresses (peer: PeerId): Promise<Multiaddr[]> {
-    const addresses = await this.components.peerStore.addressBook.get(peer)
-
-    return (await Promise.all(
-      addresses.map(async address => {
-        const deny = await this.components.connectionGater.denyDialMultiaddr?.(peer, address.multiaddr)
-
-        if (deny === true) {
-          return false
-        }
-
-        return address
-      })
-    ))
-      .filter(isTruthy)
-      // Sort addresses so, for example, we try certified public address first
-      .sort(this.addressSorter)
-      .map(address => address.multiaddr)
-  }
-
-  /**
-   * 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 new CodeError('already aborted', codes.ERR_ALREADY_ABORTED)
-      }
-
-      return await this.components.transportManager.dial(addr, options).catch(err => {
-        log.error('dial to %s failed', addr, err)
-        throw err
-      })
-    }
-
-    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): 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): void {
-    // 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, options: AbortOptions): 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, options)
-    const recursiveMultiaddrs = await Promise.all(resolvedMultiaddrs.map(async (nm) => {
-      return await this._resolve(nm, options)
-    }))
-
-    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, options: AbortOptions): Promise<Multiaddr[]> {
-    try {
-      ma = multiaddr(ma.toString()) // Use current multiaddr module
-      const multiaddrs = await ma.resolve(options)
-      return multiaddrs
-    } catch (err) {
-      log.error(`multiaddr ${ma.toString()} could not be resolved`, err)
-      return []
-    }
-  }
-}
-
-/**
- * Type safe version of `list.filter(Boolean)`
- */
-function isTruthy <T> (e: T | false | null | undefined): e is T {
-  return Boolean(e)
-}
-
-/**
- * Returns a random string
- */
-function randomId (): string {
-  return `${(parseInt(String(Math.random() * 1e9), 10)).toString()}${Date.now()}`
-}