@libp2p/webtransport 4.0.28 → 4.0.29

package/src/stream.ts

@@ -1,184 +1,110 @@
+import { AbstractStream, type AbstractStreamInit } from '@libp2p/utils/abstract-stream'
+import { raceSignal } from 'race-signal'
 import { Uint8ArrayList } from 'uint8arraylist'
 import type { AbortOptions, ComponentLogger, Direction, Stream } from '@libp2p/interface'
-import type { Source } from 'it-stream-types'
 
-export async function webtransportBiDiStreamToStream (bidiStream: WebTransportBidirectionalStream, streamId: string, direction: Direction, activeStreams: Stream[], onStreamEnd: undefined | ((s: Stream) => void), logger: ComponentLogger): Promise<Stream> {
-  const log = logger.forComponent(`libp2p:webtransport:stream:${direction}:${streamId}`)
-  const writer = bidiStream.writable.getWriter()
-  const reader = bidiStream.readable.getReader()
-  await writer.ready
-
-  function cleanupStreamFromActiveStreams (): void {
-    const index = activeStreams.findIndex(s => s === stream)
-    if (index !== -1) {
-      activeStreams.splice(index, 1)
-      stream.timeline.close = Date.now()
-      onStreamEnd?.(stream)
-    }
-  }
+interface WebTransportStreamInit extends AbstractStreamInit {
+  bidiStream: WebTransportBidirectionalStream
+}
 
-  let writerClosed = false
-  let readerClosed = false;
-  (async function () {
-    const err: Error | undefined = await writer.closed.catch((err: Error) => err)
-    if (err != null) {
-      const msg = err.message
-      if (!(msg.includes('aborted by the remote server') || msg.includes('STOP_SENDING'))) {
-        log.error(`WebTransport writer closed unexpectedly: streamId=${streamId} err=${err.message}`)
-      }
-    }
-    writerClosed = true
-    if (writerClosed && readerClosed) {
-      cleanupStreamFromActiveStreams()
-    }
-  })().catch(() => {
-    log.error('WebTransport failed to cleanup closed stream')
-  });
-
-  (async function () {
-    const err: Error | undefined = await reader.closed.catch((err: Error) => err)
-    if (err != null) {
-      log.error(`WebTransport reader closed unexpectedly: streamId=${streamId} err=${err.message}`)
-    }
-    readerClosed = true
-    if (writerClosed && readerClosed) {
-      cleanupStreamFromActiveStreams()
-    }
-  })().catch(() => {
-    log.error('WebTransport failed to cleanup closed stream')
-  })
+class WebTransportStream extends AbstractStream {
+  private readonly writer: WritableStreamDefaultWriter<Uint8Array>
+  private readonly reader: ReadableStreamDefaultReader<Uint8Array>
 
-  let sinkSunk = false
-  const stream: Stream = {
-    id: streamId,
-    status: 'open',
-    writeStatus: 'ready',
-    readStatus: 'ready',
-    abort (err: Error) {
-      if (!writerClosed) {
-        writer.abort(err)
-          .catch(err => {
-            log.error('could not abort stream', err)
-          })
-        writerClosed = true
-      }
-      readerClosed = true
-
-      this.status = 'aborted'
-      this.writeStatus = 'closed'
-      this.readStatus = 'closed'
-
-      this.timeline.reset =
-        this.timeline.close =
-        this.timeline.closeRead =
-        this.timeline.closeWrite = Date.now()
-
-      cleanupStreamFromActiveStreams()
-    },
-    async close (options?: AbortOptions) {
-      this.status = 'closing'
-
-      await Promise.all([
-        stream.closeRead(options),
-        stream.closeWrite(options)
-      ])
-
-      cleanupStreamFromActiveStreams()
-
-      this.status = 'closed'
-      this.timeline.close = Date.now()
-    },
-
-    async closeRead (options?: AbortOptions) {
-      if (!readerClosed) {
-        this.readStatus = 'closing'
-
-        try {
-          await reader.cancel()
-        } catch (err: any) {
-          if (err.toString().includes('RESET_STREAM') === true) {
-            writerClosed = true
-          }
-        }
+  constructor (init: WebTransportStreamInit) {
+    super(init)
 
-        this.timeline.closeRead = Date.now()
-        this.readStatus = 'closed'
+    this.writer = init.bidiStream.writable.getWriter()
+    this.reader = init.bidiStream.readable.getReader()
 
-        readerClosed = true
-      }
+    Promise.resolve().then(async () => {
+      while (true) {
+        const result = await this.reader.read()
 
-      if (writerClosed) {
-        cleanupStreamFromActiveStreams()
-      }
-    },
+        if (result.done) {
+          init.log('remote closed write')
+          return
+        }
 
-    async closeWrite (options?: AbortOptions) {
-      if (!writerClosed) {
-        writerClosed = true
+        if (result.value != null) {
+          this.sourcePush(new Uint8ArrayList(result.value))
+        }
+      }
+    })
+      .catch(err => {
+        init.log.error('error reading from stream', err)
+        this.abort(err)
+      })
+      .finally(() => {
+        this.remoteCloseWrite()
+      })
+
+    void this.writer.closed
+      .then(() => {
+        init.log('writer closed')
+      })
+      .catch((err) => {
+        init.log('writer close promise rejected', err)
+      })
+      .finally(() => {
+        this.remoteCloseRead()
+      })
+  }
 
-        this.writeStatus = 'closing'
+  sendNewStream (options?: AbortOptions | undefined): void {
+    // this is a no-op
+  }
 
-        try {
-          await writer.close()
-        } catch (err: any) {
-          if (err.toString().includes('RESET_STREAM') === true) {
-            readerClosed = true
-          }
-        }
+  async sendData (buf: Uint8ArrayList, options?: AbortOptions): Promise<void> {
+    for await (const chunk of buf) {
+      this.log('sendData waiting for writer to be ready')
+      await raceSignal(this.writer.ready, options?.signal)
+
+      // the streams spec recommends not waiting for data to be sent
+      // https://streams.spec.whatwg.org/#example-manual-write-dont-await
+      this.writer.write(chunk)
+        .catch(err => {
+          this.log.error('error sending stream data', err)
+        })
+    }
+  }
 
-        this.timeline.closeWrite = Date.now()
-        this.writeStatus = 'closed'
-      }
+  async sendReset (options?: AbortOptions): Promise<void> {
+    this.log('sendReset aborting writer')
+    await raceSignal(this.writer.abort(), options?.signal)
+    this.log('sendReset aborted writer')
+  }
 
-      if (readerClosed) {
-        cleanupStreamFromActiveStreams()
-      }
-    },
-    direction,
-    timeline: { open: Date.now() },
-    metadata: {},
-    source: (async function * () {
-      while (true) {
-        const val = await reader.read()
-        if (val.done) {
-          readerClosed = true
-          if (writerClosed) {
-            cleanupStreamFromActiveStreams()
-          }
-          return
-        }
+  async sendCloseWrite (options?: AbortOptions): Promise<void> {
+    this.log('sendCloseWrite closing writer')
+    await raceSignal(this.writer.close(), options?.signal)
+    this.log('sendCloseWrite closed writer')
+  }
 
-        yield new Uint8ArrayList(val.value)
-      }
-    })(),
-    sink: async function (source: Source<Uint8Array | Uint8ArrayList>) {
-      if (sinkSunk) {
-        throw new Error('sink already called on stream')
-      }
-      sinkSunk = true
-      try {
-        this.writeStatus = 'writing'
-
-        for await (const chunks of source) {
-          if (chunks instanceof Uint8Array) {
-            await writer.write(chunks)
-          } else {
-            for (const buf of chunks) {
-              await writer.write(buf)
-            }
-          }
-        }
+  async sendCloseRead (options?: AbortOptions): Promise<void> {
+    this.log('sendCloseRead cancelling reader')
+    await raceSignal(this.reader.cancel(), options?.signal)
+    this.log('sendCloseRead cancelled reader')
+  }
+}
 
-        this.writeStatus = 'done'
-      } finally {
-        this.timeline.closeWrite = Date.now()
-        this.writeStatus = 'closed'
+export async function webtransportBiDiStreamToStream (bidiStream: WebTransportBidirectionalStream, streamId: string, direction: Direction, activeStreams: Stream[], onStreamEnd: undefined | ((s: Stream) => void), logger: ComponentLogger): Promise<Stream> {
+  const log = logger.forComponent(`libp2p:webtransport:stream:${direction}:${streamId}`)
 
-        await stream.closeWrite()
+  const stream = new WebTransportStream({
+    bidiStream,
+    id: streamId,
+    direction,
+    log,
+    onEnd: () => {
+      const index = activeStreams.findIndex(s => s === stream)
+      if (index !== -1) {
+        activeStreams.splice(index, 1)
       }
-    },
-    log
-  }
+
+      onStreamEnd?.(stream)
+    }
+  })
 
   return stream
 }

package/src/utils/generate-certificates.browser.ts

@@ -0,0 +1,3 @@
+export async function generateWebTransportCertificates (): Promise<any> {
+  throw new Error('Not implemented')
+}

package/src/utils/generate-certificates.ts

@@ -0,0 +1,11 @@
+import type { WebTransportCertificate } from '../../src/index.js'
+
+export interface GenerateWebTransportCertificateOptions {
+  days: number
+  start?: Date
+  extensions?: any[]
+}
+
+export async function generateWebTransportCertificates (options: GenerateWebTransportCertificateOptions[] = []): Promise<WebTransportCertificate[]> {
+  throw new Error('Not implemented')
+}

package/src/webtransport.browser.ts

@@ -0,0 +1 @@
+export default WebTransport

package/src/webtransport.ts

@@ -0,0 +1,17 @@
+export default class WebTransport {
+  constructor (url: string | URL, options?: WebTransportOptions) {
+    throw new Error('Only supported in browsers')
+  }
+
+  close (): void {
+    throw new Error('Only supported in browsers')
+  }
+
+  async createBidirectionalStream (): Promise<WebTransportBidirectionalStream> {
+    throw new Error('Only supported in browsers')
+  }
+
+  public closed = Promise.reject(new Error('Only supported in browsers'))
+  public ready = Promise.reject(new Error('Only supported in browsers'))
+  public incomingBidirectionalStreams: ReadableStream
+}