@libp2p/mplex 9.0.12-effcfaa8e → 10.0.0-551622a96

package/src/mplex.ts

@@ -1,23 +1,20 @@
-import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
-import { abortableSource } from 'abortable-iterator'
+/* eslint-disable complexity */
+
+import { CodeError } from '@libp2p/interface'
+import { closeSource } from '@libp2p/utils/close-source'
 import { pipe } from 'it-pipe'
-import { type PushableV, pushableV } from 'it-pushable'
+import { type Pushable, pushable } from 'it-pushable'
 import { RateLimiterMemory } from 'rate-limiter-flexible'
 import { toString as uint8ArrayToString } from 'uint8arrays'
 import { Decoder } from './decode.js'
 import { encode } from './encode.js'
 import { MessageTypes, MessageTypeNames, type Message } from './message-types.js'
 import { createStream, type MplexStream } from './stream.js'
-import type { MplexInit } from './index.js'
-import type { AbortOptions } from '@libp2p/interface'
-import type { Stream } from '@libp2p/interface/connection'
-import type { StreamMuxer, StreamMuxerInit } from '@libp2p/interface/stream-muxer'
+import type { MplexComponents, MplexInit } from './index.js'
+import type { AbortOptions, ComponentLogger, Logger, Stream, StreamMuxer, StreamMuxerInit } from '@libp2p/interface'
 import type { Sink, Source } from 'it-stream-types'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
-const log = logger('libp2p:mplex')
-
 const MAX_STREAMS_INBOUND_STREAMS_PER_CONNECTION = 1024
 const MAX_STREAMS_OUTBOUND_STREAMS_PER_CONNECTION = 1024
 const MAX_STREAM_BUFFER_SIZE = 1024 * 1024 * 4 // 4MB
