@libp2p/interface-compliance-tests 1.1.11 → 1.1.14

package/src/mocks/muxer.ts

@@ -2,244 +2,368 @@ import { Pushable, pushable } from 'it-pushable'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { abortableSource } from 'abortable-iterator'
+import { anySignal } from 'any-signal'
+import errCode from 'err-code'
+import { Logger, logger } from '@libp2p/logger'
+import * as ndjson from 'it-ndjson'
 import type { Stream } from '@libp2p/interfaces/connection'
 import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
 import type { Source } from 'it-stream-types'
+import { pipe } from 'it-pipe'
+import map from 'it-map'
+
+let muxers = 0
+let streams = 0
 
 interface DataMessage {
   id: string
   type: 'data'
+  direction: 'initiator' | 'recipient'
   chunk: string
 }
 
 interface ResetMessage {
   id: string
   type: 'reset'
+  direction: 'initiator' | 'recipient'
 }
 
 interface CloseMessage {
   id: string
   type: 'close'
+  direction: 'initiator' | 'recipient'
+}
+
+interface CreateMessage {
+  id: string
+  type: 'create'
+  direction: 'initiator'
 }
 
-type StreamMessage = DataMessage | ResetMessage | CloseMessage
+type StreamMessage = DataMessage | ResetMessage | CloseMessage | CreateMessage
 
 class MuxedStream {
   public id: string
   public input: Pushable<Uint8Array>
   public stream: Stream
+  public type: 'initiator' | 'recipient'
 
-  private sourceClosed: boolean
-  private sinkClosed: boolean
-  private readonly controller: AbortController
-  private readonly onEnd: () => void
+  private sinkEnded: boolean
+  private sourceEnded: boolean
+  private readonly abortController: AbortController
+  private readonly resetController: AbortController
+  private readonly log: Logger
 
-  constructor (opts: { id: string, push: Pushable<StreamMessage>, onEnd: () => void }) {
-    const { id, push, onEnd } = opts
+  constructor (opts: { id: string, type: 'initiator' | 'recipient', push: Pushable<StreamMessage>, onEnd: (err?: Error) => void }) {
+    const { id, type, push, onEnd } = opts
+
+    this.log = logger(`libp2p:mock-muxer:stream:${id}:${type}`)
 
     this.id = id
-    this.controller = new AbortController()
-    this.onEnd = onEnd
-    this.sourceClosed = false
-    this.sinkClosed = false
-    this.input = pushable<Uint8Array>({
-      onEnd: () => {
-        this.sourceClosed = true
-        this.maybeEndStream()
+    this.type = type
+    this.abortController = new AbortController()
+    this.resetController = new AbortController()
+
+    this.sourceEnded = false
+    this.sinkEnded = false
+
+    let endErr: Error | undefined
+
+    const onSourceEnd = (err?: Error) => {
+      if (this.sourceEnded) {
+        return
+      }
+
+      this.log('onSourceEnd sink ended? %s', this.sinkEnded)
+
+      this.sourceEnded = true
+
+      if (err != null && endErr == null) {
+        endErr = err
       }
+
+      if (this.sinkEnded) {
+        this.stream.timeline.close = Date.now()
+
+        if (onEnd != null) {
+          onEnd(endErr)
+        }
+      }
+    }
+
+    const onSinkEnd = (err?: Error) => {
+      if (this.sinkEnded) {
+        return
+      }
+
+      this.log('onSinkEnd source ended? %s', this.sourceEnded)
+
+      this.sinkEnded = true
+
+      if (err != null && endErr == null) {
+        endErr = err
+      }
+
+      if (this.sourceEnded) {
+        this.stream.timeline.close = Date.now()
+
+        if (onEnd != null) {
+          onEnd(endErr)
+        }
+      }
+    }
+
+    this.input = pushable<Uint8Array>({
+      onEnd: onSourceEnd
     })
+
     this.stream = {
       id,
       sink: async (source) => {
-        source = abortableSource(source, this.controller.signal)
+        source = abortableSource(source, anySignal([
+          this.abortController.signal,
+          this.resetController.signal
+        ]))
 
         try {
+          if (this.type === 'initiator') {
+            // If initiator, open a new stream
+            const createMsg: CreateMessage = {
+              id: this.id,
+              type: 'create',
+              direction: this.type
+            }
+            push.push(createMsg)
+          }
+
           for await (const chunk of source) {
             const dataMsg: DataMessage = {
               id,
               type: 'data',
-              chunk: uint8ArrayToString(chunk, 'base64')
+              chunk: uint8ArrayToString(chunk, 'base64'),
+              direction: this.type
             }
 
             push.push(dataMsg)
           }
+        } catch (err: any) {
+          if (err.type === 'aborted' && err.message === 'The operation was aborted') {
+            if (this.resetController.signal.aborted) {
+              err.message = 'stream reset'
+              err.code = 'ERR_STREAM_RESET'
+            }
 
-          const closeMsg: CloseMessage = {
-            id,
-            type: 'close'
+            if (this.abortController.signal.aborted) {
+              err.message = 'stream aborted'
+              err.code = 'ERR_STREAM_ABORT'
+            }
           }
 
-          push.push(closeMsg)
-        } catch (err) {
-          if (!this.controller.signal.aborted) {
-            throw err
+          // Send no more data if this stream was remotely reset
+          if (err.code !== 'ERR_STREAM_RESET') {
+            const resetMsg: ResetMessage = {
+              id,
+              type: 'reset',
+              direction: this.type
+            }
+            push.push(resetMsg)
           }
+
+          this.log('sink erred', err)
+
+          this.input.end(err)
+          onSinkEnd(err)
+          return
         }
 
-        this.closeSink()
-      },
-      source: this.input,
-      close: () => {
+        this.log('sink ended')
+
+        onSinkEnd()
+
         const closeMsg: CloseMessage = {
           id,
-          type: 'close'
+          type: 'close',
+          direction: this.type
         }
         push.push(closeMsg)
+      },
+      source: this.input,
 
-        this.closeSink()
-        this.closeSource()
+      // Close for reading
+      close: () => {
+        this.input.end()
       },
-      abort: () => {
-        const resetMsg: ResetMessage = {
-          id,
-          type: 'reset'
-        }
-        push.push(resetMsg)
 
-        this.closeSink()
-        this.closeSource()
+      // Close for reading and writing (local error)
+      abort: (err?: Error) => {
+        // End the source with the passed error
+        this.input.end()
+        this.abortController.abort()
+        onSinkEnd(err)
       },
-      reset: () => {
-        const resetMsg: ResetMessage = {
-          id,
-          type: 'reset'
-        }
-        push.push(resetMsg)
 
-        this.closeSink()
-        this.closeSource()
+      // Close immediately for reading and writing (remote error)
+      reset: () => {
+        const err = errCode(new Error('stream reset'), 'ERR_STREAM_RESET')
+        this.resetController.abort()
+        this.input.end(err)
+        onSinkEnd(err)
       },
       timeline: {
         open: Date.now()
       }
     }
   }
+}
 
-  maybeEndStream () {
-    if (this.stream.timeline.close != null) {
-      // already ended
-      return
-    }
+class MockMuxer implements Muxer {
+  public source: Source<Uint8Array>
+  public input: Pushable<Uint8Array>
+  public streamInput: Pushable<StreamMessage>
+  public name: string
+
+  private readonly registryInitiatorStreams: Map<string, MuxedStream>
+  private readonly registryRecipientStreams: Map<string, MuxedStream>
+  private readonly options: MuxerOptions
+
+  private readonly log: Logger
+
+  constructor (options?: MuxerOptions) {
+    this.name = `muxer:${muxers++}`
+    this.log = logger(`libp2p:mock-muxer:${this.name}`)
+    this.registryInitiatorStreams = new Map()
+    this.registryRecipientStreams = new Map()
+    this.log('create muxer')
+    this.options = options ?? {}
+    // receives data from the muxer at the other end of the stream
+    this.source = this.input = pushable<Uint8Array>({
+      onEnd: (err) => {
+        this.log('closing muxed streams')
+        for (const stream of this.streams) {
+          stream.abort(err)
+        }
+      }
+    })
 
-    if (this.sinkClosed && this.sourceClosed) {
-      this.stream.timeline.close = Date.now()
-      this.onEnd()
-    }
+    // receives messages from all of the muxed streams
+    this.streamInput = pushable<StreamMessage>()
   }
 
-  closeSource () {
-    this.sourceClosed = true
-    this.input.end()
-  }
+  // receive incoming messages
+  async sink (source: Source<Uint8Array>) {
+    try {
+      await pipe(
+        source,
+        (source) => map(source, buf => uint8ArrayToString(buf)),
+        ndjson.parse,
+        async (source) => {
+          for await (const message of source) {
+            this.log('-> %s %s %s', message.type, message.direction, message.id)
+            this.handleMessage(message)
+          }
+        }
+      )
 
-  closeSink () {
-    this.sinkClosed = true
-    this.controller.abort()
-    this.maybeEndStream()
+      this.log('muxed stream ended')
+      this.input.end()
+    } catch (err: any) {
+      this.log('muxed stream errored', err)
+      this.input.end(err)
+    }
   }
-}
 
-export function mockMuxer (options?: MuxerOptions): Muxer {
-  let streamId = 0
-  const streams = new Map<string, MuxedStream>()
-
-  // process incoming messages from the other muxer
-  const muxerSource = pushable<Uint8Array>({
-    onEnd: () => {
-      for (const muxedStream of streams.values()) {
-        muxedStream.stream.close()
+  handleMessage (message: StreamMessage) {
+    let muxedStream: MuxedStream | undefined
+
+    const registry = message.direction === 'initiator' ? this.registryRecipientStreams : this.registryInitiatorStreams
+
+    if (message.type === 'create') {
+      if (registry.has(message.id)) {
+        throw new Error(`Already had stream for ${message.id}`)
       }
-    }
-  })
 
-  // receives messages from all of the muxed streams
-  const push = pushable<StreamMessage>()
-  void Promise.resolve().then(async () => {
-    for await (const message of push) {
-      if (message.type === 'data') {
-        muxerSource.push(uint8ArrayFromString(JSON.stringify({
-          id: message.id,
-          type: message.type,
-          chunk: message.chunk
-        })))
-      } else {
-        muxerSource.push(uint8ArrayFromString(JSON.stringify({
-          id: message.id,
-          type: message.type
-        })))
+      muxedStream = this.createStream(message.id, 'recipient')
+      registry.set(muxedStream.stream.id, muxedStream)
+
+      if (this.options.onIncomingStream != null) {
+        this.options.onIncomingStream(muxedStream.stream)
       }
     }
-  })
 
-  function createStream (name?: string): MuxedStream {
-    const id = name ?? `${streamId++}`
+    muxedStream = registry.get(message.id)
 
-    const muxedStream: MuxedStream = new MuxedStream({
-      id,
-      push,
-      onEnd: () => {
-        streams.delete(id)
-
-        if (options?.onStreamEnd != null) {
-          options?.onStreamEnd(muxedStream.stream)
-        }
-      }
-    })
+    if (muxedStream == null) {
+      throw new Error(`No stream found for ${message.id}`)
+    }
 
-    return muxedStream
+    if (message.type === 'data') {
+      muxedStream.input.push(uint8ArrayFromString(message.chunk, 'base64'))
+    } else if (message.type === 'reset') {
+      this.log('-> reset stream %s %s', muxedStream.type, muxedStream.stream.id)
+      muxedStream.stream.reset()
+    } else if (message.type === 'close') {
+      this.log('-> closing stream %s %s', muxedStream.type, muxedStream.stream.id)
+      muxedStream.stream.close()
+    }
   }
 
-  const muxer: Muxer = {
-    // receive incoming messages
-    async sink (source: Source<Uint8Array>) {
-      for await (const buf of source) {
-        const message: StreamMessage = JSON.parse(uint8ArrayToString(buf))
-        let muxedStream = streams.get(message.id)
+  get streams () {
+    return Array.from(this.registryRecipientStreams.values())
+      .concat(Array.from(this.registryInitiatorStreams.values()))
+      .map(({ stream }) => stream)
+  }
 
-        if (muxedStream == null) {
-          muxedStream = createStream(message.id)
-          streams.set(muxedStream.stream.id, muxedStream)
+  newStream (name?: string) {
+    this.log('newStream %s', name)
+    const storedStream = this.createStream(name, 'initiator')
+    this.registryInitiatorStreams.set(storedStream.stream.id, storedStream)
 
-          if (options?.onStream != null) {
-            options.onStream(muxedStream.stream)
-          }
-        }
+    return storedStream.stream
+  }
 
-        if (message.type === 'data') {
-          muxedStream.input.push(uint8ArrayFromString(message.chunk, 'base64'))
-        } else if (message.type === 'reset') {
-          muxedStream.closeSink()
-          muxedStream.closeSource()
-        } else if (message.type === 'close') {
-          muxedStream.closeSource()
-        }
-      }
+  createStream (name?: string, type: 'initiator' | 'recipient' = 'initiator'): MuxedStream {
+    const id = name ?? `${this.name}:stream:${streams++}`
 
-      for (const muxedStream of streams.values()) {
-        muxedStream.stream.close()
-      }
+    this.log('createStream %s %s', type, id)
 
-      muxerSource.end()
-    },
+    const muxedStream: MuxedStream = new MuxedStream({
+      id,
+      type,
+      push: this.streamInput,
+      onEnd: () => {
+        this.log('stream ended %s %s', type, id)
 
-    source: muxerSource,
+        if (type === 'initiator') {
+          this.registryInitiatorStreams.delete(id)
+        } else {
+          this.registryRecipientStreams.delete(id)
+        }
 
-    get streams () {
-      return Array.from(streams.values()).map(({ stream }) => stream)
-    },
+        if (this.options.onStreamEnd != null) {
+          this.options.onStreamEnd(muxedStream.stream)
+        }
+      }
+    })
 
-    newStream (name?: string) {
-      const storedStream = createStream(name)
+    return muxedStream
+  }
+}
 
-      streams.set(storedStream.stream.id, storedStream)
+export function mockMuxer (options?: MuxerOptions): Muxer {
+  const mockMuxer = new MockMuxer(options)
 
-      if (options?.onStream != null) {
-        options.onStream(storedStream.stream)
+  void Promise.resolve().then(async () => {
+    void pipe(
+      mockMuxer.streamInput,
+      ndjson.stringify,
+      (source) => map(source, str => uint8ArrayFromString(str)),
+      async (source) => {
+        for await (const buf of source) {
+          mockMuxer.input.push(buf)
+        }
       }
+    )
+  })
 
-      return storedStream.stream
-    }
-  }
-
-  return muxer
+  return mockMuxer
 }

package/src/mocks/upgrader.ts

@@ -1,10 +1,10 @@
 import { expect } from 'aegir/utils/chai.js'
 import { mockConnection } from './connection.js'
 import type { Upgrader, MultiaddrConnection } from '@libp2p/interfaces/transport'
-import type { Muxer } from '@libp2p/interfaces/stream-muxer'
+import type { Registrar } from '@libp2p/interfaces/registrar'
 
 export interface MockUpgraderOptions {
-  muxer?: Muxer
+  registrar?: Registrar
 }
 
 export function mockUpgrader (options: MockUpgraderOptions = {}) {
@@ -20,14 +20,14 @@ export function mockUpgrader (options: MockUpgraderOptions = {}) {
       ensureProps(multiaddrConnection)
       return mockConnection(multiaddrConnection, {
         direction: 'outbound',
-        muxer: options.muxer
+        registrar: options.registrar
       })
     },
     async upgradeInbound (multiaddrConnection) {
       ensureProps(multiaddrConnection)
       return mockConnection(multiaddrConnection, {
         direction: 'inbound',
-        muxer: options.muxer
+        registrar: options.registrar
       })
     }
   }

package/src/stream-muxer/base-test.ts

@@ -27,10 +27,10 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       const onStreamEndPromise: DeferredPromise<Stream> = defer()
 
       const listener = await common.setup({
-        onStream: stream => {
+        onIncomingStream: (stream) => {
           onStreamPromise.resolve(stream)
         },
-        onStreamEnd: stream => {
+        onStreamEnd: (stream) => {
           onStreamEndPromise.resolve(stream)
         }
       })
@@ -74,7 +74,7 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       const p = duplexPair<Uint8Array>()
       const onStreamPromise: DeferredPromise<Stream> = defer()
       const dialer = await common.setup({
-        onStream: stream => {
+        onIncomingStream: (stream: Stream) => {
           onStreamPromise.resolve(stream)
         }
       })
@@ -103,12 +103,13 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       const onDialerStreamPromise: DeferredPromise<Stream> = defer()
       const onListenerStreamPromise: DeferredPromise<Stream> = defer()
       const dialer = await common.setup({
-        onStream: stream => {
+        onIncomingStream: (stream) => {
           onDialerStreamPromise.resolve(stream)
         }
       })
+
       const listener = await common.setup({
-        onStream: stream => {
+        onIncomingStream: (stream) => {
           onListenerStreamPromise.resolve(stream)
         }
       })
@@ -116,20 +117,20 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       void pipe(p[0], dialer, p[0])
       void pipe(p[1], listener, p[1])
 
-      const listenerConn = listener.newStream()
-      const dialerConn = dialer.newStream()
-
-      void drainAndClose(dialerConn)
-      void drainAndClose(listenerConn)
+      const dialerInitiatorStream = dialer.newStream()
+      const listenerInitiatorStream = listener.newStream()
 
-      const dialerStream = await onDialerStreamPromise.promise
-      const listenerStream = await onListenerStreamPromise.promise
+      await Promise.all([
+        drainAndClose(dialerInitiatorStream),
+        drainAndClose(listenerInitiatorStream),
+        onDialerStreamPromise.promise.then(async stream => await drainAndClose(stream)),
+        onListenerStreamPromise.promise.then(async stream => await drainAndClose(stream))
+      ])
 
-      await drainAndClose(dialerStream)
-      await drainAndClose(listenerStream)
-
-      await drainAndClose(dialer)
-      await drainAndClose(listener)
+      await Promise.all([
+        drainAndClose(dialer),
+        drainAndClose(listener)
+      ])
     })
 
     it('Open a stream on one side, write, open a stream on the other side', async () => {
@@ -138,12 +139,12 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       const onDialerStreamPromise: DeferredPromise<Stream> = defer()
       const onListenerStreamPromise: DeferredPromise<Stream> = defer()
       const dialer = await common.setup({
-        onStream: stream => {
+        onIncomingStream: (stream) => {
           onDialerStreamPromise.resolve(stream)
         }
       })
       const listener = await common.setup({
-        onStream: stream => {
+        onIncomingStream: (stream) => {
           onListenerStreamPromise.resolve(stream)
         }
       })
@@ -157,13 +158,23 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       void pipe([uint8ArrayFromString('hey')], dialerConn)
       void pipe([uint8ArrayFromString('hello')], listenerConn)
 
-      const listenerStream = await onListenerStreamPromise.promise
-      const dialerStream = await onDialerStreamPromise.promise
+      const [
+        dialerStream,
+        listenerStream
+      ] = await Promise.all([
+        onDialerStreamPromise.promise,
+        onListenerStreamPromise.promise
+      ])
+
+      const [
+        listenerChunks,
+        dialerChunks
+      ] = await Promise.all([
+        pipe(listenerStream, toString, async (source) => await all(source)),
+        pipe(dialerStream, toString, async (source) => await all(source))
+      ])
 
-      const listenerChunks = await pipe(listenerStream, toString, async (source) => await all(source))
       expect(listenerChunks).to.be.eql(['hey'])
-
-      const dialerChunks = await pipe(dialerStream, toString, async (source) => await all(source))
       expect(dialerChunks).to.be.eql(['hello'])
     })
   })