@fails-components/webtransport 1.1.3 → 1.2.0

package/lib/stream.js

@@ -20,6 +20,8 @@ const log = logger(`webtransport:http3wtstream(${pid})`)
  * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
  * @typedef {import('./dom').WebTransportSendStream} WebTransportSendStream
  *
+ * @typedef {import('./dom').WebTransportSendGroup} WebTransportSendGroup
+ *
  * @typedef {import('./session').HttpWTSession} HttpWTSession
  *
  * @typedef {import('stream/web').WritableStreamDefaultController} WritableStreamDefaultController
@@ -33,6 +35,8 @@ export class HttpWTStream {
    * @param {object} args.transport
    * @param {boolean} args.bidirectional
    * @param {boolean} args.incoming
+   * @param {WebTransportSendGroup|undefined} args.sendGroup
+   * @param {bigint} args.sendOrder
    */
   constructor(args) {
     this.objint = args.object
@@ -43,6 +47,9 @@ export class HttpWTStream {
     this.incoming = args.incoming
     this.closed = false
 
+    this._sendGroup = args.sendGroup
+    this._sendOrder = args.sendOrder
+
     if (this.objint.sendInitialParameters) {
       this.objint.sendInitialParameters()
     }
@@ -140,18 +147,15 @@ export class HttpWTStream {
               wchunk = new Uint8Array(wchunk)
             }
             if (wchunk instanceof Uint8Array) {
+              if (wchunk.byteLength === 0) {
+                // or should we throw an error ?, Ask the W3C people!
+                return
+              }
               // eslint-disable-next-line no-unused-vars
               this.pendingoperation = new Promise((resolve, reject) => {
                 this.pendingres = resolve
               })
-              this.parentobj
-                .waitForDatagramsSend()
-                .finally(() => {
-                  this.objint.writeChunk(wchunk)
-                })
-                .catch((/** @type {any} */ err) => {
-                  log.error(err)
-                })
+              this.objint.writeChunk(wchunk)
               return this.pendingoperation
             } else {
               log.trace('chunk info:', chunk)
@@ -203,6 +207,36 @@ export class HttpWTStream {
           bytesAcknowledged: 0n
         })
       }
+      Object.defineProperties(this.writable, {
+        sendOrder: {
+          get: () => {
+            return this._sendOrder
+          },
+          /**
+           * @param {bigint} value
+           */
+          set: (value) => {
+            if (value !== this._sendOrder) {
+              this._sendOrder = args.sendOrder
+              this.updateSendOrderAndGroup()
+            }
+          }
+        },
+        sendGroup: {
+          get: () => {
+            return this._sendGroup
+          },
+          /**
+           * @param {WebTransportSendGroup} value
+           */
+          set: (value) => {
+            if (value !== this._sendGroup) {
+              this._sendGroup = value
+              this.updateSendOrderAndGroup()
+            }
+          }
+        }
+      })
       // @ts-ignore
       this.parentobj.addSendStream(this.writable, this.writableController)
     }
@@ -278,6 +312,14 @@ export class HttpWTStream {
     return retObj
   }
 
+  updateSendOrderAndGroup() {
+    this.objint.updateSendOrderAndGroup({
+      sendOrder: this._sendOrder,
+      // @ts-ignore
+      sendGroupId: this._sendGroup._sendGroupId
+    })
+  }
+
   /**
    * @param {import('./types').StreamRecvSignalEvent} args
    * @returns {void}

package/lib/types.ts

@@ -2,7 +2,7 @@ import type {
   WebTransportSession,
   WebTransportHash,
   WebTransportOptions,
-  WebTransportSendGroup
+  WebTransportSendStreamOptions
 } from './dom'
 import type { IncomingHttpHeaders, Http2Stream, ServerHttp2Stream } from 'http2'
 import { ParserBase } from './http2/parserbase'
@@ -15,12 +15,13 @@ import { HttpClient } from './client'
 export interface NativeHttpWTSession {
   jsobj: WebTransportSessionEventHandler
   sendInitialParameters?: () => void
-  writeDatagram: (chunk: Uint8Array) => void
-  orderUnidiStream: (opts:{sendGroup:  WebTransportSendGroup|null, sendOrder: number, waitUntilAvailable: boolean}) => boolean
-  orderBidiStream: (opts:{sendGroup:  WebTransportSendGroup|null, sendOrder: number, waitUntilAvailable: boolean})  => boolean
+  writeDatagram: (chunk: Uint8Array) => { code: 'success' | 'blocked' | 'internalError' | 'tooBig', message?: string}
+  orderUnidiStream: (opts: WebTransportSendStreamOptions) => boolean
+  orderBidiStream: (opts: WebTransportSendStreamOptions)  => boolean
   orderSessionStats: () => void
   orderDatagramStats: () => void
   notifySessionDraining: () => void
+  getMaxDatagramSize: () => number
   close: (arg: { code: number; reason: string }) => void
 }
 
@@ -38,6 +39,10 @@ export interface NativeHttpWTStream {
   resetStream: (code: number) => void
   writeChunk: (buf: Uint8Array) => void
   streamFinal: () => void
+  updateSendOrderAndGroup: (args :{
+    sendOrder: bigint,
+    sendGroupId: bigint
+  }) => void
 }
 
 export interface NativeServerOptions {
@@ -79,6 +84,7 @@ export interface NativeClientOptions {
   initialSessionFlowControlWindow?: number
   sessionShouldAutoTuneReceiveWindow?: boolean
   sessionFlowControlWindowSizeLimit?: number
+  protocols?: string[]
 }
 
 export interface FlowControlable {
@@ -110,7 +116,8 @@ export interface NativeFinishSessionRequest {
   protocol: 'capsule' | 'websocket' | 'websocketoverhttp1' | 'http3'
   head?: Buffer
   userData?: object
-  transportPrivate?: object
+  transportPrivate?: object,
+  selectedProtocol?: string
 }
 
 export type Purpose =
@@ -150,6 +157,7 @@ export interface WebTransportStreamEventHandler {
 
 export interface SessionReadyEvent {
   object: NativeHttpWTSession
+  protocol?: string
 }
 
 export interface SessionCloseEvent {
@@ -179,21 +187,20 @@ export interface DatagramReceivedEvent {
   datagram: Uint8Array
 }
 
-export interface DatagramSendEvent {}
-
 export interface GoawayReceivedEvent {}
 
 export interface NewStreamEvent {
   stream: NativeHttpWTStream
   bidirectional: boolean
   incoming: boolean
+  sendGroupId?: bigint;
+  sendOrder: bigint;
 }
 
 export interface WebTransportSessionEventHandler {
   onReady: (evt: SessionReadyEvent) => void
   onClose: (evt: SessionCloseEvent) => void
   onDatagramReceived: (evt: DatagramReceivedEvent) => void
-  onDatagramSend: (evt: DatagramSendEvent) => void
   onGoAwayReceived: (evt: GoawayReceivedEvent) => void
   onSessionStats: (evt: SessionStatsEvent) => void
   onDatagramStats: (evt: DatagramStatsEvent) => void

package/lib/webtransport.browser.js

@@ -3,6 +3,7 @@ import { HttpWTSession } from './session.js'
 import { HttpClient } from './client.js'
 import { Http2WebTransportBrowser } from './http2/browser/browser.js'
 import { logger } from './utils.js'
+import { WebTransportError } from './error'
 
 const log = logger(`webtransport:browser()`)
 
@@ -13,7 +14,7 @@ const log = logger(`webtransport:browser()`)
  * @typedef {import('./dom').WebTransportSendStream} WebTransportSendStream
  * @typedef {import('./dom').WebTransportSendStreamOptions} WebTransportSendStreamOptions
  * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
- * @typedef {import('./error').WebTransportError} WebTransportError
+ * @typedef {import('./dom').WebTransportSendGroup} WebTransportSendGroup
  */
 
 /**
@@ -215,7 +216,17 @@ export class WebTransportPolyfill {
     }
     /** @type {import('./dom').WebTransportDatagramDuplexStream} */
     // @ts-ignore
-    this.datagrams = {}
+    this.datagrams = {
+      // @ts-ignore
+      get writable() {
+        // @ts-ignore
+        if (!this.datagramwritablepolyfilled_) {
+          console.warn('datagrams.writable is deprecated')
+        }
+        // @ts-ignore
+        return (this.datagramwritablepolyfilled_ ||= this.createWritable())
+      }
+    }
     // @ts-ignore
     this.datagrams.readable = new ReadableStream({
       // eslint-disable-next-line no-unused-vars
@@ -233,23 +244,67 @@ export class WebTransportPolyfill {
       }
     })
     // @ts-ignore
-    this.datagrams.writable = new WritableStream({
-      // eslint-disable-next-line no-unused-vars
-      start: async (controller) => {
-        await this.ready
-        this.datagramsWriter = this.curtransport.datagrams.writable.getWriter()
-      },
-      // eslint-disable-next-line no-unused-vars
-      write: async (chunk, controller) => {
-        await this.datagramsWriter.write(chunk)
-      },
-      abort: async (reason) => {
-        await this.datagramsWriter.abort(reason)
-      },
-      close: async () => {
-        await this.datagramsWriter.close()
+    this.datagrams.createWritable = (options) => {
+      // @ts-ignore Must not exist for older browser
+      if (this.curtransport.datagrams.createWritable) {
+        return this.curtransport.datagrams.createWritable(options)
       }
-    })
+      // we need to fallback to the old default writable
+      // @ts-ignore
+      if (!this.curtransport.datagrams.writable) {
+        throw new WebTransportError('No way to send out datagrams')
+      }
+      let sendOrder = options?.sendOrder
+      let sendGroup = options?.sendGroup
+      const retWritable = new WritableStream({
+        // eslint-disable-next-line no-unused-vars
+        start: async (controller) => {
+          await this.ready
+          if (!this.datagramsWriter) {
+            this.datagramsWriter =
+              // @ts-ignore
+              this.curtransport.datagrams.writable.getWriter()
+          }
+        },
+        // eslint-disable-next-line no-unused-vars
+        write: async (chunk, controller) => {
+          await this.datagramsWriter.write(chunk)
+        },
+        abort: async (reason) => {
+          await this.datagramsWriter.abort(reason)
+        },
+        close: async () => {
+          await this.datagramsWriter.close()
+        }
+      })
+      Object.defineProperties(retWritable, {
+        sendOrder: {
+          get: () => {
+            return sendOrder
+          },
+          /**
+           * @param {number} value
+           */
+          set: (value) => {
+            sendOrder = value
+          }
+        },
+        sendGroup: {
+          get: () => {
+            return sendGroup
+          },
+          /**
+           * @param {WebTransportSendGroup} value
+           */
+          set: (value) => {
+            if (value !== sendGroup) {
+              sendGroup = value
+            }
+          }
+        }
+      })
+      return retWritable
+    }
     this.incomingBidirectionalStreams = new ReadableStream({
       // eslint-disable-next-line no-unused-vars
       start: async (controller) => {
@@ -300,6 +355,10 @@ export class WebTransportPolyfill {
     return true
   }
 
+  get protocol() {
+    return this.curtransport?.protocol || undefined
+  }
+
   getStats() {
     // @ts-ignore
     return this.curtransport.getStats()

package/lib/webtransportbase.js

@@ -152,4 +152,11 @@ export class WebTransportBase {
 
     return session.createUnidirectionalStream(opts)
   }
+
+  get protocol() {
+    const session = this.sessionint
+    if (!session) return undefined
+
+    return session.protocol
+  }
 }

package/old_test/echoserver.js

@@ -5,7 +5,7 @@
 import { Http3Server } from '../lib/index.js'
 import { runEchoServer } from './testsuite.js'
 import { existsSync, readFileSync, writeFile } from 'node:fs'
-import { generateWebTransportCertificate } from '../test/fixtures/certificate.js'
+import { generateWebTransportCertificate } from '../../test/fixtures/certificate.js'
 
 let certificate = null
 

package/old_test/test.js

@@ -4,7 +4,7 @@
 
 // this file runs various tests
 
-import { generateWebTransportCertificate } from '../test/fixtures/certificate.js'
+import { generateWebTransportCertificate } from '../../test/fixtures/certificate.js'
 import {
   Http3Server,
   Http2Server,

package/old_test/testsuite.js

@@ -70,7 +70,9 @@ export async function unidirectionalEchoTest(session) {
  */
 export async function datagramEchoTest(session) {
   try {
-    session.datagrams.readable.pipeTo(session.datagrams.writable)
+    const writable =
+      session.datagrams.writable || session.datagrams.createWritable()
+    session.datagrams.readable.pipeTo(writable)
   } catch (error) {
     console.log('datagram echo exited with', error)
   }
@@ -287,7 +289,9 @@ export async function echoTestsConnection(transport) {
   console.log('TEST 3: finish')
   console.log('TEST 4: start')
   console.log('finally test datagrams')
-  const datawrite = await transport.datagrams.writable.getWriter()
+  const dwritable =
+    transport.datagrams.writable || transport.datagrams.createWritable()
+  const datawrite = await dwritable.getWriter()
   const data7 = new Uint8Array([83, 84, 85])
   const data8 = new Uint8Array([86, 87, 88])
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fails-components/webtransport",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "description": "A component to add webtransport support (server and client) to node.js using libquiche",
   "exports": {
     ".": {
@@ -21,21 +21,9 @@
   "types": "./dist/lib/index.types.d.ts",
   "scripts": {
     "start": "node test/echoserver.js",
-    "test": "npm run test:node && npm run test:node:http2 && npm run test:chromium && npm run test:chromium:http2:polyfill && npm run test:chromium:http2:ponyfill && npm run test:firefox:http2:polyfill && npm run test:firefox:http2:ponyfill && npm run test:webkit:http2:polyfill && npm run test:webkit:http2:ponyfill",
-    "test:node": "node test/index.js node http3",
-    "test:node:http2": "node test/index.js node http2",
-    "test:chromium": "node test/index.js chromium http3",
-    "test:chromium:http2:polyfill": "node test/index.js chromium http2 polyfill",
-    "test:chromium:http2:ponyfill": "node test/index.js chromium http2 ponyfill",
-    "test:firefox": "node test/index.js firefox http3",
-    "test:firefox:http2:polyfill": "node test/index.js firefox http2 polyfill",
-    "test:firefox:http2:ponyfill": "node test/index.js firefox http2 ponyfill",
-    "test:webkit": "node test/index.js webkit http3",
-    "test:webkit:http2:polyfill": "node test/index.js webkit http2 polyfill",
-    "test:webkit:http2:ponyfill": "node test/index.js webkit http2 ponyfill",
     "oldtest": "node old_test/test.js",
     "oldtesthttp2": "node old_test/test.js http2",
-    "lint": "eslint lib test old_test"
+    "lint": "eslint lib old_test"
   },
   "repository": {
     "type": "git",
@@ -63,22 +51,15 @@
     "@types/dirty-chai": "^2.0.2",
     "@types/mocha": "^10.0.0",
     "@types/node": "^18.15.3",
-    "chai": "^4.3.6",
-    "chai-as-promised": "^7.1.1",
-    "dirty-chai": "^2.0.1",
     "eslint": "^9.3.0",
     "eslint-config-prettier": "^9.1.0",
-    "eslint-config-standard": "^16.0.2",
-    "eslint-plugin-import": "^2.25.2",
+    "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-prettier": "^5.1.3",
-    "eslint-plugin-promise": "^4.3.1",
-    "eslint-plugin-standard": "^4.1.0",
-    "execa": "^6.1.0",
-    "mocha": "^10.1.0",
-    "node-forge": "^1.3.1",
-    "playwright-test": "^12.3.4",
-    "prettier": "^3.2.5",
+    "eslint-plugin-promise": "^7.2.1",
+    "prettier": "^3.5.3",
+    "prettier-linter-helpers": "^1.0.0",
+    "synckit": "^0.11.4",
     "typescript": "^4.8.4",
     "uint8arrays": "^4.0.2"
   },
@@ -88,8 +69,6 @@
     ]
   },
   "browser": {
-    "./test/fixtures/webtransport.js": "./test/fixtures/webtransport.browser.js",
-    "./test/fixtures/quiche.js": "./test/fixtures/quiche.browser.js",
     "./lib/webstreams.js": "./lib/webstreams.browser.js"
   }
 }

package/readme.md

@@ -72,8 +72,8 @@ The package `webtransport-transport-http3-quiche` provides prebuild binaries for
 Other platforms may be possible via cross-compiling in the GitHub actions, if someone needs this, PRs are welcome.
 
 Of course, you can also build the binary on your system.
-If you are running the compiling install as root, you need to use `--`unsafe-perm` as a flag.
-Installing the package without prebuild requires a full building environment including clang-9, perl6, python, golang,  `ninja-build, `and `icu``.` See the `Dockerfile` or `Dockerfile.development` for required Debian packages.
+If you are running the compiling install as root, you need to use `--unsafe-perm` as a flag.
+Installing the package without prebuild requires a full building environment including `clang-9`, `perl6`, `python`, `golang`,  `ninja-build`, and `icu`. See the `Dockerfile` or `Dockerfile.development` for required Debian packages.
 This should work for Windows, Linux and Mac OS X.
 (You may want to check out the building dependencies (especially for Windows) for BoringSSl, zlib, abseil on their respective websites).
 
@@ -109,7 +109,9 @@ Other but more expert options include:
 * `certhttp2` and `privKeyhttp2`: For providing a different certificate for the http/2 as the  http/2 implementation does not support certificate matching by fingerprints.
 * `initialStreamFlowControlWindow`, `initialSessionFlowControlWindow`, `streamShouldAutoTuneReceiveWindow`, `sessionShouldAutoTuneReceiveWindow`, `streamFlowControlWindowSizeLimit`, `sessionFlowControlWindowSizeLimit`: As expert's option for tweaking the internal flow control.
 
-The method `setRequestHandler(callback)` sets a callback, that inspects incoming headers and allows to change the incoming path header and also to throw an error if the session should not be opened. This method is considered to be experimental.
+The method `setRequestCallback(callback)` sets a callback, that inspects incoming headers and allows to change the incoming path header and also to throw an error if the session should not be opened. 
+It is also required for selecting the application level protocol.
+In order to see how it is used, look into `test/fixtures/server.js` for a working example.
 In general, the HTTP header is attached as the `header` property to the WebTransport Session object.
 
 The method `updateCert(cert, privKey, http2only)` allows to change the certificate, while the server is running (not supported by all transports).

package/test/bidirectional-streams.spec.js

@@ -1,150 +0,0 @@
-/* eslint-env mocha */
-
-import { getReaderValue } from './fixtures/reader-value.js'
-import { expect } from './fixtures/chai.js'
-import { readStream } from './fixtures/read-stream.js'
-import { writeStream } from './fixtures/write-stream.js'
-import { readCertHash } from './fixtures/read-cert-hash.js'
-import WebTransport from './fixtures/webtransport.js'
-import { quicheLoaded } from './fixtures/quiche.js'
-import * as ui8 from 'uint8arrays'
-import {
-  KNOWN_BYTES,
-  KNOWN_BYTES_LENGTH,
-  KNOWN_BYTES_LONG,
-  KNOWN_BYTES_LONG_LENGTH
-} from './fixtures/known-bytes.js'
-
-/**
- * @template T
- * @typedef {import('../lib/types').Deferred<T>} Deferred<T>
- */
-describe('bidirectional streams', function () {
-  let forceReliable = false
-  if (process.env.USE_HTTP2 === 'true') forceReliable = true
-  /** @type {import('../lib/dom').WebTransport | undefined} */
-  let client
-
-  const wtOptions = {
-    serverCertificateHashes: [
-      {
-        algorithm: 'sha-256',
-        value: readCertHash(process.env.CERT_HASH)
-      }
-    ],
-    // @ts-ignore
-    forceReliable
-  }
-  if (process.env.NO_CERT_HASHES === 'true')
-    // @ts-ignore
-    delete wtOptions.serverCertificateHashes
-
-  // @ts-ignore
-  beforeEach(async () => {
-    if (
-      process.env.USE_HTTP2 !== 'true' &&
-      process.env.USE_PONYFILL !== 'true' &&
-      process.env.USE_POLYFILL !== 'true'
-    ) {
-      await quicheLoaded
-    }
-  })
-
-  // @ts-ignore
-  afterEach(async () => {
-    if (client != null) {
-      client.close()
-      client = undefined
-    }
-  })
-
-  it('sends and receives data over an outgoing bidirectional stream', async () => {
-    // client context - connects to the server, opens a bidi stream, sends some data and reads the response
-    client = new WebTransport(
-      `${process.env.SERVER_URL}/bidirectional_client_initiated_echo`,
-      wtOptions
-    )
-    await client.ready
-
-    const stream = await client.createBidirectionalStream()
-    await writeStream(stream.writable, KNOWN_BYTES)
-
-    const output = await readStream(stream.readable, KNOWN_BYTES_LENGTH)
-    expect(ui8.concat(KNOWN_BYTES)).to.deep.equal(
-      ui8.concat(output),
-      'Did not receive the same bytes we sent'
-    )
-  })
-
-  it('sends and receives data over an outgoing bidirectional stream with big buffers', async () => {
-    // client context - connects to the server, opens a bidi stream, sends some data and reads the response
-    client = new WebTransport(
-      `${process.env.SERVER_URL}/bidirectional_client_initiated_echo`,
-      wtOptions
-    )
-    await client.ready
-
-    const stream = await client.createBidirectionalStream()
-    await writeStream(stream.writable, KNOWN_BYTES_LONG)
-
-    const output = await readStream(stream.readable, KNOWN_BYTES_LONG_LENGTH)
-    const send = ui8.concat(KNOWN_BYTES_LONG)
-    const received = ui8.concat(output)
-    let failure = 0
-    for (let i = 0; i < Math.max(send.byteLength, received.byteLength); i++) {
-      if (send[i] !== received[i] && failure < 100) {
-        console.log('d: ', i, ' ,', send[i], ', ', received[i])
-        failure++
-      }
-    }
-
-    expect(ui8.concat(KNOWN_BYTES_LONG)).to.deep.equal(
-      ui8.concat(output),
-      'Did not receive the same bytes we sent'
-    )
-  })
-
-  it('sends and receives data over an incoming bidirectional stream', async () => {
-    // client context - waits for the server to open a bidi stream then pipes it back to them
-    client = new WebTransport(
-      `${process.env.SERVER_URL}/bidirectional_server_initiated_echo`,
-      wtOptions
-    )
-    await client.ready
-
-    const bidiStream = await getReaderValue(client.incomingBidirectionalStreams)
-
-    // redirect input to output
-    try {
-      await bidiStream.readable.pipeTo(bidiStream.writable)
-    } catch (error) {
-      console.log('Pipe to error (ignore)', error) // Actually all you can get is, that the fin is catched
-    }
-
-    // the remote will close the session
-    const result = await client.closed
-
-    // should receive the default close info
-    expect(result).to.have.property('reason', '')
-    expect(result).to.have.property('closeCode', 0)
-  })
-
-  it('receives data from server and checks receiving stream fin', async () => {
-    // client context - waits for the server to open a bidi stream then pipes it back to them
-    client = new WebTransport(
-      `${process.env.SERVER_URL}/bidirectional_server_fin_send`,
-      wtOptions
-    )
-    await client.ready
-
-    const bidiStream = await getReaderValue(client.incomingBidirectionalStreams)
-    const reader = bidiStream.readable.getReader()
-
-    while (true) {
-      const res = await reader.read()
-      if (res.done) {
-        break
-      }
-    }
-  })
-})