libp2p 0.37.2 → 0.37.3-de30c2c

package/src/registrar.ts

@@ -1,30 +1,24 @@
 import { logger } from '@libp2p/logger'
 import errCode from 'err-code'
 import { codes } from './errors.js'
-import { isTopology, Topology } from '@libp2p/interfaces/topology'
-import type { Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
-import type { PeerProtocolsChangeData } from '@libp2p/interfaces/peer-store'
-import type { Connection } from '@libp2p/interfaces/connection'
-import type { Components } from '@libp2p/interfaces/components'
+import { isTopology, StreamHandlerOptions, StreamHandlerRecord } from '@libp2p/interface-registrar'
+import merge from 'merge-options'
+import type { Registrar, StreamHandler, Topology } from '@libp2p/interface-registrar'
+import type { PeerProtocolsChangeData } from '@libp2p/interface-peer-store'
+import type { Connection } from '@libp2p/interface-connection'
+import type { Components } from '@libp2p/components'
 
 const log = logger('libp2p:registrar')
 
-function supportsProtocol (peerProtocols: string[], topologyProtocols: string[]) {
-  for (const peerProtocol of peerProtocols) {
-    if (topologyProtocols.includes(peerProtocol)) {
-      return true
-    }
-  }
-
-  return false
-}
+export const DEFAULT_MAX_INBOUND_STREAMS = 1
+export const DEFAULT_MAX_OUTBOUND_STREAMS = 1
 
 /**
  * Responsible for notifying registered protocols of events in the network.
  */
 export class DefaultRegistrar implements Registrar {
-  private readonly topologies: Map<string, { topology: Topology, protocols: string[] }>
-  private readonly handlers: Map<string, StreamHandler>
+  private readonly topologies: Map<string, Map<string, Topology>>
+  private readonly handlers: Map<string, StreamHandlerRecord>
   private readonly components: Components
 
   constructor (components: Components) {
@@ -42,57 +36,54 @@ export class DefaultRegistrar implements Registrar {
   }
 
   getProtocols () {
-    const protocols = new Set<string>()
-
-    for (const topology of this.topologies.values()) {
-      topology.protocols.forEach(protocol => protocols.add(protocol))
-    }
-
-    for (const protocol of this.handlers.keys()) {
-      protocols.add(protocol)
-    }
-
-    return Array.from(protocols).sort()
+    return Array.from(new Set<string>([
+      ...this.topologies.keys(),
+      ...this.handlers.keys()
+    ])).sort()
   }
 
   getHandler (protocol: string) {
     const handler = this.handlers.get(protocol)
 
     if (handler == null) {
-      throw new Error(`No handler registered for protocol ${protocol}`)
+      throw errCode(new Error(`No handler registered for protocol ${protocol}`), codes.ERR_NO_HANDLER_FOR_PROTOCOL)
     }
 
     return handler
   }
 
   getTopologies (protocol: string) {
-    const output: Topology[] = []
+    const topologies = this.topologies.get(protocol)
 
-    for (const { topology, protocols } of this.topologies.values()) {
-      if (protocols.includes(protocol)) {
-        output.push(topology)
-      }
+    if (topologies == null) {
+      return []
     }
 
-    return output
+    return [
+      ...topologies.values()
+    ]
   }
 
   /**
    * Registers the `handler` for each protocol
    */
-  async handle (protocols: string | string[], handler: StreamHandler): Promise<void> {
-    const protocolList = Array.isArray(protocols) ? protocols : [protocols]
+  async handle (protocol: string, handler: StreamHandler, opts?: StreamHandlerOptions): Promise<void> {
+    if (this.handlers.has(protocol)) {
+      throw errCode(new Error(`Handler already registered for protocol ${protocol}`), codes.ERR_PROTOCOL_HANDLER_ALREADY_REGISTERED)
+    }
 
-    for (const protocol of protocolList) {
-      if (this.handlers.has(protocol)) {
-        throw errCode(new Error(`Handler already registered for protocol ${protocol}`), codes.ERR_PROTOCOL_HANDLER_ALREADY_REGISTERED)
-      }
+    const options = merge.bind({ ignoreUndefined: true })({
+      maxInboundStreams: DEFAULT_MAX_INBOUND_STREAMS,
+      maxOutboundStreams: DEFAULT_MAX_OUTBOUND_STREAMS
+    }, opts)
 
-      this.handlers.set(protocol, handler)
-    }
+    this.handlers.set(protocol, {
+      handler,
+      options
+    })
 
     // Add new protocols to self protocols in the Protobook
-    await this.components.getPeerStore().protoBook.add(this.components.getPeerId(), protocolList)
+    await this.components.getPeerStore().protoBook.add(this.components.getPeerId(), [protocol])
   }
 
   /**
@@ -113,7 +104,7 @@ export class DefaultRegistrar implements Registrar {
   /**
    * Register handlers for a set of multicodecs given
    */
-  async register (protocols: string | string[], topology: Topology): Promise<string> {
+  async register (protocol: string, topology: Topology): Promise<string> {
     if (!isTopology(topology)) {
       log.error('topology must be an instance of interfaces/topology')
       throw errCode(new Error('topology must be an instance of interfaces/topology'), codes.ERR_INVALID_PARAMETERS)
@@ -122,10 +113,14 @@ export class DefaultRegistrar implements Registrar {
     // Create topology
     const id = `${(Math.random() * 1e9).toString(36)}${Date.now()}`
 
-    this.topologies.set(id, {
-      topology,
-      protocols: Array.isArray(protocols) ? protocols : [protocols]
-    })
+    let topologies = this.topologies.get(protocol)
+
+    if (topologies == null) {
+      topologies = new Map<string, Topology>()
+      this.topologies.set(protocol, topologies)
+    }
+
+    topologies.set(id, topology)
 
     // Set registrar
     await topology.setRegistrar(this)
@@ -137,7 +132,15 @@ export class DefaultRegistrar implements Registrar {
    * Unregister topology
    */
   unregister (id: string) {
-    this.topologies.delete(id)
+    for (const [protocol, topologies] of this.topologies.entries()) {
+      if (topologies.has(id)) {
+        topologies.delete(id)
+
+        if (topologies.size === 0) {
+          this.topologies.delete(protocol)
+        }
+      }
+    }
   }
 
   /**
@@ -148,8 +151,15 @@ export class DefaultRegistrar implements Registrar {
 
     void this.components.getPeerStore().protoBook.get(connection.remotePeer)
       .then(peerProtocols => {
-        for (const { topology, protocols } of this.topologies.values()) {
-          if (supportsProtocol(peerProtocols, protocols)) {
+        for (const protocol of peerProtocols) {
+          const topologies = this.topologies.get(protocol)
+
+          if (topologies == null) {
+            // no topologies are interested in this protocol
+            continue
+          }
+
+          for (const topology of topologies.values()) {
             topology.onDisconnect(connection.remotePeer)
           }
         }
@@ -168,14 +178,28 @@ export class DefaultRegistrar implements Registrar {
     const removed = oldProtocols.filter(protocol => !protocols.includes(protocol))
     const added = protocols.filter(protocol => !oldProtocols.includes(protocol))
 
-    for (const { topology, protocols } of this.topologies.values()) {
-      if (supportsProtocol(removed, protocols)) {
+    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()) {
         topology.onDisconnect(peerId)
       }
     }
 
-    for (const { topology, protocols } of this.topologies.values()) {
-      if (supportsProtocol(added, protocols)) {
+    for (const protocol of added) {
+      const topologies = this.topologies.get(protocol)
+
+      if (topologies == null) {
+        // no topologies are interested in this protocol
+        continue
+      }
+
+      for (const topology of topologies.values()) {
         const connection = this.components.getConnectionManager().getConnections(peerId)[0]
 
         if (connection == null) {

package/src/transport-manager.ts

@@ -2,13 +2,13 @@ import { logger } from '@libp2p/logger'
 import pSettle from 'p-settle'
 import { codes } from './errors.js'
 import errCode from 'err-code'
-import type { Listener, Transport, TransportManager, TransportManagerEvents } from '@libp2p/interfaces/transport'
+import type { Listener, Transport, TransportManager, TransportManagerEvents } from '@libp2p/interface-transport'
 import type { Multiaddr } from '@multiformats/multiaddr'
-import type { Connection } from '@libp2p/interfaces/connection'
+import type { Connection } from '@libp2p/interface-connection'
 import type { AbortOptions } from '@libp2p/interfaces'
 import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/components'
 import { trackedMap } from '@libp2p/tracked-map'
 
 const log = logger('libp2p:transports')

package/src/upgrader.ts

@@ -8,14 +8,16 @@ import { codes } from './errors.js'
 import { createConnection } from '@libp2p/connection'
 import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
 import { peerIdFromString } from '@libp2p/peer-id'
-import type { Connection, ProtocolStream, Stream } from '@libp2p/interfaces/connection'
-import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interfaces/connection-encrypter'
-import type { StreamMuxer, StreamMuxerFactory } from '@libp2p/interfaces/stream-muxer'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
-import type { MultiaddrConnection, Upgrader, UpgraderEvents } from '@libp2p/interfaces/transport'
+import type { MultiaddrConnection, Connection, Stream } from '@libp2p/interface-connection'
+import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface-connection-encrypter'
+import type { StreamMuxer, StreamMuxerFactory } from '@libp2p/interface-stream-muxer'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { Upgrader, UpgraderEvents } from '@libp2p/interface-transport'
 import type { Duplex } from 'it-stream-types'
-import type { Components } from '@libp2p/interfaces/components'
+import { Components, isInitializable } from '@libp2p/components'
 import type { AbortOptions } from '@libp2p/interfaces'
+import type { Registrar } from '@libp2p/interface-registrar'
+import { DEFAULT_MAX_INBOUND_STREAMS, DEFAULT_MAX_OUTBOUND_STREAMS } from './registrar.js'
 
 const log = logger('libp2p:upgrader')
 
@@ -43,6 +45,46 @@ export interface UpgraderInit {
   muxers: StreamMuxerFactory[]
 }
 
+function findIncomingStreamLimit (protocol: string, registrar: Registrar) {
+  try {
+    const { options } = registrar.getHandler(protocol)
+
+    return options.maxInboundStreams
+  } catch (err: any) {
+    if (err.code !== codes.ERR_NO_HANDLER_FOR_PROTOCOL) {
+      throw err
+    }
+  }
+
+  return DEFAULT_MAX_INBOUND_STREAMS
+}
+
+function findOutgoingStreamLimit (protocol: string, registrar: Registrar) {
+  try {
+    const { options } = registrar.getHandler(protocol)
+
+    return options.maxOutboundStreams
+  } catch (err: any) {
+    if (err.code !== codes.ERR_NO_HANDLER_FOR_PROTOCOL) {
+      throw err
+    }
+  }
+
+  return DEFAULT_MAX_OUTBOUND_STREAMS
+}
+
+function countStreams (protocol: string, direction: 'inbound' | 'outbound', connection: Connection) {
+  let streamCount = 0
+
+  connection.streams.forEach(stream => {
+    if (stream.stat.direction === direction && stream.stat.protocol === protocol) {
+      streamCount++
+    }
+  })
+
+  return streamCount
+}
+
 export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upgrader {
   private readonly components: Components
   private readonly connectionEncryption: Map<string, ConnectionEncrypter>
@@ -267,12 +309,12 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
     } = opts
 
     let muxer: StreamMuxer | undefined
-    let newStream: ((multicodecs: string[], options?: AbortOptions) => Promise<ProtocolStream>) | undefined
+    let newStream: ((multicodecs: string[], options?: AbortOptions) => Promise<Stream>) | undefined
     let connection: Connection // eslint-disable-line prefer-const
 
     if (muxerFactory != null) {
       // Create the muxer
-      muxer = muxerFactory.createStreamMuxer(this.components, {
+      muxer = muxerFactory.createStreamMuxer({
         // Run anytime a remote stream is created
         onIncomingStream: muxedStream => {
           if (connection == null) {
@@ -296,11 +338,24 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
                 return
               }
 
-              connection.addStream(muxedStream, { protocol })
+              const incomingLimit = findIncomingStreamLimit(protocol, this.components.getRegistrar())
+              const streamCount = countStreams(protocol, 'inbound', connection)
+
+              if (streamCount === incomingLimit) {
+                throw errCode(new Error('Too many incoming protocol streams'), codes.ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS)
+              }
+
+              muxedStream.stat.protocol = protocol
+
+              connection.addStream(muxedStream)
               this._onStream({ connection, stream: { ...muxedStream, ...stream }, protocol })
             })
             .catch(err => {
               log.error(err)
+
+              if (muxedStream.stat.timeline.close == null) {
+                muxedStream.close()
+              }
             })
         },
         // Run anytime a stream closes
@@ -309,7 +364,11 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
         }
       })
 
-      newStream = async (protocols: string[], options: AbortOptions = {}): Promise<ProtocolStream> => {
+      if (isInitializable(muxer)) {
+        muxer.init(this.components)
+      }
+
+      newStream = async (protocols: string[], options: AbortOptions = {}): Promise<Stream> => {
         if (muxer == null) {
           throw errCode(new Error('Stream is not multiplexed'), codes.ERR_MUXER_UNAVAILABLE)
         }
@@ -326,10 +385,30 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
             stream = metrics.trackStream({ stream, remotePeer, protocol })
           }
 
-          return { stream: { ...muxedStream, ...stream }, protocol }
+          const outgoingLimit = findOutgoingStreamLimit(protocol, this.components.getRegistrar())
+          const streamCount = countStreams(protocol, 'outbound', connection)
+
+          if (streamCount === outgoingLimit) {
+            throw errCode(new Error('Too many outgoing protocol streams'), codes.ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS)
+          }
+
+          muxedStream.stat.protocol = protocol
+
+          return {
+            ...muxedStream,
+            ...stream,
+            stat: {
+              ...muxedStream.stat,
+              protocol
+            }
+          }
         } catch (err: any) {
           log.error('could not create new stream', err)
 
+          if (muxedStream.stat.timeline.close == null) {
+            muxedStream.close()
+          }
+
           if (err.code != null) {
             throw err
           }
@@ -390,9 +469,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
         await maConn.close()
         // Ensure remaining streams are closed
         if (muxer != null) {
-          await Promise.all(muxer.streams.map(async stream => {
-            await stream.close()
-          }))
+          muxer.streams.forEach(s => s.close())
         }
       }
     })
@@ -409,8 +486,9 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
    */
   _onStream (opts: OnStreamOptions): void {
     const { connection, stream, protocol } = opts
-    const handler = this.components.getRegistrar().getHandler(protocol)
-    handler({ connection, stream, protocol })
+    const { handler } = this.components.getRegistrar().getHandler(protocol)
+
+    handler({ connection, stream })
   }
 
   /**