@fails-components/webtransport 1.1.4 → 1.2.0

package/lib/http2/browser/browserparser.js

@@ -162,7 +162,10 @@ export class BrowserParser extends ParserBase {
           if (typeof streamid !== 'undefined') {
             let object = this.wtstreams.get(streamid)
             if (!object) {
-              object = this.newStream(streamid)
+              object = this.newStream(streamid, {
+                sendOrder: 0n,
+                sendGroupId: 0n
+              })
               if (!object) return // stream broken
             }
             // TODO submit data

package/lib/http2/node/capsuleparser.js

@@ -154,7 +154,10 @@ export class Http2CapsuleParser extends ParserBaseHttp2 {
                 if (typeof streamid !== 'undefined') {
                   let object = this.wtstreams.get(streamid)
                   if (!object) {
-                    object = this.newStream(streamid)
+                    object = this.newStream(streamid, {
+                      sendOrder: 0n,
+                      sendGroupId: 0n
+                    })
                     if (!object) return // stream broken
                   }
                   // TODO submit data

package/lib/http2/node/client.js

@@ -15,6 +15,7 @@ export class Http2WebTransportClient {
     this.port = Number(port)
     this.hostname = args?.host || 'localhost'
     this.serverCertificateHashes = args?.serverCertificateHashes || undefined
+    this.protocols = args?.protocols || []
     this.localPort = Number(args?.localPort) || undefined
     this.allowPooling = args?.allowPooling || false
     this.forceIpv6 = args?.forceIpv6 || false
@@ -29,12 +30,12 @@ export class Http2WebTransportClient {
       args?.initialUnidirectionalSendStreams || 100
 
     this.streamShouldAutoTuneReceiveWindow =
-      args.streamShouldAutoTuneReceiveWindow || false
+      args.streamShouldAutoTuneReceiveWindow || true
     this.streamFlowControlWindowSizeLimit =
       args?.streamFlowControlWindowSizeLimit || 6 * 1024 * 1024
 
     this.sessionShouldAutoTuneReceiveWindow =
-      args.sessionShouldAutoTuneReceiveWindow || false
+      args.sessionShouldAutoTuneReceiveWindow || true
     this.sessionFlowControlWindowSizeLimit =
       args?.sessionFlowControlWindowSizeLimit || 15 * 1024 * 1024
     /** @type {import('../../session.js').HttpClient} */
@@ -92,9 +93,9 @@ export class Http2WebTransportClient {
           0x2b63: this.initialStreamFlowControlWindow, // SETTINGS_WEBTRANSPORT_INITIAL_MAX_STREAM_DATA_BIDI
           0x2b64: this.initialUnidirectionalStreams, // SETTINGS_WEBTRANSPORT_INITIAL_MAX_STREAMS_UNI
           0x2b65: this.initialBidirectionalStreams // SETTINGS_WEBTRANSPORT_INITIAL_MAX_STREAMS_BIDI
-        },
-        remoteCustomSettings: [0x2b60, 0x2b61, 0x2b62, 0x2b63, 0x2b64, 0x2b65]
+        }
       },
+      remoteCustomSettings: [0x2b60, 0x2b61, 0x2b62, 0x2b63, 0x2b64, 0x2b65],
       localPort: this.localPort,
       // TODO: REMOVE BEFORE RELEASE; UNSAFE SETTING
       rejectUnauthorized: !this.serverCertificateHashes
@@ -109,26 +110,8 @@ export class Http2WebTransportClient {
       http2Options
     )
 
-    let rtt = 100
-    let adjust = 1
-    // ok we got a session and want to measure RTT
-    let pingsender = setInterval(() => {
-      if (this.clientInt && !this.clientInt.closed) {
-        // eslint-disable-next-line no-unused-vars
-        this.clientInt.ping((err, duration, payload) => {
-          if (!err) {
-            rtt = adjust * duration + (1 - adjust) * rtt
-            adjust = 0.2
-            // @ts-ignore
-            this.clientInt.WTrtt = rtt
-          }
-        })
-      } else {
-        clearInterval(pingsender)
-        // @ts-ignore
-        pingsender = undefined
-      }
-    }, 1000)
+    /** @type {NodeJS.Timeout|undefined} */
+    let pingsender
 
     this.clientInt.on('close', () => {
       if (pingsender) clearInterval(pingsender)
@@ -180,6 +163,28 @@ export class Http2WebTransportClient {
         this.jsobj.onClientConnected({
           success: true
         })
+        let rtt = 100
+        let adjust = 1
+        // ok we got a session and want to measure RTT
+        const pingupdater = () => {
+          if (this.clientInt && !this.clientInt.closed) {
+            // eslint-disable-next-line no-unused-vars
+            this.clientInt.ping((err, duration, payload) => {
+              if (!err) {
+                rtt = adjust * duration + (1 - adjust) * rtt
+                adjust = 0.2
+                // @ts-ignore
+                this.clientInt.WTrtt = rtt
+              }
+            })
+          } else {
+            clearInterval(pingsender)
+            // @ts-ignore
+            pingsender = undefined
+          }
+        }
+        pingsender = setInterval(pingupdater, 1000)
+        pingupdater()
       }
     })
     this.clientInt.on('error', (error) => {
@@ -207,14 +212,20 @@ export class Http2WebTransportClient {
   openWTSession(path) {
     if (!this.clientInt) throw new Error('clientInt not present')
 
-    const stream = this.clientInt.request({
+    const requestOpts = {
       ':method': 'CONNECT',
       ':protocol': 'webtransport',
       ':scheme': 'https',
       ':path': path,
       authority: this.hostname,
       origin: this.hostname
-    })
+    }
+    if (this.protocols.length > 0) {
+      // @ts-ignore
+      requestOpts['wt-available-protocols'] = this.protocols.join(',')
+    }
+
+    const stream = this.clientInt.request(requestOpts)
     const {
       0x2b65: remoteBidirectionalStreams = undefined,
       0x2b64: remoteUnidirectionalStreams = undefined,
@@ -255,7 +266,7 @@ export class Http2WebTransportClient {
         sendWindowOffset:
           remoteSessionFlowControlWindow ||
           this.sessionFlowControlWindowSizeLimit,
-        receiveWindowOffset: this.sessionFlowControlWindowSizeLimit,
+        receiveWindowOffset: this.initialSessionFlowControlWindow,
         shouldAutoTuneReceiveWindow: this.sessionShouldAutoTuneReceiveWindow,
         receiveWindowSizeLimit: this.sessionFlowControlWindowSizeLimit
       }),

package/lib/http2/node/server.js

@@ -33,12 +33,12 @@ export class Http2WebTransportServer {
       args?.initialUnidirectionalStreams || 100
 
     this.streamShouldAutoTuneReceiveWindow =
-      args.streamShouldAutoTuneReceiveWindow || false
+      args.streamShouldAutoTuneReceiveWindow || true
     this.streamFlowControlWindowSizeLimit =
       args?.streamFlowControlWindowSizeLimit || 6 * 1024 * 1024
 
     this.sessionShouldAutoTuneReceiveWindow =
-      args.sessionShouldAutoTuneReceiveWindow || false
+      args.sessionShouldAutoTuneReceiveWindow || true
     this.sessionFlowControlWindowSizeLimit =
       args?.sessionFlowControlWindowSizeLimit || 15 * 1024 * 1024
 
@@ -65,9 +65,9 @@ export class Http2WebTransportServer {
           0x2b63: this.initialStreamFlowControlWindow, // SETTINGS_WEBTRANSPORT_INITIAL_MAX_STREAM_DATA_BIDI
           0x2b64: this.initialUnidirectionalStreams, // SETTINGS_WEBTRANSPORT_INITIAL_MAX_STREAMS_UNI
           0x2b65: this.initialBidirectionalStreams // SETTINGS_WEBTRANSPORT_INITIAL_MAX_STREAMS_BIDI
-        },
-        remoteCustomSettings: [0x2b60, 0x2b61, 0x2b62, 0x2b63, 0x2b64, 0x2b65]
-      }
+        }
+      },
+      remoteCustomSettings: [0x2b60, 0x2b61, 0x2b62, 0x2b63, 0x2b64, 0x2b65]
     })
 
     this.serverInt.on('listening', () => {
@@ -95,7 +95,7 @@ export class Http2WebTransportServer {
       let rtt = 100
       let adjust = 1
       // ok we got a session and want to measure RTT
-      let pingsender = setInterval(() => {
+      const pingupdater = () => {
         if (!session.closed)
           // eslint-disable-next-line no-unused-vars
           session.ping((err, duration, payload) => {
@@ -111,7 +111,9 @@ export class Http2WebTransportServer {
           // @ts-ignore
           pingsender = undefined
         }
-      }, 1000)
+      }
+      let pingsender = setInterval(pingupdater, 1000)
+      pingupdater()
 
       session.on('close', () => {
         if (pingsender) clearInterval(pingsender)
@@ -136,7 +138,11 @@ export class Http2WebTransportServer {
           path = path?.slice(1)
         }
         const header = { ...request.headers, ':path': path }
-        const websocketProt = this.checkProtocolHeader(header)
+        const { websocketProt, webtransportProt } =
+          this.checkProtocolHeader(header)
+        if (webtransportProt) {
+          header['wt-available-protocols'] = webtransportProt
+        }
         if (!websocketProt) {
           stream.destroy()
           return
@@ -227,7 +233,11 @@ export class Http2WebTransportServer {
         header[':protocol'] === 'websocket' &&
         header['sec-websocket-protocol']
       ) {
-        websocketProt = this.checkProtocolHeader(header)
+        let obj = this.checkProtocolHeader(header)
+        websocketProt = obj.websocketProt
+        if (obj.webtransportProt) {
+          header['wt-available-protocols'] = obj.webtransportProt
+        }
       }
       if (header[':protocol'] !== 'webtransport' && !websocketProt) {
         stream.respond({
@@ -334,8 +344,11 @@ export class Http2WebTransportServer {
         const resp = {
           ':status': '200'
         }
-        // @ts-ignore
-        if (websocketProt) resp['sec-websocket-protocol'] = websocketProt
+
+        if (websocketProt) {
+          // @ts-ignore
+          resp['sec-websocket-protocol'] = websocketProt
+        }
         stream.respond(resp)
         this.jsobj.onHttpWTSessionVisitor(retObj)
       } else {
@@ -352,9 +365,12 @@ export class Http2WebTransportServer {
 
   /**
    * @param {import("http2").IncomingHttpHeaders} header
+   * @return {{websocketProt: string|undefined, webtransportProt?: string}}
    */
   checkProtocolHeader(header) {
     const sechead = header['sec-websocket-protocol']
+      ?.split?.(',')
+      ?.map?.((el) => el.trim())
     let prots
     if (!Array.isArray(sechead)) {
       prots = [sechead]
@@ -365,8 +381,19 @@ export class Http2WebTransportServer {
       .map((el) => (el ? el.split('_') : [undefined, undefined]))
       .filter((el) => el[0] === 'webtransport')
       .filter((el) => (el[1] ? supportedVersions.includes(el[1]) : false))
-    if (prots.length > 0) return prots[0].join('_')
-    else return undefined
+    if (prots.length > 0) {
+      const selWtVersion = prots[0][1]
+      prots = prots.filter((el) => el[1] === selWtVersion)
+      /** @type {{websocketProt: string|undefined, webtransportProt?: string}} */
+      const retObj = { websocketProt: prots[0].slice(0, 2).join('_') }
+      if (prots[0][2]) {
+        // @ts-ignore
+        retObj.webtransportProt = [
+          ...new Set(prots.map((el) => el.slice(2).join('_')))
+        ].join(',')
+      }
+      return retObj
+    } else return { websocketProt: undefined }
   }
 
   startServer() {
@@ -444,7 +471,8 @@ export class Http2WebTransportServer {
     protocol,
     head,
     path,
-    transportPrivate
+    transportPrivate,
+    selectedProtocol
   }) {
     if (status !== 200) {
       if (protocol === 'websocketoverhttp1') {
@@ -462,8 +490,11 @@ export class Http2WebTransportServer {
           // @ts-ignore
           stream,
           header,
-          // @ts-ignore
-          protocol: transportPrivate.websocketProt
+          protocol: selectedProtocol
+            ? // @ts-ignore
+              transportPrivate.websocketProt + '_' + selectedProtocol
+            : // @ts-ignore
+              transportPrivate.websocketProt
         })
           .then(() => {
             const retObj = {
@@ -496,7 +527,7 @@ export class Http2WebTransportServer {
                 initialUnidirectionalReceiveStreams:
                   this.initialUnidirectionalStreams,
                 sendWindowOffset: 0,
-                receiveWindowOffset: this.sessionFlowControlWindowSizeLimit,
+                receiveWindowOffset: this.initialSessionFlowControlWindow,
                 shouldAutoTuneReceiveWindow:
                   this.sessionShouldAutoTuneReceiveWindow,
                 receiveWindowSizeLimit: this.sessionFlowControlWindowSizeLimit
@@ -518,7 +549,13 @@ export class Http2WebTransportServer {
         // @ts-ignore
         if (transportPrivate?.websocketProt)
           // @ts-ignore
-          resp['sec-websocket-protocol'] = transportPrivate.websocketProt
+          resp['sec-websocket-protocol'] = selectedProtocol
+            ? // @ts-ignore
+              transportPrivate.websocketProt + '_' + selectedProtocol
+            : // @ts-ignore
+              transportPrivate.websocketProt
+        // @ts-ignore
+        else if (selectedProtocol) resp['wt-protocol'] = selectedProtocol
         stream.respond(resp)
         const {
           0x2b65: remoteBidirectionalStreams = undefined,
@@ -587,7 +624,7 @@ export class Http2WebTransportServer {
                 ? remoteSessionFlowControlWindow ||
                   this.sessionFlowControlWindowSizeLimit
                 : 0, // TODO, once supported by node, use initial settings
-            receiveWindowOffset: this.sessionFlowControlWindowSizeLimit,
+            receiveWindowOffset: this.initialSessionFlowControlWindow,
             shouldAutoTuneReceiveWindow:
               this.sessionShouldAutoTuneReceiveWindow,
             receiveWindowSizeLimit: this.sessionFlowControlWindowSizeLimit

package/lib/http2/node/websocketparser.js

@@ -132,8 +132,8 @@ function applyMask(ms, buffer, offset, length) {
     for (let run = 0 /* Math.round(length / 4) * 4 */; run < length; run++) {
       data[run] ^= workmask[run % 4]
     }
-    ms.offset += length
   }
+  ms.offset += length
 }
 /*
 function readDWord(bs) {
@@ -541,7 +541,10 @@ export class WebSocketParser extends ParserBaseHttp2 {
                   if (typeof streamid !== 'undefined') {
                     let object = this.wtstreams.get(streamid)
                     if (!object) {
-                      object = this.newStream(streamid)
+                      object = this.newStream(streamid, {
+                        sendOrder: 0n,
+                        sendGroupId: 0n
+                      })
                       if (!object) return // stream broken
                     }
                     // TODO submit data

package/lib/http2/parserbase.js

@@ -1,5 +1,6 @@
 import { Http2WebTransportStream } from './stream.js'
 import { logger } from '../utils.js'
+import { PriorityScheduler } from './priorityscheduler.js'
 
 const pid = typeof process !== 'undefined' ? process.pid : 0
 const log = logger(`webtransport:parserbase(${pid})`)
@@ -59,6 +60,8 @@ export class ParserBase {
 
     /** @type {Map<bigint,Http2WebTransportStream>} */
     this.wtstreams = new Map()
+
+    this.scheduler = new PriorityScheduler()
   }
 
   /**
@@ -101,8 +104,9 @@ export class ParserBase {
 
   /**
    * @param {bigint} streamid
+   * @param {{sendOrder: bigint,sendGroupId: bigint}} priority
    */
-  newStream(streamid) {
+  newStream(streamid, priority) {
     const incoming = this.isclient ? !(streamid & 0x1n) : !!(streamid & 0x1n)
     const streamIdManager =
       streamid & 0x2n
@@ -138,16 +142,36 @@ export class ParserBase {
       streamIdManager
     })
     this.wtstreams.set(streamid, stream)
+    this.scheduler.Register(streamid, priority)
     this.session.jsobj.onStream({
       bidirectional: !(streamid & 0x2n),
       incoming,
-      stream
+      stream,
+      sendGroupId: priority.sendGroupId,
+      sendOrder: priority.sendOrder
     })
     return stream
   }
 
+  scheduleDrainWrites() {
+    if (this._scheduledDrainWriteCall) return
+    const prom = Promise.resolve()
+    this._scheduledDrainWriteCall = prom
+    prom
+      .then(() => {
+        delete this._scheduledDrainWriteCall
+        this.drainWrites()
+      })
+      .catch((error) => log('Error in drainWrites', error))
+  }
+
   drainWrites() {
-    for (const stream of this.wtstreams.values()) {
+    if (!this.blocked) this.session.drainWrites()
+    while (!this.blocked) {
+      const frontId = this.scheduler.PopFront()
+      if (typeof frontId === 'undefined') break
+      const stream = this.wtstreams.get(frontId)
+      if (!stream) break
       stream.drainWrites()
     }
   }
@@ -156,8 +180,16 @@ export class ParserBase {
    * @param {bigint|undefined} val
    */
   onMaxData(val) {
-    if (val && this.session.flowController.updateSendWindowOffset(val))
-      this.drainWrites()
+    if (val && this.session.flowController.updateSendWindowOffset(val)) {
+      let pending = false
+      this.wtstreams.forEach((stream, streamid) => {
+        if (stream.hasPendingData()) {
+          pending = true
+          this.scheduleDrainWriteStream(streamid)
+        }
+      })
+      if (pending) this.drainWrites()
+    }
   }
 
   /**
@@ -167,8 +199,10 @@ export class ParserBase {
   onMaxStreamData(streamid, offset) {
     const object = this.wtstreams.get(streamid)
     if (object && offset) {
-      if (object.flowController.updateSendWindowOffset(offset))
-        object.drainWrites()
+      if (object.flowController.updateSendWindowOffset(offset)) {
+        this.scheduleDrainWriteStream(streamid)
+        this.drainWrites()
+      }
     }
   }
 
@@ -251,6 +285,41 @@ export class ParserBase {
     this.session.jsobj.onGoAwayReceived()
   }
 
+  /**
+   *
+   * @param {bigint} streamid
+   */
+  shouldYieldStream(streamid) {
+    return this.scheduler.ShouldYield(streamid)
+  }
+
+  /**
+   *
+   * @param {bigint} streamid
+   */
+  scheduleDrainWriteStream(streamid) {
+    this.scheduler.Schedule(streamid)
+  }
+
+  /**
+   *
+   * @param {bigint} streamid
+   */
+  removeStream(streamid) {
+    this.scheduler.Unregister(streamid)
+    //this.wtstreams.delete(streamid) // why does this create troubles
+  }
+
+  /**
+   *
+   * @param {bigint} streamid
+   * @param {{sendOrder: bigint, sendGroupId: bigint}} arg2
+   */
+  streamUpdateSendOrderAndGroup(streamid, { sendOrder, sendGroupId }) {
+    this.scheduler.UpdateSendGroup(streamid, sendGroupId)
+    this.scheduler.UpdateSendOrder(streamid, sendOrder)
+  }
+
   /**
    * @param {number} code
    */