@libp2p/webrtc 5.2.24-6059227cb → 5.2.24-8484de8a2

package/src/stream.ts

@@ -1,13 +1,11 @@
-import { StreamResetError, StreamStateError } from '@libp2p/interface'
+import { StreamStateError } from '@libp2p/interface'
 import { AbstractStream } from '@libp2p/utils'
 import * as lengthPrefixed from 'it-length-prefixed'
 import { pushable } from 'it-pushable'
-import { pEvent } from 'p-event'
 import { raceSignal } from 'race-signal'
 import { Uint8ArrayList } from 'uint8arraylist'
-import { DEFAULT_FIN_ACK_TIMEOUT, MAX_BUFFERED_AMOUNT, MAX_MESSAGE_SIZE, PROTOBUF_OVERHEAD } from './constants.js'
+import { MAX_BUFFERED_AMOUNT, MAX_MESSAGE_SIZE, PROTOBUF_OVERHEAD } from './constants.js'
 import { Message } from './private-to-public/pb/message.js'
-import { isFirefox } from './util.js'
 import type { DataChannelOptions } from './index.js'
 import type { AbortOptions, MessageStreamDirection, Logger } from '@libp2p/interface'
 import type { AbstractStreamInit, SendResult } from '@libp2p/utils'
@@ -37,8 +35,7 @@ export class WebRTCStream extends AbstractStream {
    */
   private readonly incomingData: Pushable<Uint8Array>
   private readonly maxBufferedAmount: number
-  private receivedFinAck?: PromiseWithResolvers<void>
-  private finAckTimeout: number
+  private readonly receivedFinAck: PromiseWithResolvers<void>
 
   constructor (init: WebRTCStreamInit) {
     super({
@@ -50,26 +47,44 @@ export class WebRTCStream extends AbstractStream {
     this.channel.binaryType = 'arraybuffer'
     this.incomingData = pushable<Uint8Array>()
     this.maxBufferedAmount = init.maxBufferedAmount ?? MAX_BUFFERED_AMOUNT
-    this.finAckTimeout = init.finAckTimeout ?? DEFAULT_FIN_ACK_TIMEOUT
+    this.receivedFinAck = Promise.withResolvers()
+
+    // set up initial state
+    switch (this.channel.readyState) {
+      case 'open':
+        break
+
+      case 'closed':
+      case 'closing':
+        if (this.timeline.close === undefined || this.timeline.close === 0) {
+          this.timeline.close = Date.now()
+        }
+        break
+      case 'connecting':
+        // noop
+        break
+
+      default:
+        this.log.error('unknown datachannel state %s', this.channel.readyState)
+        throw new StreamStateError('Unknown datachannel state')
+    }
 
     // handle RTCDataChannel events
-    this.channel.onclose = () => {
-      this.log.trace('received datachannel close event')
+    this.channel.onclose = (_evt) => {
+      this.log.trace('received onclose event')
 
       this.onRemoteCloseWrite()
       this.onTransportClosed()
     }
 
     this.channel.onerror = (evt) => {
-      const err = (evt as RTCErrorEvent).error
-
-      this.log.trace('received datachannel error event - %e', err)
+      this.log.trace('received onerror event')
 
+      const err = (evt as RTCErrorEvent).error
       this.abort(err)
     }
 
     this.channel.onmessage = async (event: MessageEvent<ArrayBuffer>) => {
-      this.log('incoming message %d bytes', event.data.byteLength)
       const { data } = event
 
       if (data === null || data.byteLength === 0) {
@@ -81,49 +96,32 @@ export class WebRTCStream extends AbstractStream {
 
     // dispatch drain event when the buffered amount drops to zero
     this.channel.bufferedAmountLowThreshold = 0
-
     this.channel.onbufferedamountlow = () => {
-      if (this.writableNeedsDrain) {
-        this.safeDispatchEvent('drain')
-      }
+      this.safeDispatchEvent('drain')
     }
 
-    if (this.channel.readyState !== 'open') {
-      this.log('channel ready state is "%s" and not "open", waiting for "open" event before sending data', this.channel.readyState)
-      pEvent(this.channel, 'open', {
-        rejectionEvents: [
-          'close',
-          'error'
-        ]
-      })
-        .then(() => {
-          this.log('channel ready state is now "%s", dispatching drain', this.channel.readyState)
-          this.safeDispatchEvent('drain')
-        })
-        .catch(err => {
-          this.abort(err.error ?? err)
-        })
-    }
+    const self = this
 
     // pipe framed protobuf messages through a length prefixed decoder, and
     // surface data from the `Message.message` field through a source.
     Promise.resolve().then(async () => {
       for await (const buf of lengthPrefixed.decode(this.incomingData)) {
-        this.processIncomingProtobuf(buf)
+        const message = self.processIncomingProtobuf(buf)
+
+        if (message != null) {
+          self.onData(new Uint8ArrayList(message))
+        }
       }
     })
       .catch(err => {
         this.log.error('error processing incoming data channel messages', err)
       })
 
-    // close when both writable ends are closed or an error occurs
-    const cleanUpDatachannelOnClose = (): void => {
-      if (this.channel.readyState === 'open') {
-        this.log.trace('stream closed, closing underlying datachannel')
-        this.channel.close()
-      }
+    // clean up the datachannel when both ends have sent a FIN
+    const webRTCStreamOnClose = (): void => {
+      this.channel.close()
     }
-    this.addEventListener('close', cleanUpDatachannelOnClose)
+    this.addEventListener('close', webRTCStreamOnClose)
   }
 
   sendNewStream (): void {
@@ -131,57 +129,27 @@ export class WebRTCStream extends AbstractStream {
   }
 
   _sendMessage (data: Uint8ArrayList): void {
-    if (this.channel.readyState !== 'open') {
+    if (this.channel.readyState === 'closed' || this.channel.readyState === 'closing') {
       throw new StreamStateError(`Invalid datachannel state - ${this.channel.readyState}`)
     }
 
-    this.log.trace('sending message, channel state "%s"', this.channel.readyState)
-
-    if (isFirefox) {
-      // TODO: firefox can deliver small messages out of order - remove once a
-      // browser with https://bugzilla.mozilla.org/show_bug.cgi?id=1983831 is
-      // available in playwright-test
-      this.channel.send(data.subarray())
-      return
-    }
-
-    // send message without copying data
-    for (const buf of data) {
-      this.channel.send(buf)
+    try {
+      this.log.trace('sending message, channel state "%s"', this.channel.readyState)
+      // send message without copying data
+      for (const buf of data) {
+        this.channel.send(buf)
+      }
+    } catch (err: any) {
+      this.log.error('error while sending message', err)
     }
   }
 
   sendData (data: Uint8ArrayList): SendResult {
-    if (this.channel.readyState !== 'open') {
-      return {
-        sentBytes: 0,
-        canSendMore: false
-      }
-    }
-
-    // TODO: firefox can deliver small messages out of order - remove once a
-    // browser with https://bugzilla.mozilla.org/show_bug.cgi?id=1983831 is
-    // available in playwright-test
-    // ----
-    // this is also necessary to work with rust-libp2p 0.54 though 0.53 seems ok
-    this._sendMessage(
-      lengthPrefixed.encode.single(Message.encode({
-        message: data.subarray()
-      }))
-    )
-
-    /*
-    // TODO: enable this when FF and rust-libp2p are not broken
-    // send message without copying data
-      for (const message of data) {
-        this._sendMessage(
-          lengthPrefixed.encode.single(Message.encode({
-            message
-          }))
-        )
-      }
-    }
-    */
+    const messageBuf = Message.encode({
+      message: data.subarray()
+    })
+    const prefixedBuf = lengthPrefixed.encode.single(messageBuf)
+    this._sendMessage(prefixedBuf)
 
     return {
       sentBytes: data.byteLength,
@@ -189,73 +157,69 @@ export class WebRTCStream extends AbstractStream {
     }
   }
 
-  sendReset (err: Error): void {
+  sendReset (): void {
+    this.receivedFinAck.resolve()
+
     try {
-      this.log.error('sending reset - %e', err)
       this._sendFlag(Message.Flag.RESET)
-      this.receivedFinAck?.reject(err)
     } catch (err) {
       this.log.error('failed to send reset - %e', err)
+    } finally {
+      this.channel.close()
     }
   }
 
   async sendCloseWrite (options?: AbortOptions): Promise<void> {
-    this._sendFlag(Message.Flag.FIN)
-    options?.signal?.throwIfAborted()
-    this.receivedFinAck = Promise.withResolvers<void>()
-
-    await Promise.any([
-      raceSignal(this.receivedFinAck.promise, options?.signal),
-      new Promise<void>(resolve => {
-        AbortSignal.timeout(this.finAckTimeout)
-          .addEventListener('abort', () => {
-            resolve()
-          })
-      })
-    ])
+    if (this.channel.readyState === 'open') {
+      this._sendFlag(Message.Flag.FIN)
+    }
+
+    await raceSignal(this.receivedFinAck.promise, options?.signal)
   }
 
   async sendCloseRead (options?: AbortOptions): Promise<void> {
-    this._sendFlag(Message.Flag.STOP_SENDING)
+    if (this.channel.readyState === 'open') {
+      this._sendFlag(Message.Flag.STOP_SENDING)
+    }
+
     options?.signal?.throwIfAborted()
   }
 
   /**
    * Handle incoming
    */
-  private processIncomingProtobuf (buffer: Uint8ArrayList): void {
+  private processIncomingProtobuf (buffer: Uint8ArrayList): Uint8Array | undefined {
     const message = Message.decode(buffer)
 
-    // ignore data messages if we've closed the readable end already
-    if (message.message != null && (this.readStatus === 'readable' || this.readStatus === 'paused')) {
-      this.onData(new Uint8ArrayList(message.message))
-    }
-
     if (message.flag !== undefined) {
       this.log.trace('incoming flag %s, write status "%s", read status "%s"', message.flag, this.writeStatus, this.readStatus)
 
       if (message.flag === Message.Flag.FIN) {
-        // we should expect no more data from the remote, stop reading
-        this._sendFlag(Message.Flag.FIN_ACK)
+        // We should expect no more data from the remote, stop reading
         this.onRemoteCloseWrite()
+        this._sendFlag(Message.Flag.FIN_ACK)
       }
 
       if (message.flag === Message.Flag.RESET) {
-        // stop reading and writing to the stream immediately
-        this.receivedFinAck?.reject(new StreamResetError('The stream was reset'))
+        this.receivedFinAck.resolve()
+        // Stop reading and writing to the stream immediately
         this.onRemoteReset()
       }
 
       if (message.flag === Message.Flag.STOP_SENDING) {
-        // the remote has stopped reading
+        // The remote has stopped reading
         this.onRemoteCloseRead()
       }
 
       if (message.flag === Message.Flag.FIN_ACK) {
-        // remote received our FIN
-        this.receivedFinAck?.resolve()
+        this.receivedFinAck.resolve()
       }
     }
+
+    // ignore data messages if we've closed the readable end already
+    if (this.readStatus === 'readable' || this.readStatus === 'paused') {
+      return message.message
+    }
   }
 
   private _sendFlag (flag: Message.Flag): boolean {