@libp2p/utils 6.7.2-8484de8a2 → 6.7.2-87bc8d4fb

package/src/abstract-stream-muxer.ts

@@ -1,239 +0,0 @@
-import { MuxerClosedError, TypedEventEmitter } from '@libp2p/interface'
-import { raceSignal } from 'race-signal'
-import { MaxEarlyStreamsError } from './errors.ts'
-import { isPromise } from './is-promise.ts'
-import type { AbstractStream } from './abstract-stream.ts'
-import type { AbortOptions, CounterGroup, CreateStreamOptions, EventHandler, Logger, MessageStream, Stream, StreamCloseEvent, StreamMessageEvent, StreamMuxer, StreamMuxerEvents, StreamMuxerOptions, StreamMuxerStatus, StreamOptions } from '@libp2p/interface'
-import type { Uint8ArrayList } from 'uint8arraylist'
-
-export interface AbstractStreamMuxerInit extends StreamMuxerOptions {
-  /**
-   * The protocol name for the muxer
-   */
-  protocol: string
-
-  /**
-   * The name of the muxer, used to create a new logging scope from the passed
-   * connection's logger
-   */
-  name: string
-
-  /**
-   * A counter for muxer metrics
-   */
-  metrics?: CounterGroup
-}
-
-export abstract class AbstractStreamMuxer <MuxedStream extends AbstractStream = AbstractStream> extends TypedEventEmitter<StreamMuxerEvents<MuxedStream>> implements StreamMuxer<MuxedStream> {
-  public streams: MuxedStream[]
-  public protocol: string
-  public status: StreamMuxerStatus
-
-  protected log: Logger
-  protected maConn: MessageStream
-  protected streamOptions?: StreamOptions
-  protected earlyStreams: MuxedStream[]
-  protected maxEarlyStreams: number
-
-  private readonly metrics?: CounterGroup
-
-  constructor (maConn: MessageStream, init: AbstractStreamMuxerInit) {
-    super()
-
-    this.maConn = maConn
-    this.protocol = init.protocol
-    this.streams = []
-    this.earlyStreams = []
-    this.status = 'open'
-    this.log = maConn.log.newScope(init.name)
-    this.streamOptions = init.streamOptions
-    this.maxEarlyStreams = init.maxEarlyStreams ?? 10
-    this.metrics = init.metrics
-
-    // read/write all data from/to underlying maConn
-    const muxerMaConnOnMessage = (evt: StreamMessageEvent): void => {
-      try {
-        this.onData(evt.data)
-      } catch (err: any) {
-        this.abort(err)
-        this.maConn.abort(err)
-      }
-    }
-    this.maConn.addEventListener('message', muxerMaConnOnMessage)
-
-    // signal stream writers when the underlying connection can accept more data
-    const muxerMaConnOnDrain = (): void => {
-      this.log('underlying stream drained, signal %d streams to continue writing', this.streams.length)
-
-      this.streams.forEach(stream => {
-        stream.onMuxerDrain()
-      })
-    }
-    this.maConn.addEventListener('drain', muxerMaConnOnDrain)
-
-    const muxerOnMaConnClose = (): void => {
-      this.log('underlying stream closed with status %s and %d streams', this.status, this.streams.length)
-      this.onTransportClosed()
-    }
-    this.maConn.addEventListener('close', muxerOnMaConnClose)
-  }
-
-  send (data: Uint8Array | Uint8ArrayList): boolean {
-    const result = this.maConn.send(data)
-
-    if (result === false) {
-      this.log('underlying stream saturated, signal %d streams to pause writing', this.streams.length)
-
-      this.streams.forEach(stream => {
-        stream.onMuxerNeedsDrain()
-      })
-    }
-
-    return result
-  }
-
-  async close (options?: AbortOptions): Promise<void> {
-    if (this.status === 'closed' || this.status === 'closing') {
-      return
-    }
-
-    this.status = 'closing'
-
-    await raceSignal(Promise.all(
-      [...this.streams].map(async s => {
-        await s.close(options)
-      })
-    ), options?.signal)
-
-    this.status = 'closed'
-  }
-
-  abort (err: Error): void {
-    if (this.status === 'closed') {
-      return
-    }
-
-    this.status = 'closing'
-
-    ;[...this.streams].forEach(s => {
-      s.abort(err)
-    })
-
-    this.status = 'closed'
-  }
-
-  onTransportClosed (err?: Error): void {
-    this.status = 'closing'
-
-    try {
-      [...this.streams].forEach(stream => {
-        stream.onTransportClosed(err)
-      })
-    } catch (err: any) {
-      this.abort(err)
-    }
-
-    this.status = 'closed'
-  }
-
-  async createStream (options?: CreateStreamOptions): Promise<MuxedStream> {
-    if (this.status !== 'open') {
-      throw new MuxerClosedError()
-    }
-
-    let stream = this.onCreateStream({
-      ...this.streamOptions,
-      ...options
-    })
-
-    if (isPromise(stream)) {
-      stream = await stream
-    }
-
-    this.streams.push(stream)
-    this.cleanUpStream(stream)
-
-    return stream
-  }
-
-  /**
-   * Extending classes should invoke this method when a new stream was created
-   * by the remote muxer
-   */
-  onRemoteStream (stream: MuxedStream): void {
-    this.streams.push(stream)
-    this.cleanUpStream(stream)
-
-    if (this.listenerCount('stream') === 0) {
-      // no listener has been added for the stream event yet, store the stream
-      // to emit it later
-      this.earlyStreams.push(stream)
-
-      if (this.earlyStreams.length > this.maxEarlyStreams) {
-        this.abort(new MaxEarlyStreamsError(`Too many early streams were opened - ${this.earlyStreams.length}/${this.maxEarlyStreams}`))
-      }
-
-      return
-    }
-
-    this.safeDispatchEvent('stream', {
-      detail: stream
-    })
-  }
-
-  private cleanUpStream (stream: Stream): void {
-    const muxerOnStreamEnd = (evt: StreamCloseEvent): void => {
-      const index = this.streams.findIndex(s => s === stream)
-
-      if (index !== -1) {
-        this.streams.splice(index, 1)
-      }
-
-      if (evt.error != null) {
-        if (evt.local) {
-          this.metrics?.increment({ [`${stream.direction}_stream_reset`]: true })
-        } else {
-          this.metrics?.increment({ [`${stream.direction}_stream_abort`]: true })
-        }
-      } else {
-        this.metrics?.increment({ [`${stream.direction}_stream_end`]: true })
-      }
-    }
-    stream.addEventListener('close', muxerOnStreamEnd)
-
-    this.metrics?.increment({ [`${stream.direction}_stream`]: true })
-  }
-
-  addEventListener<K extends keyof StreamMuxerEvents<MuxedStream>>(type: K, listener: EventHandler<StreamMuxerEvents<MuxedStream>[K]> | null, options?: boolean | AddEventListenerOptions): void
-  addEventListener (type: string, listener: EventHandler<Event>, options?: boolean | AddEventListenerOptions): void
-  addEventListener (...args: any[]): void {
-    // @ts-expect-error cannot ensure args has enough members
-    super.addEventListener.apply(this, args)
-
-    // if a 'stream' listener is being added and we have early streams, emit
-    // them
-    if (args[0] === 'stream' && this.earlyStreams.length > 0) {
-      // event listeners can be added in constructors and often use object
-      // properties - if this the case we can access a class member before it
-      // has been initialized so dispatch the message in the microtask queue
-      queueMicrotask(() => {
-        this.earlyStreams.forEach(stream => {
-          this.safeDispatchEvent('stream', {
-            detail: stream
-          })
-        })
-        this.earlyStreams = []
-      })
-    }
-  }
-
-  /**
-   * A new outgoing stream needs to be created
-   */
-  abstract onCreateStream (options: CreateStreamOptions): MuxedStream | Promise<MuxedStream>
-
-  /**
-   * Multiplexed data was received from the remote muxer
-   */
-  abstract onData (data: Uint8Array | Uint8ArrayList): void
-}

