libp2p 0.43.4 → 0.44.0-17eb162a

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

@@ -1,158 +0,0 @@
-import { logger } from '@libp2p/logger'
-import mergeOptions from 'merge-options'
-// @ts-expect-error retimer does not have types
-import retimer from 'retimer'
-import type { Startable } from '@libp2p/interfaces/startable'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-
-const log = logger('libp2p:connection-manager:auto-dialler')
-
-export interface AutoDiallerInit {
-  /**
-   * 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
-}
-
-export interface AutoDiallerComponents {
-  peerId: PeerId
-  connectionManager: ConnectionManager
-  peerStore: PeerStore
-}
-
-const defaultOptions: Partial<AutoDiallerInit> = {
-  minConnections: 0,
-  autoDialInterval: 10000
-}
-
-export class AutoDialler implements Startable {
-  private readonly components: AutoDiallerComponents
-  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: AutoDiallerComponents, 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 (): boolean {
-    return this.running
-  }
-
-  /**
-   * Starts the auto dialer
-   */
-  async start (): Promise<void> {
-    this.running = true
-
-    void this._autoDial().catch(err => {
-      log.error('could not start autodial', err)
-    })
-
-    log('started')
-  }
-
-  /**
-   * Stops the auto dialler
-   */
-  async stop (): Promise<void> {
-    this.running = false
-
-    if (this.autoDialTimeout != null) {
-      this.autoDialTimeout.clear()
-    }
-
-    log('stopped')
-  }
-
-  async _autoDial (): Promise<void> {
-    if (this.autoDialTimeout != null) {
-      this.autoDialTimeout.clear()
-    }
-
-    const minConnections = this.options.minConnections
-
-    // Already has enough connections
-    if (this.components.connectionManager.getConnections().length >= minConnections) {
-      this.autoDialTimeout = retimer(this._autoDial, this.options.autoDialInterval)
-
-      return
-    }
-
-    // Sort peers on whether we know protocols or public keys for them
-    let peers = await this.components.peerStore.all()
-
-    peers = peers.filter((peer) => {
-      // do not dial ourselves
-      if (peer.id.equals(this.components.peerId)) {
-        return false
-      }
-
-      // do not dial peers without multiaddrs
-      if (peer.addresses.length === 0) {
-        return false
-      }
-
-      return true
-    })
-
-    // shuffle the peers
-    peers = peers.sort(() => Math.random() > 0.5 ? 1 : -1)
-
-    peers = peers.sort((a, b) => {
-      // dial peers with the most protocols first
-      if (b.protocols.length > a.protocols.length) {
-        return 1
-      }
-
-      // dial peers with public keys first
-      if (b.id.publicKey != null && a.id.publicKey == null) {
-        return 1
-      }
-
-      return -1
-    })
-
-    for (let i = 0; this.running && i < peers.length && this.components.connectionManager.getConnections().length < minConnections; i++) {
-      // Connection Manager was stopped during async dial
-      if (!this.running) {
-        return
-      }
-
-      const peer = peers[i]
-
-      if (this.components.connectionManager.getConnections(peer.id).length === 0) {
-        log('connecting to a peerStore stored peer %p', peer.id)
-        try {
-          await this.components.connectionManager.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/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
-    }
-  }
-}