@libp2p/utils 6.7.1 → 6.7.2-8484de8a2

package/src/socket-writer.ts

@@ -0,0 +1,64 @@
+import stream from 'node:stream'
+import { Uint8ArrayList } from 'uint8arraylist'
+
+export interface SocketWriter {
+  /**
+   * Write any available data into the socket, if the socket's internal write
+   * buffer has available capacity
+   */
+  pull (): boolean
+
+  /**
+   * Write data into the socket, returns false if the socket's internal write
+   * buffer is at capacity
+   */
+  write (data: Uint8Array | Uint8Array[] | Uint8ArrayList): boolean
+}
+
+/**
+ * @deprecated delete if unused
+ */
+export function socketWriter (socket: stream.Duplex): SocketWriter {
+  const queue = new Uint8ArrayList()
+
+  return {
+    pull (): boolean {
+      if (socket.writableNeedDrain) {
+        return false
+      }
+
+      for (const buf of queue) {
+        queue.consume(buf.byteLength)
+
+        if (!socket.write(buf)) {
+          // continue writing after drain event. this is a synchronous operation
+          // so it will not interleave with the `this.writeToSocket()`
+          // invocation in this.sendData so all data will be sent in-order
+          if (queue.byteLength > 0) {
+            socket.once('drain', () => {
+              this.pull()
+            })
+          }
+
+          return false
+        }
+      }
+
+      return true
+    },
+
+    write (data: Uint8Array | Uint8Array[] | Uint8ArrayList): boolean {
+      if (Array.isArray(data)) {
+        queue.appendAll(data)
+      } else {
+        queue.append(data)
+      }
+
+      if (socket.writableNeedDrain) {
+        return false
+      }
+
+      return this.pull()
+    }
+  }
+}

package/src/stream-pair.ts

@@ -0,0 +1,90 @@
+import { pEvent } from 'p-event'
+import { mockMuxer } from './mock-muxer.ts'
+import { multiaddrConnectionPair } from './multiaddr-connection-pair.ts'
+import { echo } from './stream-utils.ts'
+import type { MockMultiaddrConnectionInit } from './multiaddr-connection-pair.ts'
+import type { Stream, StreamOptions } from '@libp2p/interface'
+
+export interface StreamPairOptions {
+  /**
+   * How long to wait in ms before sending messages
+   *
+   * @default 1
+   */
+  delay?: number
+
+  /**
+   * If more than this many messages are sent within delay, write backpressure
+   * will be applied
+   */
+  capacity?: number
+
+  /**
+   * Simulate having pre-negotiated a protocol by passing it here
+   */
+  protocol?: string
+
+  /**
+   * Configuration options for the outbound stream
+   */
+  outbound?: StreamOptions
+
+  /**
+   * Configuration options for underlying outbound connection
+   */
+  outboundConnection?: Partial<MockMultiaddrConnectionInit>
+
+  /**
+   * Configuration options for the inbound stream
+   */
+  inbound?: StreamOptions
+
+  /**
+   * Configuration options for underlying inbound connection
+   */
+  inboundConnection?: Partial<MockMultiaddrConnectionInit>
+}
+
+/**
+ * Returns two streams connected to each other with a slight delay in sending
+ * messages to simulate a network
+ */
+export async function streamPair (opts: StreamPairOptions = {}): Promise<[Stream, Stream]> {
+  const [outboundConnection, inboundConnection] = multiaddrConnectionPair({
+    ...opts,
+    outbound: opts.outboundConnection,
+    inbound: opts.inboundConnection
+  })
+
+  const localMuxer = mockMuxer({
+    streamOptions: opts.outbound
+  }).createStreamMuxer(outboundConnection)
+  const remoteMuxer = mockMuxer({
+    streamOptions: opts.inbound
+  }).createStreamMuxer(inboundConnection)
+
+  const [
+    inboundStream,
+    outboundStream
+  ] = await Promise.all([
+    pEvent<'stream', CustomEvent<Stream>>(remoteMuxer, 'stream').then(evt => {
+      return evt.detail
+    }),
+    localMuxer.createStream({
+      ...opts.outbound,
+      protocol: opts.protocol
+    })
+  ])
+
+  return [
+    outboundStream,
+    inboundStream
+  ]
+}
+
+export async function echoStream (opts: StreamPairOptions = {}): Promise<Stream> {
+  const [outbound, inbound] = await streamPair(opts)
+  echo(inbound)
+
+  return outbound
+}