package/src/length-prefixed-decoder.ts

@@ -1,98 +0,0 @@
-import { InvalidParametersError } from '@libp2p/interface'
-import * as varint from 'uint8-varint'
-import { Uint8ArrayList } from 'uint8arraylist'
-import { InvalidMessageLengthError } from './stream-utils.ts'
-
-const DEFAULT_MAX_BUFFER_SIZE = 1024 * 1024 * 4
-const DEFAULT_MAX_DATA_LENGTH = 1024 * 1024 * 4
-
-export interface LengthPrefixedDecoderInit {
-  /**
-   * How large the internal buffer is allowed to grow - attempting to store more
-   * data than this will throw
-   */
-  maxBufferSize?: number
-
-  /**
-   * Throw an error if the message that would be read from the buffer is larger
-   * than this value
-   */
-  maxDataLength?: number
-
-  /**
-   * Read a varint from the buffer
-   */
-  lengthDecoder?(data: Uint8ArrayList | Uint8Array): number
-
-  /**
-   * Return how many bytes it takes to encode the passed value
-   */
-  encodingLength?(length: number): number
-}
-
-/**
- * Decode length-prefixed data from a buffer
- */
-export class LengthPrefixedDecoder {
-  private readonly buffer: Uint8ArrayList
-  private readonly maxBufferSize: number
-  private readonly lengthDecoder: (data: Uint8ArrayList | Uint8Array) => number
-  private readonly maxDataLength: number
-  private readonly encodingLength: (length: number) => number
-
-  constructor (init: LengthPrefixedDecoderInit = {}) {
-    this.buffer = new Uint8ArrayList()
-    this.maxBufferSize = init.maxBufferSize ?? DEFAULT_MAX_BUFFER_SIZE
-    this.maxDataLength = init.maxDataLength ?? DEFAULT_MAX_DATA_LENGTH
-    this.lengthDecoder = init.lengthDecoder ?? varint.decode
-    this.encodingLength = init.encodingLength ?? varint.encodingLength
-  }
-
-  /**
-   * Decodes length-prefixed data
-   */
-  * decode (buf: Uint8Array | Uint8ArrayList): Generator<Uint8ArrayList> {
-    this.buffer.append(buf)
-
-    if (this.buffer.byteLength > this.maxBufferSize) {
-      throw new InvalidParametersError(`Buffer length limit exceeded - ${this.buffer.byteLength}/${this.maxBufferSize}`)
-    }
-
-    // Loop to consume as many bytes from the buffer as possible
-    // Eg: when a single chunk contains several frames
-    while (true) {
-      let dataLength: number
-
-      try {
-        dataLength = this.lengthDecoder(this.buffer)
-      } catch (err) {
-        if (err instanceof RangeError) {
-          // ignore errors where we don't have enough data to read the length
-          // prefix
-          break
-        }
-
-        throw err
-      }
-
-      if (dataLength < 0 || dataLength > this.maxDataLength) {
-        throw new InvalidMessageLengthError('Invalid message length')
-      }
-
-      const lengthLength = this.encodingLength(dataLength)
-      const chunkLength = lengthLength + dataLength
-
-      if (this.buffer.byteLength >= chunkLength) {
-        const buf = this.buffer.sublist(lengthLength, chunkLength)
-
-        this.buffer.consume(chunkLength)
-
-        if (buf.byteLength > 0) {
-          yield buf
-        }
-      } else {
-        break
-      }
-    }
-  }
-}

