libp2p 0.36.2 → 0.37.0-5934b13

package/src/config.ts

@@ -0,0 +1,99 @@
+import mergeOptions from 'merge-options'
+import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
+import * as Constants from './constants.js'
+import { AGENT_VERSION } from './identify/consts.js'
+import * as RelayConstants from './circuit/constants.js'
+import { publicAddressesFirst } from '@libp2p/utils/address-sort'
+import { FaultTolerance } from './transport-manager.js'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { Libp2pInit } from './index.js'
+import { codes, messages } from './errors.js'
+import errCode from 'err-code'
+import type { RecursivePartial } from '@libp2p/interfaces'
+
+const DefaultConfig: Partial<Libp2pInit> = {
+  addresses: {
+    listen: [],
+    announce: [],
+    noAnnounce: [],
+    announceFilter: (multiaddrs: Multiaddr[]) => multiaddrs
+  },
+  connectionManager: {
+    maxConnections: 300,
+    minConnections: 50,
+    autoDial: true,
+    autoDialInterval: 10000,
+    maxParallelDials: Constants.MAX_PARALLEL_DIALS,
+    maxDialsPerPeer: Constants.MAX_PER_PEER_DIALS,
+    dialTimeout: Constants.DIAL_TIMEOUT,
+    resolvers: {
+      dnsaddr: dnsaddrResolver
+    },
+    addressSorter: publicAddressesFirst
+  },
+  connectionGater: {},
+  transportManager: {
+    faultTolerance: FaultTolerance.FATAL_ALL
+  },
+  host: {
+    agentVersion: AGENT_VERSION
+  },
+  metrics: {
+    enabled: false,
+    computeThrottleMaxQueueSize: 1000,
+    computeThrottleTimeout: 2000,
+    movingAverageIntervals: [
+      60 * 1000, // 1 minute
+      5 * 60 * 1000, // 5 minutes
+      15 * 60 * 1000 // 15 minutes
+    ],
+    maxOldPeersRetention: 50
+  },
+  peerRouting: {
+    refreshManager: {
+      enabled: true,
+      interval: 6e5,
+      bootDelay: 10e3
+    }
+  },
+  protocolPrefix: 'ipfs',
+  nat: {
+    enabled: true,
+    ttl: 7200,
+    keepAlive: true
+  },
+  relay: {
+    enabled: true,
+    advertise: {
+      bootDelay: RelayConstants.ADVERTISE_BOOT_DELAY,
+      enabled: false,
+      ttl: RelayConstants.ADVERTISE_TTL
+    },
+    hop: {
+      enabled: false,
+      active: false
+    },
+    autoRelay: {
+      enabled: false,
+      maxListeners: 2
+    }
+  }
+}
+
+export function validateConfig (opts: RecursivePartial<Libp2pInit>): Libp2pInit {
+  const resultingOptions: Libp2pInit = mergeOptions(DefaultConfig, opts)
+
+  if (resultingOptions.transports == null || resultingOptions.transports.length < 1) {
+    throw errCode(new Error(messages.ERR_TRANSPORTS_REQUIRED), codes.ERR_TRANSPORTS_REQUIRED)
+  }
+
+  if (resultingOptions.connectionEncryption == null || resultingOptions.connectionEncryption.length === 0) {
+    throw errCode(new Error(messages.CONN_ENCRYPTION_REQUIRED), codes.CONN_ENCRYPTION_REQUIRED)
+  }
+
+  if (resultingOptions.connectionProtector === null && globalThis.process?.env?.LIBP2P_FORCE_PNET != null) { // eslint-disable-line no-undef
+    throw errCode(new Error(messages.ERR_PROTECTOR_REQUIRED), codes.ERR_PROTECTOR_REQUIRED)
+  }
+
+  return resultingOptions
+}

package/src/connection-manager/auto-dialler.ts

