libp2p 1.4.3 → 1.5.0-9d13a2f6a

package/src/random-walk.ts

@@ -0,0 +1,138 @@
+import { randomBytes } from '@libp2p/crypto'
+import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
+import { anySignal } from 'any-signal'
+import pDefer, { type DeferredPromise } from 'p-defer'
+import { raceEvent } from 'race-event'
+import { raceSignal } from 'race-signal'
+import type { AbortOptions, ComponentLogger, Logger, PeerInfo, PeerRouting, Startable } from '@libp2p/interface'
+import type { RandomWalk as RandomWalkInterface } from '@libp2p/interface-internal'
+
+export interface RandomWalkComponents {
+  peerRouting: PeerRouting
+  logger: ComponentLogger
+}
+
+interface RandomWalkEvents {
+  'walk:peer': CustomEvent<PeerInfo>
+  'walk:error': CustomEvent<Error>
+}
+
+export class RandomWalk extends TypedEventEmitter<RandomWalkEvents> implements RandomWalkInterface, Startable {
+  private readonly peerRouting: PeerRouting
+  private readonly log: Logger
+  private walking: boolean
+  private walkers: number
+  private shutdownController: AbortController
+  private walkController?: AbortController
+  private needNext?: DeferredPromise<void>
+
+  constructor (components: RandomWalkComponents) {
+    super()
+
+    this.log = components.logger.forComponent('libp2p:random-walk')
+    this.peerRouting = components.peerRouting
+    this.walkers = 0
+    this.walking = false
+
+    // stops any in-progress walks when the node is shut down
+    this.shutdownController = new AbortController()
+    setMaxListeners(Infinity, this.shutdownController.signal)
+  }
+
+  start (): void {
+    this.shutdownController = new AbortController()
+    setMaxListeners(Infinity, this.shutdownController.signal)
+  }
+
+  stop (): void {
+    this.shutdownController.abort()
+  }
+
+  async * walk (options?: AbortOptions): AsyncGenerator<PeerInfo> {
+    if (!this.walking) {
+      // start the query that causes walk:peer events to be emitted
+      this.startWalk()
+    }
+
+    this.walkers++
+    const signal = anySignal([this.shutdownController.signal, options?.signal])
+    setMaxListeners(Infinity, signal)
+
+    try {
+      while (true) {
+        // if another consumer has paused the query, start it again
+        this.needNext?.resolve()
+        this.needNext = pDefer()
+
+        // wait for a walk:peer or walk:error event
+        const event = await raceEvent<CustomEvent<PeerInfo>>(this, 'walk:peer', signal, {
+          errorEvent: 'walk:error'
+        })
+
+        yield event.detail
+      }
+    } finally {
+      signal.clear()
+      this.walkers--
+
+      // stop the walk if no more consumers are interested
+      if (this.walkers === 0) {
+        this.walkController?.abort()
+        this.walkController = undefined
+      }
+    }
+  }
+
+  private startWalk (): void {
+    this.walking = true
+
+    // the signal for this controller will be aborted if no more random peers
+    // are required
+    this.walkController = new AbortController()
+    setMaxListeners(Infinity, this.walkController.signal)
+
+    const signal = anySignal([this.walkController.signal, this.shutdownController.signal])
+    setMaxListeners(Infinity, signal)
+
+    const start = Date.now()
+    let found = 0
+
+    Promise.resolve().then(async () => {
+      this.log('start walk')
+
+      // find peers until no more consumers are interested
+      while (this.walkers > 0) {
+        try {
+          for await (const peer of this.peerRouting.getClosestPeers(randomBytes(32), { signal })) {
+            signal.throwIfAborted()
+
+            this.log('found peer %p', peer.id)
+            found++
+            this.safeDispatchEvent('walk:peer', {
+              detail: peer
+            })
+
+            // if we only have one consumer, pause the query until they request
+            // another random peer or they signal they are no longer interested
+            if (this.walkers === 1 && this.needNext != null) {
+              await raceSignal(this.needNext.promise, signal)
+            }
+          }
+        } catch (err) {
+          this.log.error('randomwalk errored', err)
+
+          this.safeDispatchEvent('walk:error', {
+            detail: err
+          })
+        }
+      }
+    })
+      .catch(err => {
+        this.log.error('randomwalk errored', err)
+      })
+      .finally(() => {
+        this.log('finished walk, found %d peers after %dms', found, Date.now() - start)
+        this.walking = false
+      })
+  }
+}

package/src/transport-manager.ts

@@ -106,7 +106,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
    * Dials the given Multiaddr over it's supported transport
    */
   async dial (ma: Multiaddr, options?: AbortOptions): Promise<Connection> {
-    const transport = this.transportForMultiaddr(ma)
+    const transport = this.dialTransportForMultiaddr(ma)
 
     if (transport == null) {
       throw new CodeError(`No transport available for address ${String(ma)}`, codes.ERR_TRANSPORT_UNAVAILABLE)
@@ -156,9 +156,22 @@ export class DefaultTransportManager implements TransportManager, Startable {
   /**
    * Finds a transport that matches the given Multiaddr
    */
-  transportForMultiaddr (ma: Multiaddr): Transport | undefined {
+  dialTransportForMultiaddr (ma: Multiaddr): Transport | undefined {
     for (const transport of this.transports.values()) {
-      const addrs = transport.filter([ma])
+      const addrs = transport.dialFilter([ma])
+
+      if (addrs.length > 0) {
+        return transport
+      }
+    }
+  }
+
+  /**
+   * Finds a transport that matches the given Multiaddr
+   */
+  listenTransportForMultiaddr (ma: Multiaddr): Transport | undefined {
+    for (const transport of this.transports.values()) {
+      const addrs = transport.listenFilter([ma])
 
       if (addrs.length > 0) {
         return transport
@@ -182,7 +195,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
     const couldNotListen = []
 
     for (const [key, transport] of this.transports.entries()) {
-      const supportedAddrs = transport.filter(addrs)
+      const supportedAddrs = transport.listenFilter(addrs)
       const tasks = []
 
       // For each supported multiaddr, create a listener

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '1.4.3'
+export const version = '1.5.0-9d13a2f6a'
 export const name = 'libp2p'

package/dist/typedoc-urls.json

@@ -1,14 +0,0 @@
-{
-  "Libp2pInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.Libp2pInit.html",
-  ".:Libp2pInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.Libp2pInit.html",
-  "Libp2pOptions": "https://libp2p.github.io/js-libp2p/types/libp2p.index.Libp2pOptions.html",
-  ".:Libp2pOptions": "https://libp2p.github.io/js-libp2p/types/libp2p.index.Libp2pOptions.html",
-  "ServiceFactoryMap": "https://libp2p.github.io/js-libp2p/types/libp2p.index.ServiceFactoryMap.html",
-  ".:ServiceFactoryMap": "https://libp2p.github.io/js-libp2p/types/libp2p.index.ServiceFactoryMap.html",
-  "createLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.createLibp2p.html",
-  ".:createLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.createLibp2p.html",
-  "name": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.name.html",
-  "./version:name": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.name.html",
-  "version": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.version.html",
-  "./version:version": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.version.html"
-}