package/src/message-queue.ts

@@ -1,156 +0,0 @@
-import { StreamMessageEvent } from '@libp2p/interface'
-import delay from 'delay'
-import { TypedEventEmitter } from 'main-event'
-import { raceSignal } from 'race-signal'
-import { isUint8ArrayList, Uint8ArrayList } from 'uint8arraylist'
-import { Queue } from './queue/index.js'
-import type { AbortOptions, Logger } from '@libp2p/interface'
-
-const DEFAULT_CHUNK_SIZE = 1024 * 64
-
-export interface MessageQueueEvents {
-  /**
-   * Message data
-   */
-  message: StreamMessageEvent
-
-  /**
-   * Emitted when the queue is empty
-   */
-  drain: Event
-
-  /**
-   * The remote closed the connection abruptly
-   */
-  reset: Event
-}
-
-export interface MessageQueueInit {
-  /**
-   * How much delay there should be between each message send in ms (note that
-   * even 0 introduces a small delay)
-   *
-   * @default 0
-   */
-  delay?: number
-
-  /**
-   * How many messages to hold in the send queue before applying backpressure to
-   * the sender
-   */
-  capacity?: number
-
-  /**
-   * Data messages larger than this size will be chunked into smaller messages.
-   *
-   * Defaults to the maximum TCP package size.
-   *
-   * @default 65_536
-   */
-  chunkSize?: number
-}
-
-interface MessageQueueJobOptions extends AbortOptions {
-  evt: Event
-}
-
-/**
- * Accepts events to emit after a short delay, and with a configurable maximum
- * queue capacity after which the send method will return false to let us
- * simulate write backpressure.
- */
-export class MessageQueue<Events> extends TypedEventEmitter<Events & MessageQueueEvents> {
-  public needsDrain: boolean
-
-  private queue: Queue<void, MessageQueueJobOptions>
-  private capacity: number
-  private delay: number
-  private log: Logger
-  private chunkSize: number
-
-  constructor (init: MessageQueueInit & { log: Logger }) {
-    super()
-
-    this.needsDrain = false
-    this.queue = new Queue({
-      concurrency: 1
-    })
-    this.capacity = init.capacity ?? 5
-    this.delay = init.delay ?? 0
-    this.log = init.log
-    this.chunkSize = init.chunkSize ?? DEFAULT_CHUNK_SIZE
-
-    this.queue.addEventListener('idle', () => {
-      if (this.needsDrain) {
-        this.log('network send queue drained')
-        this.needsDrain = false
-        this.safeDispatchEvent('drain')
-      } else {
-        this.log('network send queue idle')
-      }
-    })
-  }
-
-  send (evt: Event): boolean {
-    if (isMessageEvent(evt)) {
-      // chunk outgoing messages to match TCP packet sizes
-      const data = new Uint8ArrayList(evt.data)
-
-      while (data.byteLength > 0) {
-        const end = Math.min(this.chunkSize, data.byteLength)
-        const chunk = data.sublist(0, end)
-        data.consume(chunk.byteLength)
-
-        const chunkEvent = new StreamMessageEvent(chunk)
-
-        this.queue.add(async (opts) => {
-          if (this.delay > 0) {
-            await raceSignal(delay(this.delay), opts.signal)
-          }
-
-          this.dispatchEvent(opts.evt)
-        }, {
-          evt: chunkEvent
-        })
-      }
-    } else {
-      this.queue.add(async (opts) => {
-        if (this.delay > 0) {
-          await raceSignal(delay(this.delay), opts.signal)
-        }
-
-        this.dispatchEvent(opts.evt)
-      }, {
-        evt
-      })
-    }
-
-    if (this.queue.size >= this.capacity) {
-      this.log('network send queue full')
-      this.needsDrain = true
-      return false
-    }
-
-    return true
-  }
-
-  pause (): void {
-    this.queue.pause()
-  }
-
-  resume (): void {
-    this.queue.resume()
-  }
-
-  onIdle (): Promise<void> {
-    return this.queue.onIdle()
-  }
-
-  size (): number {
-    return this.queue.size
-  }
-}
-
-function isMessageEvent (evt?: any): evt is StreamMessageEvent {
-  return evt?.data instanceof Uint8Array || isUint8ArrayList(evt?.data)
-}