libp2p 2.10.0 → 3.0.0-049bfa0fa

package/src/registrar.ts

@@ -1,8 +1,7 @@
 import { InvalidParametersError } from '@libp2p/interface'
-import { mergeOptions } from '@libp2p/utils/merge-options'
-import { trackedMap } from '@libp2p/utils/tracked-map'
-import * as errorsJs from './errors.js'
-import type { IdentifyResult, Libp2pEvents, Logger, PeerUpdate, PeerId, PeerStore, Topology, StreamHandler, StreamHandlerRecord, StreamHandlerOptions, AbortOptions, Metrics } from '@libp2p/interface'
+import { trackedMap } from '@libp2p/utils'
+import { DuplicateProtocolHandlerError, UnhandledProtocolError } from './errors.js'
+import type { IdentifyResult, Libp2pEvents, Logger, PeerUpdate, PeerId, PeerStore, Topology, StreamHandler, StreamHandlerRecord, StreamHandlerOptions, AbortOptions, Metrics, StreamMiddleware } from '@libp2p/interface'
 import type { Registrar as RegistrarInterface } from '@libp2p/interface-internal'
 import type { ComponentLogger } from '@libp2p/logger'
 import type { TypedEventTarget } from 'main-event'
@@ -26,10 +25,12 @@ export class Registrar implements RegistrarInterface {
   private readonly topologies: Map<string, Map<string, Topology>>
   private readonly handlers: Map<string, StreamHandlerRecord>
   private readonly components: RegistrarComponents
+  private readonly middleware: Map<string, StreamMiddleware[]>
 
   constructor (components: RegistrarComponents) {
     this.components = components
     this.log = components.logger.forComponent('libp2p:registrar')
+    this.middleware = new Map()
     this.topologies = new Map()
     components.metrics?.registerMetricGroup('libp2p_registrar_topologies', {
       calculate: () => {
@@ -68,7 +69,7 @@ export class Registrar implements RegistrarInterface {
     const handler = this.handlers.get(protocol)
 
     if (handler == null) {
-      throw new errorsJs.UnhandledProtocolError(`No handler registered for protocol ${protocol}`)
+      throw new UnhandledProtocolError(`No handler registered for protocol ${protocol}`)
     }
 
     return handler
@@ -91,17 +92,16 @@ export class Registrar implements RegistrarInterface {
    */
   async handle (protocol: string, handler: StreamHandler, opts?: StreamHandlerOptions): Promise<void> {
     if (this.handlers.has(protocol) && opts?.force !== true) {
-      throw new errorsJs.DuplicateProtocolHandlerError(`Handler already registered for protocol ${protocol}`)
+      throw new DuplicateProtocolHandlerError(`Handler already registered for protocol ${protocol}`)
     }
 
-    const options = mergeOptions.bind({ ignoreUndefined: true })({
-      maxInboundStreams: DEFAULT_MAX_INBOUND_STREAMS,
-      maxOutboundStreams: DEFAULT_MAX_OUTBOUND_STREAMS
-    }, opts)
-
     this.handlers.set(protocol, {
       handler,
-      options
+      options: {
+        maxInboundStreams: DEFAULT_MAX_INBOUND_STREAMS,
+        maxOutboundStreams: DEFAULT_MAX_OUTBOUND_STREAMS,
+        ...opts
+      }
     })
 
     // Add new protocol to self protocols in the peer store
@@ -165,69 +165,89 @@ export class Registrar implements RegistrarInterface {
     }
   }
 
+  use (protocol: string, middleware: StreamMiddleware[]): void {
+    this.middleware.set(protocol, middleware)
+  }
+
+  unuse (protocol: string): void {
+    this.middleware.delete(protocol)
+  }
+
+  getMiddleware (protocol: string): StreamMiddleware[] {
+    return this.middleware.get(protocol) ?? []
+  }
+
   /**
    * Remove a disconnected peer from the record
    */
-  _onDisconnect (evt: CustomEvent<PeerId>): void {
+  async _onDisconnect (evt: CustomEvent<PeerId>): Promise<void> {
     const remotePeer = evt.detail
     const options = {
       signal: AbortSignal.timeout(5_000)
     }
 
-    void this.components.peerStore.get(remotePeer, options)
-      .then(peer => {
-        for (const protocol of peer.protocols) {
-          const topologies = this.topologies.get(protocol)
+    try {
+      const peer = await this.components.peerStore.get(remotePeer, options)
 
-          if (topologies == null) {
-            // no topologies are interested in this protocol
-            continue
-          }
+      for (const protocol of peer.protocols) {
+        const topologies = this.topologies.get(protocol)
 
-          for (const topology of topologies.values()) {
+        if (topologies == null) {
+          // no topologies are interested in this protocol
+          continue
+        }
+
+        await Promise.all(
+          [...topologies.values()].map(async topology => {
             if (topology.filter?.has(remotePeer) === false) {
-              continue
+              return
             }
 
             topology.filter?.remove(remotePeer)
-            topology.onDisconnect?.(remotePeer)
-          }
-        }
-      })
-      .catch(err => {
-        if (err.name === 'NotFoundError') {
-          // peer has not completed identify so they are not in the peer store
-          return
-        }
+            await topology.onDisconnect?.(remotePeer)
+          })
+        )
+      }
+    } catch (err: any) {
+      if (err.name === 'NotFoundError') {
+        // peer has not completed identify so they are not in the peer store
+        return
+      }
 
-        this.log.error('could not inform topologies of disconnecting peer %p', remotePeer, err)
-      })
+      this.log.error('could not inform topologies of disconnecting peer %p - %e', remotePeer, err)
+    }
   }
 
   /**
    * When a peer is updated, if they have removed supported protocols notify any
    * topologies interested in the removed protocols.
    */
-  _onPeerUpdate (evt: CustomEvent<PeerUpdate>): void {
+  async _onPeerUpdate (evt: CustomEvent<PeerUpdate>): Promise<void> {
     const { peer, previous } = evt.detail
     const removed = (previous?.protocols ?? []).filter(protocol => !peer.protocols.includes(protocol))
 
-    for (const protocol of removed) {
-      const topologies = this.topologies.get(protocol)
+    try {
+      for (const protocol of removed) {
+        const topologies = this.topologies.get(protocol)
 
-      if (topologies == null) {
-        // no topologies are interested in this protocol
-        continue
-      }
-
-      for (const topology of topologies.values()) {
-        if (topology.filter?.has(peer.id) === false) {
+        if (topologies == null) {
+          // no topologies are interested in this protocol
           continue
         }
 
-        topology.filter?.remove(peer.id)
-        topology.onDisconnect?.(peer.id)
+        await Promise.all(
+          [...topologies.values()].map(async topology => {
+            if (topology.filter?.has(peer.id) === false) {
+              return
+            }
+
+            topology.filter?.remove(peer.id)
+            await topology.onDisconnect?.(peer.id)
+          })
+        )
       }
+    } catch (err: any) {
+      this.log.error('could not inform topologies of updated peer %p - %e', peer.id, err)
     }
   }
 
@@ -235,31 +255,37 @@ export class Registrar implements RegistrarInterface {
    * After identify has completed and we have received the list of supported
    * protocols, notify any topologies interested in those protocols.
    */
-  _onPeerIdentify (evt: CustomEvent<IdentifyResult>): void {
+  async _onPeerIdentify (evt: CustomEvent<IdentifyResult>): Promise<void> {
     const protocols = evt.detail.protocols
     const connection = evt.detail.connection
     const peerId = evt.detail.peerId
 
-    for (const protocol of protocols) {
-      const topologies = this.topologies.get(protocol)
+    try {
+      for (const protocol of protocols) {
+        const topologies = this.topologies.get(protocol)
 
-      if (topologies == null) {
-        // no topologies are interested in this protocol
-        continue
-      }
-
-      for (const topology of topologies.values()) {
-        if (connection.limits != null && topology.notifyOnLimitedConnection !== true) {
+        if (topologies == null) {
+          // no topologies are interested in this protocol
           continue
         }
 
-        if (topology.filter?.has(peerId) === true) {
-          continue
-        }
+        await Promise.all(
+          [...topologies.values()].map(async topology => {
+            if (connection.limits != null && topology.notifyOnLimitedConnection !== true) {
+              return
+            }
+
+            if (topology.filter?.has(peerId) === true) {
+              return
+            }
 
-        topology.filter?.add(peerId)
-        topology.onConnect?.(peerId, connection)
+            topology.filter?.add(peerId)
+            await topology.onConnect?.(peerId, connection)
+          })
+        )
       }
+    } catch (err: any) {
+      this.log.error('could not inform topologies of updated peer after identify %p - %e', peerId, err)
     }
   }
 }

package/src/transport-manager.ts

@@ -1,5 +1,5 @@
 import { FaultTolerance, InvalidParametersError, NotStartedError } from '@libp2p/interface'
-import { trackedMap } from '@libp2p/utils/tracked-map'
+import { trackedMap } from '@libp2p/utils'
 import { IP4, IP6 } from '@multiformats/multiaddr-matcher'
 import { CustomProgressEvent } from 'progress-events'
 import { TransportUnavailableError, UnsupportedListenAddressError, UnsupportedListenAddressesError } from './errors.js'
@@ -318,7 +318,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
     throw new UnsupportedListenAddressesError(`Some configured addresses failed to be listened on, you may need to remove one or more listen addresses from your configuration or set \`transportManager.faultTolerance\` to NO_FATAL:\n${
       [...listenStats.errors.entries()].map(([addr, err]) => {
         return `
-  ${addr}: ${`${err.stack ?? err}`.split('\n').join('\n  ')}
+  ${addr}: ${`${getErrorMessage(err)}`.split('\n').join('\n  ')}
 `
       }).join('')
     }`)
@@ -376,3 +376,19 @@ export class DefaultTransportManager implements TransportManager, Startable {
     await Promise.all(tasks)
   }
 }
+
+/**
+ * Not every error has useful fields, browsers particularly often have an empty
+ * string for the "stack" so try a few different fields here.
+ */
+function getErrorMessage (err: Error): string {
+  if (err.stack != null && err.stack.trim() !== '') {
+    return err.stack
+  }
+
+  if (err.message != null) {
+    return err.message
+  }
+
+  return err.toString()
+}