@@ -0,0 +1,154 @@
+import { logger } from '@libp2p/logger'
+import mergeOptions from 'merge-options'
+// @ts-expect-error retimer does not have types
+import retimer from 'retimer'
+import all from 'it-all'
+import { pipe } from 'it-pipe'
+import filter from 'it-filter'
+import sort from 'it-sort'
+import type { Startable } from '@libp2p/interfaces/startable'
+import type { Components } from '@libp2p/interfaces/components'
+
+const log = logger('libp2p:connection-manager:auto-dialler')
+
+export interface AutoDiallerInit {
+  /**
+   * Should preemptively guarantee connections are above the low watermark
+   */
+  enabled?: boolean
+
+  /**
+   * The minimum number of connections to avoid pruning
+   */
+  minConnections?: number
+
+  /**
+   * How often, in milliseconds, it should preemptively guarantee connections are above the low watermark
+   */
+  autoDialInterval?: number
+}
+
+const defaultOptions: Partial<AutoDiallerInit> = {
+  enabled: true,
+  minConnections: 0,
+  autoDialInterval: 10000
+}
+
+export class AutoDialler implements Startable {
+  private readonly components: Components
+  private readonly options: Required<AutoDiallerInit>
+  private running: boolean
+  private autoDialTimeout?: ReturnType<retimer>
+
+  /**
+   * Proactively tries to connect to known peers stored in the PeerStore.
+   * It will keep the number of connections below the upper limit and sort
+   * the peers to connect based on wether we know their keys and protocols.
+   */
+  constructor (components: Components, init: AutoDiallerInit) {
+    this.components = components
+    this.options = mergeOptions.call({ ignoreUndefined: true }, defaultOptions, init)
+    this.running = false
+    this._autoDial = this._autoDial.bind(this)
+
+    log('options: %j', this.options)
+  }
+
+  isStarted () {
+    return this.running
+  }
+
+  /**
+   * Starts the auto dialer
+   */
+  async start () {
+    if (!this.options.enabled) {
+      log('not enabled')
+      return
+    }
+
+    this.running = true
+
+    void this._autoDial().catch(err => {
+      log.error('could start autodial', err)
+    })
+
+    log('started')
+  }
+
+  /**
+   * Stops the auto dialler
+   */
+  async stop () {
+    if (!this.options.enabled) {
+      log('not enabled')
+      return
+    }
+
+    this.running = false
+
+    if (this.autoDialTimeout != null) {
+      this.autoDialTimeout.clear()
+    }
+
+    log('stopped')
+  }
+
+  async _autoDial () {
+    if (this.autoDialTimeout != null) {
+      this.autoDialTimeout.clear()
+    }
+
+    const minConnections = this.options.minConnections
+
+    // Already has enough connections
+    if (this.components.getConnectionManager().getConnections().length >= minConnections) {
+      this.autoDialTimeout = retimer(this._autoDial, this.options.autoDialInterval)
+
+      return
+    }
+
+    // Sort peers on whether we know protocols or public keys for them
+    const allPeers = await this.components.getPeerStore().all()
+
+    const peers = await pipe(
+      // shuffle the peers
+      allPeers.sort(() => Math.random() > 0.5 ? 1 : -1),
+      (source) => filter(source, (peer) => !peer.id.equals(this.components.getPeerId())),
+      (source) => sort(source, (a, b) => {
+        if (b.protocols.length > a.protocols.length) {
+          return 1
+        } else if (b.id.publicKey != null && a.id.publicKey == null) {
+          return 1
+        }
+        return -1
+      }),
+      async (source) => await all(source)
+    )
+
+    for (let i = 0; this.running && i < peers.length && this.components.getConnectionManager().getConnections().length < minConnections; i++) {
+      // Connection Manager was stopped during async dial
+      if (!this.running) {
+        return
+      }
+
+      const peer = peers[i]
+
+      if (this.components.getConnectionManager().getConnections(peer.id).length === 0) {
+        log('connecting to a peerStore stored peer %p', peer.id)
+        try {
+          await this.components.getConnectionManager().openConnection(peer.id)
+        } catch (err: any) {
+          log.error('could not connect to peerStore stored peer', err)
+        }
+      }
+    }
+
+    // Connection Manager was stopped
+    if (!this.running) {
+      return
+    }
+
+    this.autoDialTimeout = retimer(this._autoDial, this.options.autoDialInterval)
+  }
+}

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

@@ -0,0 +1,59 @@
+import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import { logger } from '@libp2p/logger'
+import type { Components } from '@libp2p/interfaces/components'
+import { TimeoutController } from 'timeout-abort-controller'
+
+const log = logger('libp2p:dialer:auto-dialer')
+
+export interface AutoDialerInit {
+  enabled: boolean
+  minConnections: number
+  dialTimeout: number
+}
+
+export class AutoDialer {
+  private readonly components: Components
+  private readonly enabled: boolean
+  private readonly minConnections: number
+  private readonly dialTimeout: number
+
+  constructor (components: Components, init: AutoDialerInit) {
+    this.components = components
+    this.enabled = init.enabled
+    this.minConnections = init.minConnections
+    this.dialTimeout = init.dialTimeout
+  }
+
+  public handle (evt: CustomEvent<PeerInfo>) {
+    const { detail: peer } = evt
+
+    if (!this.enabled) {
+      return
+    }
+
+    const connections = this.components.getConnectionManager().getConnections(peer.id)
+
+    // If auto dialing is on and we have no connection to the peer, check if we should dial
+    if (connections.length === 0) {
+      const minConnections = this.minConnections ?? 0
+
+      const allConnections = this.components.getConnectionManager().getConnections()
+
+      if (minConnections > allConnections.length) {
+        log('auto-dialing discovered peer %p with timeout %d', peer.id, this.dialTimeout)
+
+        const controller = new TimeoutController(this.dialTimeout)
+
+        void this.components.getConnectionManager().openConnection(peer.id, {
+          signal: controller.signal
+        })
+          .catch(err => {
+            log.error('could not connect to discovered peer %p with %o', peer.id, err)
+          })
+          .finally(() => {
+            controller.clear()
+          })
+      }
+    }
+  }
+}

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

@@ -0,0 +1,137 @@
+import errCode from 'err-code'
+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/interfaces/connection'
+import type { AbortOptions } from '@libp2p/interfaces'
+import type { Dialer } 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: 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 errCode(new Error('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 errCode(new Error('dialAction already succeeded'), codes.ERR_ALREADY_SUCCEEDED)
+        }
+
+        const controller = dialAbortControllers[i]
+        if (controller == null) {
+          throw errCode(new Error('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 errCode(new Error('dialAction led to empty object'), codes.ERR_TRANSPORT_DIAL_FAILED)
+        } else {
+          // This dial succeeded, don't attempt anything else
+          done = true
+        }
+
+        return conn
+      }))
+    } 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
+    }
+  }
+}