@fails-components/webtransport 1.1.4 → 1.2.1

package/lib/http2/session.js

@@ -1,6 +1,7 @@
 /**
  * @typedef {import('http2').Http2Stream} Http2Stream
  * @typedef {import('../dom.js').WebTransportSendGroup} WebTransportSendGroup
+ * @typedef {import('../dom.js').WebTransportSendStreamOptions} WebTransportSendStreamOptions
  */
 import { ParserBase } from './parserbase.js'
 import { FlowController } from './flowcontroller.js'
@@ -72,15 +73,25 @@ export class Http2WebTransportSession {
       maxAllowedIncomingStreams: initialBidirectionalReceiveStreams,
       maxAllowedOutgoingStreams: initialBidirectionalSendStreams
     })
-    this.orderUniStreams = 0
-    this.orderBiStreams = 0
+    /** @type {Array<Uint8Array>} */
+    this.datagramsWaiting_ = []
+    /** @type {Array<{sendOrder: bigint, sendGroupId: bigint}>} */
+    this.orderUniStreams = []
+    /** @type {Array<{sendOrder: bigint, sendGroupId: bigint}>} */
+    this.orderBiStreams = []
     if (stream) {
       if (isclient) {
         stream.on('response', (headers) => {
           processnextTick(() => {
             if (headers[':status'] === 200) {
+              const beReady = {}
+              if (stream && headers['wt-protocol']) {
+                // http/2 case
+                // @ts-ignore
+                beReady.protocol = headers['wt-protocol']
+              }
               // on ready
-              this.jsobj.onReady({})
+              this.jsobj.onReady(beReady)
             } else {
               this.jsobj.onClose({
                 errorcode: headers[':status'],
@@ -98,51 +109,87 @@ export class Http2WebTransportSession {
   }
 
   sendInitialParameters() {
-    this.flowController.sendWindowUpdate()
-    this.streamIdMngrBi.sendMaxStreamsFrameInitial()
-    this.streamIdMngrUni.sendMaxStreamsFrameInitial()
+    let skip = false //skips the initial parameters at environment with settings
+    if (process) {
+      if (process.version) {
+        const majorVersion = parseInt(
+          process.version.split('.')[0].substring(1)
+        )
+        if (majorVersion >= 20) skip = true
+      }
+    }
+    if (!skip || this.capsParser.initialParametersMandatory()) {
+      this.flowController.sendWindowUpdate()
+      this.streamIdMngrBi.sendMaxStreamsFrameInitial()
+      this.streamIdMngrUni.sendMaxStreamsFrameInitial()
+    }
+  }
+
+  drainWrites() {
+    while (!this.capsParser.blocked && this.datagramsWaiting_.length > 0) {
+      const outChunk = this.datagramsWaiting_.shift()
+      this.capsParser.writeCapsule({
+        type: ParserBase.DATAGRAM,
+        headerVints: [],
+        payload: outChunk
+      })
+    }
+    if (this.datagramsWaiting_.length > 0) {
+      this.capsParser.scheduleDrainWrites()
+    }
   }
 
   /**
    * @param {Uint8Array} chunk
+   * @return {{ code: "success" | "blocked" | "internalError" | "tooBig", message?: string | undefined; }}
    */
   writeDatagram(chunk) {
+    if (chunk.byteLength > this.getMaxDatagramSize()) return { code: 'tooBig' }
+    if (this.capsParser.blocked) {
+      this.datagramsWaiting_.push(chunk)
+      this.capsParser.scheduleDrainWrites()
+      return { code: 'blocked' }
+    }
     this.capsParser.writeCapsule({
       type: ParserBase.DATAGRAM,
       headerVints: [],
       payload: chunk
     })
-    processnextTick(() => {
-      this.jsobj.onDatagramSend({})
-    })
+    return { code: 'success' }
   }
 
   trySendingUnidirectionalStreams() {
     while (
-      this.orderUniStreams > 0 &&
+      this.orderUniStreams.length > 0 &&
       this.streamIdMngrUni.canOpenNextOutgoingStream()
     ) {
       const streamid = this.streamIdMngrUni.getNextOutgoingStreamId()
+      const priority = this.orderUniStreams.pop()
       this.capsParser.writeCapsule({
         type: ParserBase.WT_STREAM_WOFIN,
         headerVints: [streamid],
         payload: undefined
       })
-      this.capsParser.newStream(streamid)
-      this.orderUniStreams--
+      this.capsParser.newStream(
+        streamid,
+        priority || { sendGroupId: 0n, sendOrder: 0n }
+      )
     }
   }
 
   /**
-   * @param {{sendGroup:  WebTransportSendGroup|null, sendOrder: number, waitUntilAvailable: boolean}} opts
+   * @param {WebTransportSendStreamOptions} opts
    */
-  // eslint-disable-next-line no-unused-vars
   orderUnidiStream({ sendGroup, sendOrder, waitUntilAvailable }) {
     const canopen = this.streamIdMngrUni.canOpenNextOutgoingStream()
     const maxset = this.streamIdMngrUni.isMaxStreamSet() // we block if the maxsetting did not arrive
 
     if (canopen || waitUntilAvailable || !maxset) {
-      this.orderUniStreams++
+      this.orderUniStreams.push({
+        // @ts-ignore
+        sendGroupId: sendGroup?._sendGroupId || 0n,
+        sendOrder: sendOrder ?? 0n
+      })
       this.trySendingUnidirectionalStreams()
       return true
     }
@@ -151,30 +198,36 @@ export class Http2WebTransportSession {
 
   trySendingBidirectionalStreams() {
     while (
-      this.orderBiStreams > 0 &&
+      this.orderBiStreams.length > 0 &&
       this.streamIdMngrBi.canOpenNextOutgoingStream()
     ) {
       const streamid = this.streamIdMngrBi.getNextOutgoingStreamId()
+      const priority = this.orderBiStreams.pop()
       this.capsParser.writeCapsule({
         type: ParserBase.WT_STREAM_WOFIN,
         headerVints: [streamid],
         payload: undefined
       })
-      this.capsParser.newStream(streamid)
-      this.orderBiStreams--
+      this.capsParser.newStream(
+        streamid,
+        priority || { sendGroupId: 0n, sendOrder: 0n }
+      )
     }
   }
 
   /**
-   * @param {{sendGroup:  WebTransportSendGroup|null, sendOrder: number, waitUntilAvailable: boolean}} opts
+   * @param {WebTransportSendStreamOptions} opts
    */
-  // eslint-disable-next-line no-unused-vars
   orderBidiStream({ sendGroup, sendOrder, waitUntilAvailable }) {
     const canopen = this.streamIdMngrBi.canOpenNextOutgoingStream()
     const maxset = this.streamIdMngrBi.isMaxStreamSet() // we block if the maxsetting did not arrive
 
     if (canopen || waitUntilAvailable || !maxset) {
-      this.orderBiStreams++
+      this.orderBiStreams.push({
+        // @ts-ignore
+        sendGroupId: sendGroup?._sendGroupId || 0n,
+        sendOrder: sendOrder ?? 0n
+      })
       this.trySendingBidirectionalStreams()
       return true
     }
@@ -202,6 +255,10 @@ export class Http2WebTransportSession {
     })
   }
 
+  getMaxDatagramSize() {
+    return 16384 // this completly arbitry, we do not have a real restriction, but we choose more than quiche, to make things interesting
+  }
+
   /*
    * @returns {void}
    */
@@ -260,16 +317,19 @@ export class Http2WebTransportSession {
   }
 
   smoothedRtt() {
+    let toret
     if (this.stream) {
       // we are on node
       // @ts-ignore
-      return this.stream.session?.WTrtt || 26
+      toret = this.stream.session?.WTrtt || 25
     } else if (this.ws) {
       // we are at the Browser, so we use the connection rtt?
       // @ts-ignore
       // eslint-disable-next-line no-undef
-      return navigator?.connection?.rtt || 26
+      toret = navigator?.connection?.rtt || 25
     }
+    toret = Math.ceil(toret / 25) * 25 // to do be to accurate!
+    return toret
   }
 
   /**

package/lib/http2/stream.js

@@ -1,6 +1,7 @@
 import { FlowController } from './flowcontroller.js'
 import { ParserBase } from './parserbase.js'
 import { logger } from '../utils.js'
+import { WebTransportError } from '../error.js'
 
 const pid = typeof process !== 'undefined' ? process.pid : 0
 const log = logger(`webtransport:http2webtransportstream(${pid})`)
@@ -69,6 +70,7 @@ export class Http2WebTransportStream {
     this.streamIdManager = streamIdManager
 
     this.final = false
+    this.finalmessagesend = false
     this.stopReading_ = true
     this.drainReads_ = true
     this.recvBytes = 0
@@ -285,20 +287,34 @@ export class Http2WebTransportStream {
    */
   writeChunk(buf) {
     this.outgochunks.push({ buf, fin: false })
-    this.drainWrites()
+    this.capsuleParser.scheduler.Schedule(this.streamid)
+    this.capsuleParser.scheduleDrainWrites()
+  }
+
+  hasPendingData() {
+    return this.outgochunks.length > 0
   }
 
   drainWrites() {
+    let finsend = false
     while (
       this.outgochunks.length > 0 &&
-      (!this.capsuleParser.blocked || this.final) &&
+      (!this.capsuleParser.blocked ||
+        this.final ||
+        !this.capsuleParser.shouldYieldStream(this.streamid)) &&
       this.flowController.sendWindowSize() > 0n &&
       this.sessionFlowController.sendWindowSize() > 0n
     ) {
       const cur = this.outgochunks.shift()
+      let outgoChunkSend = true
       if (cur) {
         let payload = cur.buf
         if (payload) {
+          if (payload.byteLength === 0 && !cur.fin) {
+            throw new WebTransportError(
+              'Trying to send zero length capsule without a fin'
+            )
+          }
           const sessWindow = this.sessionFlowController.sendWindowSize()
           const streamWindow = this.flowController.sendWindowSize()
           if (
@@ -319,6 +335,7 @@ export class Http2WebTransportStream {
               const dest = new Uint8Array(payload.byteLength - len)
               dest.set(src)
               this.outgochunks.unshift({ fin: cur.fin, buf: dest })
+              outgoChunkSend = false // remaing part is send later
             }
             cur.fin = false
             payload = cur.buf = new Uint8Array(
@@ -335,27 +352,60 @@ export class Http2WebTransportStream {
           headerVints: [this.streamid],
           payload
         })
+        finsend ||= !!cur?.fin
 
         if (payload) {
           this.flowController.addBytesSent(payload?.byteLength)
           this.sessionFlowController.addBytesSent(payload?.byteLength)
         }
       }
-      this.jsobj.onStreamWrite({
-        success: true
+      if (outgoChunkSend) {
+        this.jsobj.onStreamWrite({
+          success: true
+        })
+      }
+    }
+    if (finsend) {
+      this.capsuleParser.removeStream(this.streamid)
+      return
+    }
+
+    if (
+      !(
+        !this.capsuleParser.blocked ||
+        this.final ||
+        !this.capsuleParser.shouldYieldStream(this.streamid)
+      ) &&
+      this.outgochunks.length > 0
+    ) {
+      this.capsuleParser.scheduleDrainWriteStream(this.streamid)
+    }
+    if (this.final && this.outgochunks.length === 0 && !this.finalmessagesend) {
+      processnextTick(() => {
+        this.jsobj.onStreamNetworkFinish({
+          nettask: 'streamFinal'
+        })
       })
+      this.finalmessagesend = true
     }
   }
 
   streamFinal() {
     this.final = true
     this.outgochunks.push({ fin: true })
-    this.drainWrites()
-    processnextTick(() =>
-      this.jsobj.onStreamNetworkFinish({
-        nettask: 'streamFinal'
-      })
-    )
+    this.capsuleParser.scheduleDrainWriteStream(this.streamid)
+    this.capsuleParser.scheduleDrainWrites()
+  }
+
+  /**
+   *
+   * @param {{sendOrder: bigint, sendGroupId: bigint}} args
+   */
+  updateSendOrderAndGroup({ sendOrder, sendGroupId }) {
+    this.capsuleParser.streamUpdateSendOrderAndGroup(this.streamid, {
+      sendOrder,
+      sendGroupId
+    })
   }
 
   /**

package/lib/http2/websocketcommon.js

@@ -1 +1 @@
-export const supportedVersions = ['kDraft1']
+export const supportedVersions = ['kDraft1', 'kDraft2']

package/lib/server.js

@@ -214,7 +214,6 @@ export class HttpServer {
   setRequestCallback(callback) {
     this.requestHandler = callback
 
-    this.transportInt.setJSRequestHandler(!!callback)
     if (this.transportInt) this.transportInt.setJSRequestHandler(!!callback)
     else this._pendingRequestCallback = !!callback
   }

package/lib/session.js

@@ -13,7 +13,6 @@ const log = logger(`webtransport:httpwtsession(${pid})`)
  * @typedef {import('./types').SessionReadyEvent} SessionReadyEvent
  * @typedef {import('./types').SessionCloseEvent} SessionCloseEvent
  * @typedef {import('./types').DatagramReceivedEvent} DatagramReceivedEvent
- * @typedef {import('./types').DatagramSendEvent} DatagramSendEvent
  * @typedef {import('./types').GoawayReceivedEvent} GoawayReceivedEvent
  * @typedef {import('./types').DatagramStatsEvent} DatagramStatsEvent
  * @typedef {import('./types').SessionStatsEvent} SessionStatsEvent
@@ -27,8 +26,11 @@ const log = logger(`webtransport:httpwtsession(${pid})`)
  * @typedef {import('./dom').WebTransportDatagramDuplexStream} WebTransportDatagramDuplexStream
  * @typedef {import('./dom').WebTransportReliabilityMode} WebTransportReliabilityMode
  * @typedef {import('./dom').WebTransportCongestionControl} WebTransportCongestionControl
+ * @typedef {import('./dom').WebTransportSendGroup} WebTransportSendGroup
  * @typedef {import('./dom').WebTransportStats} WebTransportStats
  * @typedef {import('./dom').WebTransportDatagramStats} WebTransportDatagramStats
+ * @typedef {import('./dom').WebTransportSendOptions} WebTransportSendOptions
+ * @typedef {import('./dom').WebTransportDatagramsWritable} WebTransportDatagramsWritable
  *
  * @typedef {import('./types').NativeHttpWTSession} NativeHttpWTSession
  *
@@ -112,12 +114,6 @@ export class HttpWTSession {
       }
     })
 
-    /** @type {Array<() => void>} */
-    this.writeDatagramRes = []
-    /** @type {Array<(err?: Error) => void>} */
-    this.writeDatagramRej = []
-    /** @type {Array<Promise<void>>} */
-    this.writeDatagramProm = []
     const readableopts = {
       start: (
         /** @type {import("stream/web").ReadableByteStreamController} */ controller
@@ -130,37 +126,95 @@ export class HttpWTSession {
       // @ts-ignore
       delete readableopts.type
     }
+    this._lastGetMaxDatagramSize = 0
     /** @type {WebTransportDatagramDuplexStream} */
     this.datagrams = {
       /** @type {ReadableStream<Uint8Array>} */
       // @ts-ignore
       readable: new ReadableStream(readableopts),
-      writable: new WritableStream({
-        start: (controller) => {
-          this.outgoDatagramController = controller
-        },
-        // eslint-disable-next-line no-unused-vars
-        write: (chunk, controller) => {
-          if (this.state === 'closed') throw new Error('Session is closed')
-          if (chunk instanceof Uint8Array) {
-            /** @type {Promise<void>} */
-            const ret = new Promise((resolve, reject) => {
-              this.writeDatagramRes.push(resolve)
-              this.writeDatagramRej.push(reject)
-            })
-            this.writeDatagramProm.push(ret)
-            log.trace('b4 datagram write', chunk)
-            if (this.objint == null) {
-              throw new Error('this.objint is not set')
+      /**
+       *  @param {WebTransportSendOptions|undefined} options
+       *  @return {import('./dom').WebTransportDatagramsWritable}
+       */
+      createWritable: (options) => {
+        let sendOrder = options?.sendOrder ?? 0n
+        let sendGroup = options?.sendGroup
+        /** @type {WebTransportSendStream} */
+        // @ts-expect-error some props are initially missing
+        const retWritable = new WritableStream({
+          start: (controller) => {
+            this.outgoDatagramController = controller
+          },
+          // eslint-disable-next-line no-unused-vars
+          write: (chunk, controller) => {
+            if (this.state === 'closed') throw new Error('Session is closed')
+            if (chunk instanceof Uint8Array) {
+              /** @type {Promise<void>} */
+              if (this.objint == null) {
+                throw new Error('this.objint is not set')
+              }
+              const { code, message } = this.objint.writeDatagram(chunk)
+              if (
+                code !== 'success' &&
+                code !== 'blocked' &&
+                code !== 'tooBig'
+              ) {
+                throw new WebTransportError(code + ':' + message)
+              }
+            } else throw new Error('chunk is not of type Uint8Array')
+          },
+          close: () => {
+            // do nothing
+          }
+        })
+        Object.defineProperties(retWritable, {
+          sendOrder: {
+            get: () => {
+              return sendOrder
+            },
+            /**
+             * @param {bigint} value
+             */
+            set: (value) => {
+              sendOrder = value
+            }
+          },
+          sendGroup: {
+            get: () => {
+              return sendGroup
+            },
+            /**
+             * @param {WebTransportSendGroup} value
+             */
+            set: (value) => {
+              if (value !== sendGroup) {
+                sendGroup = value
+              }
             }
-            this.objint.writeDatagram(chunk)
-            return ret
-          } else throw new Error('chunk is not of type Uint8Array')
-        },
-        close: () => {
-          // do nothing
+          }
+        })
+        return retWritable
+      },
+      // @ts-ignore
+      get writable() {
+        // @ts-ignore
+        if (!this.datagramwritablepolyfilled_) {
+          console.warn('datagrams.writable is deprecated')
         }
-      })
+        // @ts-ignore
+        return (this.datagramwritablepolyfilled_ ||= this.createWritable())
+      },
+      get maxDatagramSize() {
+        // @ts-ignore
+        return this._getMaxDatagramSize()
+      },
+      // @ts-ignore
+      _getMaxDatagramSize: () => {
+        if (this.objint) {
+          this._lastGetMaxDatagramSize = this.objint.getMaxDatagramSize()
+        }
+        return this._lastGetMaxDatagramSize
+      }
     }
 
     /** @type {Array<(stream: WebTransportBidirectionalStream) => void>} */
@@ -193,6 +247,13 @@ export class HttpWTSession {
     this.sendStreamsController = new Set()
     /** @type {Set<ReadableStreamDefaultController>} */
     this.receiveStreamsController = new Set()
+
+    this._sendGroupNum = 1n // 0n is reserved for no sendgroup
+    /** @type {Map<bigint,WebTransportSendGroup>} */
+    this._sendGroupIndex = new Map()
+
+    /** @type {undefined|string} */
+    this._selectedProtocol = undefined
   }
 
   /**
@@ -210,6 +271,10 @@ export class HttpWTSession {
     }
   }
 
+  get protocol() {
+    return this._selectedProtocol
+  }
+
   getStats() {
     if (this.objint == null) {
       throw new Error('this.objint not set')
@@ -279,16 +344,6 @@ export class HttpWTSession {
       })
   }
 
-  async waitForDatagramsSend() {
-    while (this.writeDatagramProm.length > 0) {
-      try {
-        await Promise.allSettled(this.writeDatagramProm)
-      } catch (error) {
-        log.error('datagram promise failed ', error)
-      }
-    }
-  }
-
   notifySessionDraining() {
     if (this.objint == null) {
       throw new Error('this.objint not set')
@@ -361,7 +416,7 @@ export class HttpWTSession {
     })
     const notblocked = this.objint.orderBidiStream({
       sendGroup: opts?.sendGroup || null, // maybe replace, when implemented
-      sendOrder: opts?.sendOrder || 0,
+      sendOrder: BigInt(opts?.sendOrder || 0n),
       waitUntilAvailable: opts?.waitUntilAvailable || false
     })
     if (!notblocked) {
@@ -388,7 +443,7 @@ export class HttpWTSession {
     })
     const notblocked = this.objint.orderUnidiStream({
       sendGroup: opts?.sendGroup || null, // maybe replace, when implemented
-      sendOrder: opts?.sendOrder || 0,
+      sendOrder: opts?.sendOrder || 0n,
       waitUntilAvailable: opts?.waitUntilAvailable || false
     })
     if (!notblocked) {
@@ -417,7 +472,33 @@ export class HttpWTSession {
     }
   }
 
-  onReady(/* error */) {
+  /**
+   * @returns {WebTransportSendGroup}
+   */
+  createSendGroup() {
+    if (this.state === 'closed' || this.state === 'failed')
+      throw new Error('InvalidState')
+    const _sendGroupId = this._sendGroupNum++
+    const sendGroup = {
+      // @ts-ignore
+      _sendGroupId,
+      getStats: async () => {
+        // TODO implement
+        return {
+          bytesWritten: 0n,
+          bytesSent: 0n,
+          bytesAcknowledged: 0n
+        }
+      }
+    }
+    this._sendGroupIndex.set(_sendGroupId, sendGroup)
+    return sendGroup
+  }
+  /**
+   * @param {{protocol?: string}} arg
+   **/
+  onReady({ protocol }) {
+    if (protocol) this._selectedProtocol = protocol
     this.state = 'connected'
     if (!this.reliable) this.reliability = 'supports-unreliable'
     else this.reliability = 'reliable-only'
@@ -458,13 +539,9 @@ export class HttpWTSession {
 
     for (const rej of this.rejectBiDi) rej(error)
     for (const rej of this.rejectUniDi) rej(error)
-    for (const rej of this.writeDatagramRej) rej(error)
     for (const rej of this.rejectSessionStats) rej(error)
     for (const rej of this.rejectDatagramStats) rej(error)
 
-    this.writeDatagramRej = []
-    this.writeDatagramRes = []
-    this.writeDatagramProm = []
     this.resolveBiDi = []
     this.resolveUniDi = []
     this.rejectBiDi = []
@@ -519,7 +596,9 @@ export class HttpWTSession {
       parentobj: this,
       transport: this.parentobj,
       bidirectional: args.bidirectional,
-      incoming: args.incoming
+      incoming: args.incoming,
+      sendGroup: this._sendGroupIndex.get(args.sendGroupId || 0n),
+      sendOrder: args.sendOrder
     })
     this.addStreamObj(strobj)
     if (args.incoming) {
@@ -563,6 +642,11 @@ export class HttpWTSession {
    */
   onDatagramReceived(args) {
     log.trace('datagram received', args.datagram)
+    // streams spec says zero length chunk on byob stream is illegal
+    if (args.datagram.byteLength === 0) {
+      log.trace('zerolength datagram dropped')
+      return
+    }
     // console.log('datagram received', args.datagram, Date.now())
     if (this.incomDatagramController.byobRequest) {
       /** @type {ReadableStreamBYOBRequest} */
@@ -588,21 +672,6 @@ export class HttpWTSession {
     }
   }
 
-  /**
-   * @param {DatagramSendEvent} args
-   */
-  // eslint-disable-next-line no-unused-vars
-  onDatagramSend(args) {
-    if (this.state === 'closed') return
-    this.writeDatagramRej.shift()
-    this.writeDatagramProm.shift()
-    const res = this.writeDatagramRes.shift()
-
-    if (res != null) {
-      res()
-    }
-  }
-
   /**
    * @param {GoawayReceivedEvent} args
    */