@@ -52,19 +49,23 @@ export class MplexStreamMuxer implements StreamMuxer {
   public protocol = '/mplex/6.7.0'
 
   public sink: Sink<Source<Uint8ArrayList | Uint8Array>, Promise<void>>
-  public source: AsyncGenerator<Uint8Array>
+  public source: AsyncGenerator<Uint8ArrayList | Uint8Array>
 
+  private readonly log: Logger
   private _streamId: number
   private readonly _streams: { initiators: Map<number, MplexStream>, receivers: Map<number, MplexStream> }
   private readonly _init: MplexStreamMuxerInit
-  private readonly _source: PushableV<Message>
+  private readonly _source: Pushable<Message>
   private readonly closeController: AbortController
   private readonly rateLimiter: RateLimiterMemory
   private readonly closeTimeout: number
+  private readonly logger: ComponentLogger
 
-  constructor (init?: MplexStreamMuxerInit) {
+  constructor (components: MplexComponents, init?: MplexStreamMuxerInit) {
     init = init ?? {}
 
+    this.log = components.logger.forComponent('libp2p:mplex')
+    this.logger = components.logger
     this._streamId = 0
     this._streams = {
       /**
@@ -87,7 +88,7 @@ export class MplexStreamMuxer implements StreamMuxer {
     /**
      * An iterable source
      */
-    this._source = pushableV<Message>({
+    this._source = pushable<Message>({
       objectMode: true,
       onEnd: (): void => {
         // the source has ended, we can't write any more messages to gracefully
@@ -103,7 +104,7 @@ export class MplexStreamMuxer implements StreamMuxer {
     })
     this.source = pipe(
       this._source,
-      source => encode(source, this._init.minSendBytes)
+      source => encode(source)
     )
 
     /**
@@ -199,7 +200,7 @@ export class MplexStreamMuxer implements StreamMuxer {
   _newStream (options: { id: number, name: string, type: 'initiator' | 'receiver', registry: Map<number, MplexStream> }): MplexStream {
     const { id, name, type, registry } = options
 
-    log('new %s stream %s', type, id)
+    this.log('new %s stream %s', type, id)
 
     if (type === 'initiator' && this._streams.initiators.size === (this._init.maxOutboundStreams ?? MAX_STREAMS_OUTBOUND_STREAMS_PER_CONNECTION)) {
       throw new CodeError('Too many outbound streams open', 'ERR_TOO_MANY_OUTBOUND_STREAMS')
@@ -210,15 +211,15 @@ export class MplexStreamMuxer implements StreamMuxer {
     }
 
     const send = async (msg: Message): Promise<void> => {
-      if (log.enabled) {
-        log.trace('%s stream %s send', type, id, printMessage(msg))
+      if (this.log.enabled) {
+        this.log.trace('%s stream %s send', type, id, printMessage(msg))
       }
 
       this._source.push(msg)
     }
 
     const onEnd = (): void => {
-      log('%s stream with id %s and protocol %s ended', type, id, stream.protocol)
+      this.log('%s stream with id %s and protocol %s ended', type, id, stream.protocol)
       registry.delete(id)
 
       if (this._init.onStreamEnd != null) {
@@ -226,7 +227,7 @@ export class MplexStreamMuxer implements StreamMuxer {
       }
     }
 
-    const stream = createStream({ id, name, send, type, onEnd, maxMsgSize: this._init.maxMsgSize })
+    const stream = createStream({ id, name, send, type, onEnd, maxMsgSize: this._init.maxMsgSize, logger: this.logger })
     registry.set(id, stream)
     return stream
   }
@@ -237,11 +238,13 @@ export class MplexStreamMuxer implements StreamMuxer {
    */
   _createSink (): Sink<Source<Uint8ArrayList | Uint8Array>, Promise<void>> {
     const sink: Sink<Source<Uint8ArrayList | Uint8Array>, Promise<void>> = async source => {
-      try {
-        source = abortableSource(source, this.closeController.signal, {
-          returnOnAbort: true
-        })
+      const abortListener = (): void => {
+        closeSource(source, this.log)
+      }
+
+      this.closeController.signal.addEventListener('abort', abortListener)
 
+      try {
         const decoder = new Decoder(this._init.maxMsgSize, this._init.maxUnprocessedMessageQueueSize)
 
         for await (const chunk of source) {
@@ -252,8 +255,10 @@ export class MplexStreamMuxer implements StreamMuxer {
 
         this._source.end()
       } catch (err: any) {
-        log('error in sink', err)
+        this.log('error in sink', err)
         this._source.end(err) // End the source with an error
+      } finally {
+        this.closeController.signal.removeEventListener('abort', abortListener)
       }
     }
 
@@ -263,14 +268,14 @@ export class MplexStreamMuxer implements StreamMuxer {
   async _handleIncoming (message: Message): Promise<void> {
     const { id, type } = message
 
-    if (log.enabled) {
-      log.trace('incoming message', printMessage(message))
+    if (this.log.enabled) {
+      this.log.trace('incoming message', printMessage(message))
     }
 
     // Create a new stream?
     if (message.type === MessageTypes.NEW_STREAM) {
       if (this._streams.receivers.size === (this._init.maxInboundStreams ?? MAX_STREAMS_INBOUND_STREAMS_PER_CONNECTION)) {
-        log('too many inbound streams open')
+        this.log('too many inbound streams open')
 
         // not going to allow this stream, send the reset message manually
         // instead of setting it up just to tear it down
@@ -285,7 +290,7 @@ export class MplexStreamMuxer implements StreamMuxer {
         try {
           await this.rateLimiter.consume('new-stream', 1)
         } catch {
-          log('rate limit hit when opening too many new streams over the inbound stream limit - closing remote connection')
+          this.log('rate limit hit when opening too many new streams over the inbound stream limit - closing remote connection')
           // since there's no backpressure in mplex, the only thing we can really do to protect ourselves is close the connection
           this.abort(new Error('Too many open streams'))
           return
@@ -307,7 +312,7 @@ export class MplexStreamMuxer implements StreamMuxer {
     const stream = list.get(id)
 
     if (stream == null) {
-      log('missing stream %s for message type %s', id, MessageTypeNames[type])
+      this.log('missing stream %s for message type %s', id, MessageTypeNames[type])
 
       // if the remote keeps sending us messages for streams that have been
       // closed or were never opened they may be attacking us so if they do
@@ -315,7 +320,7 @@ export class MplexStreamMuxer implements StreamMuxer {
       try {
         await this.rateLimiter.consume('missing-stream', 1)
       } catch {
-        log('rate limit hit when receiving messages for streams that do not exist - closing remote connection')
+        this.log('rate limit hit when receiving messages for streams that do not exist - closing remote connection')
         // since there's no backpressure in mplex, the only thing we can really do to protect ourselves is close the connection
         this.abort(new Error('Too many messages for missing streams'))
         return
@@ -355,10 +360,10 @@ export class MplexStreamMuxer implements StreamMuxer {
           stream.reset()
           break
         default:
-          log('unknown message type %s', type)
+          this.log('unknown message type %s', type)
       }
     } catch (err: any) {
-      log.error('error while processing message', err)
+      this.log.error('error while processing message', err)
       stream.abort(err)
     }
   }

package/src/stream.ts

@@ -1,10 +1,10 @@
-import { AbstractStream, type AbstractStreamInit } from '@libp2p/interface/stream-muxer/stream'
-import { logger } from '@libp2p/logger'
+import { AbstractStream, type AbstractStreamInit } from '@libp2p/utils/abstract-stream'
 import { Uint8ArrayList } from 'uint8arraylist'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { MAX_MSG_SIZE } from './decode.js'
 import { InitiatorMessageTypes, ReceiverMessageTypes } from './message-types.js'
 import type { Message } from './message-types.js'
+import type { ComponentLogger } from '@libp2p/interface'
 
 export interface Options {
   id: number
@@ -13,6 +13,7 @@ export interface Options {
   onEnd?(err?: Error): void
   type?: 'initiator' | 'receiver'
   maxMsgSize?: number
+  logger: ComponentLogger
 }
 
 interface MplexStreamInit extends AbstractStreamInit {
@@ -87,6 +88,6 @@ export function createStream (options: Options): MplexStream {
     maxDataSize: maxMsgSize,
     onEnd,
     send,
-    log: logger(`libp2p:mplex:stream:${type}:${id}`)
+    log: options.logger.forComponent(`libp2p:mplex:stream:${type}:${id}`)
   })
 }