@fails-components/webtransport 0.3.1 → 1.0.1

package/lib/stream.js

@@ -1,8 +1,9 @@
-import { ReadableStream, WritableStream } from 'node:stream/web'
+import { ReadableStream, WritableStream } from './webstreams.js'
 import { logger } from './utils.js'
 import { WebTransportError } from './error.js'
 
-const log = logger(`webtransport:http3wtstream(${process.pid})`)
+const pid = typeof process !== 'undefined' ? process.pid : 0
+const log = logger(`webtransport:http3wtstream(${pid})`)
 
 /**
  * WebTransport stream events
@@ -10,24 +11,24 @@ const log = logger(`webtransport:http3wtstream(${process.pid})`)
  * @typedef {import('./types').StreamRecvSignalEvent} StreamRecvSignalEvent
  * @typedef {import('./types').StreamReadEvent} StreamReadEvent
  * @typedef {import('./types').StreamWriteEvent} StreamWriteEvent
- * @typedef {import('./types').StreamResetEvent} StreamResetEvent
  * @typedef {import('./types').StreamNetworkFinishEvent} StreamNetworkFinishEvent
  *
- * @typedef {import('./types').NativeHttp3WTStream} NativeHttp3WTStream
+ * @typedef {import('./types').NativeHttpWTStream} NativeHttpWTStream
+ * @typedef {import('./types').ReadBuffer} ReadBuffer
  *
  * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
  * @typedef {import('./dom').WebTransportSendStream} WebTransportSendStream
  *
- * @typedef {import('./session').Http3WTSession} Http3WTSession
+ * @typedef {import('./session').HttpWTSession} HttpWTSession
  *
  * @typedef {import('stream/web').WritableStreamDefaultController} WritableStreamDefaultController
  */
 
-export class Http3WTStream {
+export class HttpWTStream {
   /**
    * @param {object} args
-   * @param {NativeHttp3WTStream} args.object
-   * @param {Http3WTSession} args.parentobj
+   * @param {NativeHttpWTStream} args.object
+   * @param {HttpWTSession} args.parentobj
    * @param {object} args.transport
    * @param {boolean} args.bidirectional
    * @param {boolean} args.incoming
@@ -41,6 +42,10 @@ export class Http3WTStream {
     this.incoming = args.incoming
     this.closed = false
 
+    if (this.objint.sendInitialParameters) {
+      this.objint.sendInitialParameters()
+    }
+
     /** @type {Promise<void> | null} */
     this.pendingoperation = null
     this.pendingres = null
@@ -55,12 +60,6 @@ export class Http3WTStream {
     this.pendingresRead = null
 
     if (this.bidirectional || this.incoming) {
-      /** @type {Number} */
-      this.incomingbufferfilled = 0
-      /** @type {Number} */
-      this.incomingbufferreadpos = 0
-      if (!this.objint.readbuffer)
-        throw new Error('No readbuffer for read stream')
       /** @type {WebTransportReceiveStream} */
       // @ts-expect-error `getStats` property is missing from ReadableStream
       this.readable = new ReadableStream(
@@ -78,16 +77,11 @@ export class Http3WTStream {
               return Promise.resolve()
             }
 
-            /** @type {Uint8Array} */
-            if (this.incomingbufferfilled === 0) {
-              this.pendingoperationRead = new Promise((resolve, reject) => {
-                this.pendingresRead = resolve
-              })
-              await this.pendingoperationRead
-            }
-            if (this.incomingbufferfilled === 0) return Promise.resolve()
-
-            this.drainBuffer()
+            this.pendingoperationRead = new Promise((resolve, reject) => {
+              this.pendingresRead = resolve
+            })
+            this.objint.startReading()
+            await this.pendingoperationRead
           },
           cancel: (/** @type {{ code: number; }} */ reason) => {
             /** @type {Promise<void>} */
@@ -131,14 +125,18 @@ export class Http3WTStream {
             if (this.writableclosed) {
               return Promise.resolve()
             }
-            if (chunk instanceof Uint8Array) {
+            let wchunk = chunk
+            if (wchunk instanceof ArrayBuffer) {
+              wchunk = new Uint8Array(wchunk)
+            }
+            if (wchunk instanceof Uint8Array) {
               this.pendingoperation = new Promise((resolve, reject) => {
                 this.pendingres = resolve
               })
               this.parentobj
                 .waitForDatagramsSend()
                 .finally(() => {
-                  this.objint.writeChunk(chunk)
+                  this.objint.writeChunk(wchunk)
                 })
                 .catch((/** @type {any} */ err) => {
                   log.error(err)
@@ -146,7 +144,9 @@ export class Http3WTStream {
               return this.pendingoperation
             } else {
               log.trace('chunk info:', chunk)
-              throw new Error('chunk is not of instanceof Uint8Array ')
+              throw new Error(
+                'chunk is not of instanceof Uint8Array or Arraybuffer'
+              )
             }
           },
           close: () => {
@@ -199,62 +199,69 @@ export class Http3WTStream {
     this.pendingres = null
     /** @type {(() => void) | null} */
     this.abortres = null
+
+    this.finaldrain_ = false
   }
 
-  drainBuffer() {
+  /**
+   * @param {{byteSize: number}} args
+   * @returns {ReadBuffer}
+   */
+  getReadBuffer({ byteSize }) {
     const byob = this.readableController.byobRequest
-    // @ts-ignore
-    const view = byob?.view
-    // @ts-ignore
-    if (!(byob?.view instanceof Uint8Array))
-      throw new Error('byob view is not a Uint8Array')
-    let toread = Math.min(view.byteLength, this.incomingbufferfilled)
-    let read = 0
-    if (!this.objint.readbuffer)
-      throw new Error('No readbuffer in read for read stream')
-    if (
-      this.incomingbufferreadpos + toread >
-      this.objint.readbuffer.byteLength
-    ) {
-      /** @type {Number} */
-      const firstread =
-        this.objint.readbuffer.byteLength - this.incomingbufferreadpos
-      read += firstread
-      toread -= firstread
-      const destview = new Uint8Array(
-        view.buffer,
-        0 + view.byteOffset,
-        firstread
-      )
-      const srcview = new Uint8Array(
-        this.objint.readbuffer,
-        this.incomingbufferreadpos,
-        firstread
-      )
-      destview.set(srcview)
-      this.incomingbufferreadpos = 0
+    if (byob) {
+      // @ts-ignore
+      const buffer = byob?.view
+      // @ts-ignore
+      if (!(buffer instanceof Uint8Array)) {
+        throw new Error('byob view is not a Uint8Array')
+      }
+      return { buffer, byob, readBytes: 0, fin: false }
+    } else {
+      const buffer = new Uint8Array(byteSize)
+      return { buffer, byob: undefined, readBytes: 0, fin: false }
     }
-    {
-      const destview = new Uint8Array(
-        view.buffer,
-        read + view.byteOffset,
-        toread
-      )
-      const srcview = new Uint8Array(
-        this.objint.readbuffer,
-        this.incomingbufferreadpos,
-        toread
-      )
-      destview.set(srcview)
-      read += toread
-      this.incomingbufferreadpos =
-        (this.incomingbufferreadpos + toread) %
-        this.objint.readbuffer.byteLength
+  }
+
+  /**
+   * @param {ReadBuffer} args
+   */
+  commitReadBuffer({ buffer, byob, drained, readBytes, fin }) {
+    if (!this.readableclosed) {
+      if (byob && readBytes !== undefined) {
+        byob.respond(readBytes)
+      } else if (buffer) {
+        this.readableController.enqueue(buffer)
+      }
     }
-    // @ts-ignore
-    byob.respond(read)
-    this.incomingbufferfilled -= read
-    this.objint.updateReadPos(read, this.incomingbufferreadpos)
+    const retObj = {}
+
+    if (readBytes !== undefined && readBytes > 0 && !this.readableclosed) {
+      log.trace('commitReadbuffer', readBytes)
+      // console.log('stream read received', args.data, Date.now())
+      if (this.pendingoperationRead && drained) {
+        if (this.readableController.desiredSize != null && !this.finaldrain_) {
+          if (this.readableController.desiredSize < 0) retObj.stopReading = true
+        }
+        // this.readableController.enqueue(data)
+        const res = this.pendingresRead
+        this.pendingoperationRead = null
+        this.pendingresRead = null
+        if (res) res()
+      }
+    }
+    if (fin) {
+      if (this.cancelres) {
+        const res = this.cancelres
+        this.cancelres = null
+        res()
+      }
+      if (!this.readableclosed) {
+        this.readableController.close()
+        this.readableclosed = true
+      }
+    }
+    return retObj
   }
 
   /**
@@ -262,7 +269,7 @@ export class Http3WTStream {
    * @returns {void}
    */
   onStreamRecvSignal(args) {
-    log('callback', args?.purpose, args?.nettask)
+    log('callback', args?.nettask)
     log.trace('onStreamRecvSignal', args)
     // check if transport is closed
     let parentcleanup = true
@@ -274,6 +281,7 @@ export class Http3WTStream {
     switch (args.nettask) {
       case 'resetStream':
         if (this.readable) {
+          this.finalDrain()
           if (parentcleanup)
             this.parentobj.removeReceiveStream(
               this.readable,
@@ -326,46 +334,9 @@ export class Http3WTStream {
     }
   }
 
-  /**
-   * @param {StreamReadEvent} args
-   * @returns {void}
-   */
-  onStreamRead(args) {
-    if (args.buffergrow && !this.readableclosed) {
-      log.trace('stream read received', args.buffergrow)
-      this.incomingbufferfilled += args.buffergrow
-      // console.log('stream read received', args.data, Date.now())
-      if (this.pendingoperationRead) {
-        // this.readableController.enqueue(data)
-        const res = this.pendingresRead
-        this.pendingoperationRead = null
-        this.pendingresRead = null
-        if (res) res()
-      }
-      if (
-        this.readableController.desiredSize != null &&
-        this.readableController.desiredSize < 0
-      )
-        this.objint.stopReading()
-    }
-    if (args.fin) {
-      if (this.incomingbufferfilled > 0) {
-        log.trace('Warning buffer filled and we got a fin')
-        if (this.pendingoperationRead || this.pendingresRead)
-          throw new Error('We have pendingoperationRead and a filled buffer?')
-
-        this.drainBuffer()
-      }
-      if (this.cancelres) {
-        const res = this.cancelres
-        this.cancelres = null
-        res()
-      }
-      if (!this.readableclosed) {
-        this.readableController.close()
-        this.readableclosed = true
-      }
-    }
+  finalDrain() {
+    this.finaldrain_ = true
+    this.objint.drainReads()
   }
 
   /**
@@ -383,29 +354,11 @@ export class Http3WTStream {
     }
   }
 
-  /**
-   * @param {StreamResetEvent} args
-   */
-  onStreamReset(args) {
-    if (this.abortres) {
-      this.abortres()
-      if (this.readable)
-        this.parentobj.removeReceiveStream(
-          this.readable,
-          this.readableController
-        )
-      if (this.writable)
-        this.parentobj.removeSendStream(this.writable, this.writableController)
-      this.readableclosed = true
-      this.parentobj.removeStreamObj(this)
-    }
-  }
-
   /**
    * @param {StreamNetworkFinishEvent} args
    */
   onStreamNetworkFinish(args) {
-    log('callback', args?.purpose)
+    log('callback', args?.nettask)
     log.trace('networkfinish args', args)
     switch (args.nettask) {
       case 'stopSending':
@@ -421,6 +374,18 @@ export class Http3WTStream {
           const res = this.abortres
           this.abortres = null
           res()
+          if (this.readable)
+            this.parentobj.removeReceiveStream(
+              this.readable,
+              this.readableController
+            )
+          if (this.writable)
+            this.parentobj.removeSendStream(
+              this.writable,
+              this.writableController
+            )
+          this.readableclosed = true
+          this.parentobj.removeStreamObj(this)
         }
 
         break
@@ -440,45 +405,4 @@ export class Http3WTStream {
     }
     // we could differentiate....
   }
-
-  /**
-   * @param {StreamRecvSignalEvent | StreamReadEvent | StreamWriteEvent | StreamResetEvent | StreamNetworkFinishEvent} args
-   */
-  static callback(args) {
-    log('callback', args?.purpose)
-    log.trace(log)
-    if (!args || !args.object || !args.object.jsobj)
-      throw new Error('Stream callback without jsobj')
-    const visitor = args.object.jsobj
-    if (args.purpose) {
-      switch (args.purpose) {
-        case 'StreamRecvSignal':
-          visitor.onStreamRecvSignal(args)
-          break
-        case 'StreamRead':
-          if (
-            visitor &&
-            Object.prototype.hasOwnProperty.call(args, 'buffergrow')
-          ) {
-            visitor.onStreamRead(args)
-          } else {
-            throw new Error('Malformed StreamRead')
-          }
-          break
-        case 'StreamWrite':
-          visitor.onStreamWrite(args)
-          break
-        case 'StreamReset':
-          visitor.onStreamReset(args)
-          break
-        case 'StreamNetworkFinish':
-          visitor.onStreamNetworkFinish(args)
-
-          break
-        default: {
-          throw new Error('unknown purpose Streamcb')
-        }
-      }
-    } else throw new Error('no purpose Streamcb')
-  }
 }