@fails-components/webtransport 0.2.1 → 0.3.0

package/lib/session.js

@@ -1,5 +1,9 @@
 import { ReadableStream, WritableStream } from 'node:stream/web'
 import { Http3WTStream } from './stream.js'
+import { WebTransportError } from './error.js'
+import { logger } from './utils.js'
+
+const log = logger(`webtransport:http3wtsession(${process.pid})`)
 
 /**
  * WebTransport session events
@@ -9,6 +13,8 @@ import { Http3WTStream } from './stream.js'
  * @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
  * @typedef {import('./types').NewStreamEvent} NewStreamEvent
  *
  * @typedef {import('./dom').WebTransportCloseInfo} WebTransportCloseInfo
@@ -19,6 +25,7 @@ import { Http3WTStream } from './stream.js'
  * @typedef {import('./dom').WebTransportReliabilityMode} WebTransportReliabilityMode
  * @typedef {import('./dom').WebTransportCongestionControl} WebTransportCongestionControl
  * @typedef {import('./dom').WebTransportStats} WebTransportStats
+ * @typedef {import('./dom').WebTransportDatagramStats} WebTransportDatagramStats
  *
  * @typedef {import('./types').NativeHttp3WTSession} NativeHttp3WTSession
  *
@@ -49,7 +56,7 @@ export class Http3WTSession {
     }
     this.parentobj = args.parentobj
     /** @type {import('./types').WebTransportSessionState} */
-    this.state = 'connected'
+    this.state = 'connecting'
 
     /** @type {((value?: any) => void) | null | undefined} */
     this.readyResolve = null
@@ -96,7 +103,7 @@ export class Http3WTSession {
 
     /** @type {Array<() => void>} */
     this.writeDatagramRes = []
-    /** @type {Array<() => void>} */
+    /** @type {Array<(err?: Error) => void>} */
     this.writeDatagramRej = []
     /** @type {Array<Promise<void>>} */
     this.writeDatagramProm = []
@@ -125,7 +132,7 @@ export class Http3WTSession {
               this.writeDatagramRej.push(reject)
             })
             this.writeDatagramProm.push(ret)
-            // console.log('b4 datagram write', chunk, Date.now())
+            log.trace('b4 datagram write', chunk)
             if (this.objint == null) {
               throw new Error('this.objint is not set')
             }
@@ -148,6 +155,16 @@ export class Http3WTSession {
     /** @type {Array<(err?: Error) => void>} */
     this.rejectUniDi = []
 
+    /** @type {Array<(stats: WebTransportStats) => void>} */
+    this.resolveSessionStats = []
+    /** @type {Array<(err?: Error) => void>} */
+    this.rejectSessionStats = []
+
+    /** @type {Array<(stats: WebTransportDatagramStats) => void>} */
+    this.resolveDatagramStats = []
+    /** @type {Array<(err?: Error) => void>} */
+    this.rejectDatagramStats = []
+
     /** @type {Set<WebTransportSendStream>} */
     this.sendStreams = new Set()
     /** @type {Set<WebTransportReceiveStream>} */
@@ -172,25 +189,72 @@ export class Http3WTSession {
   }
 
   getStats() {
-    return Promise.resolve({
-      timestamp: Date.now(),
-      bytesSent: BigInt(0),
-      packetsSent: BigInt(0),
-      packetsLost: BigInt(0),
-      numOutgoingStreamsCreated: 0,
-      numIncomingStreamsCreated: 0,
-      bytesReceived: BigInt(0),
-      packetsReceived: BigInt(0),
-      smoothedRtt: 0,
-      rttVariation: 0,
-      minRtt: 0,
-      datagrams: {
-        timestamp: Date.now(),
-        expiredOutgoing: BigInt(0),
-        droppedIncoming: BigInt(0),
-        lostOutgoing: BigInt(0)
-      }
+    if (this.objint == null) {
+      throw new Error('this.objint not set')
+    }
+    const prom = new Promise((resolve, reject) => {
+      this.resolveSessionStats.push(resolve)
+      this.rejectSessionStats.push(reject)
     })
+    this.objint.orderSessionStats()
+    return prom
+  }
+
+  /**
+   * @param {SessionStatsEvent} evt
+   */
+  onSessionStats({
+    timestamp,
+    expiredOutgoing = BigInt(0),
+    lostOutgoing = BigInt(0),
+    // non Datagram
+    minRtt = 0,
+    smoothedRtt = 0,
+    rttVariation = 0,
+    estimatedSendRateBps
+  }) {
+    const res = this.resolveSessionStats.pop()
+    this.rejectSessionStats.pop()
+    if (res)
+      res({
+        timestamp,
+        bytesSent: BigInt(0),
+        packetsSent: BigInt(0),
+        packetsLost: BigInt(0),
+        numOutgoingStreamsCreated: 0,
+        numIncomingStreamsCreated: 0,
+        bytesReceived: BigInt(0),
+        packetsReceived: BigInt(0),
+        smoothedRtt,
+        rttVariation,
+        minRtt,
+        estimatedSendRate: estimatedSendRateBps,
+        datagrams: {
+          timestamp,
+          expiredOutgoing,
+          droppedIncoming: BigInt(0),
+          lostOutgoing
+        }
+      })
+  }
+
+  /**
+   * @param {DatagramStatsEvent} evt
+   */
+  onDatagramStats({
+    timestamp,
+    expiredOutgoing = BigInt(0),
+    lostOutgoing = BigInt(0)
+  }) {
+    const res = this.resolveDatagramStats.pop()
+    this.rejectDatagramStats.pop()
+    if (res)
+      res({
+        timestamp,
+        expiredOutgoing,
+        droppedIncoming: BigInt(0),
+        lostOutgoing
+      })
   }
 
   async waitForDatagramsSend() {
@@ -198,7 +262,7 @@ export class Http3WTSession {
       try {
         await Promise.allSettled(this.writeDatagramProm)
       } catch (error) {
-        console.log('datagram promise failed ', error)
+        log.error('datagram promise failed ', error)
       }
     }
   }
@@ -299,7 +363,7 @@ export class Http3WTSession {
    * @returns {void}
    */
   close(closeInfo) {
-    // console.log('closeinfo', closeInfo)
+    log('closeinfo', closeInfo)
     if (this.state === 'closed' || this.state === 'failed') return
     if (this.objint) {
       this.objint.close({
@@ -310,6 +374,7 @@ export class Http3WTSession {
   }
 
   onReady(/* error */) {
+    this.state = 'connected'
     this.reliability = 'supports-unreliable'
     if (this.readyResolve) this.readyResolve()
     delete this.readyResolve
@@ -320,10 +385,36 @@ export class Http3WTSession {
    */
   onClose(args) {
     delete this.objint // not valid any more
-    // console.log('onClose')
-    for (const rej of this.rejectBiDi) rej()
-    for (const rej of this.rejectUniDi) rej()
-    for (const rej of this.writeDatagramRej) rej()
+
+    if (this.state !== 'connected') {
+      log.error(
+        'session was closed before state was "connected" - it was "%s"',
+        this.state
+      )
+      this.state = 'failed'
+
+      // make sure the event loop can still exit
+      if (this.closeHook) {
+        this.closeHook()
+        delete this.closeHook
+      }
+
+      // closed before connected
+      const error = new WebTransportError('Opening handshake failed.')
+      this.readyReject(error)
+      this.closedReject(error)
+      return
+    }
+
+    log('onClose')
+    const error = new WebTransportError('Session closed')
+
+    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 = []
@@ -332,14 +423,27 @@ export class Http3WTSession {
     this.rejectBiDi = []
     this.rejectUniDi = []
 
+    this.resolveSessionStats = []
+    this.rejectSessionStats = []
+    this.resolveDatagramStats = []
+    this.rejectDatagramStats = []
+
     this.incomBiDiController.close()
     this.incomUniDiController.close()
     this.incomDatagramController.close()
     // this.outgoDatagramController.error(errorcode)
     this.state = 'closed'
 
-    this.sendStreamsController.forEach((ele) => ele.error(args.errorcode))
-    this.receiveStreamsController.forEach((ele) => ele.error(args.errorcode))
+    const wtError = new WebTransportError(
+      `Session closed (on process ${process.pid}) with code ` +
+        args.errorcode +
+        ' and reason' +
+        args.error
+    )
+
+    this.sendStreamsController.forEach((ele) => ele.error(wtError))
+    this.receiveStreamsController.forEach((ele) => ele.error(wtError))
+
     this.streamObjs.forEach((ele) => (ele.readableclosed = true))
 
     this.sendStreams.clear()
@@ -351,7 +455,7 @@ export class Http3WTSession {
     if (this.closedResolve)
       this.closedResolve({
         closeCode: args.errorcode,
-        reason: args.error ? args.error : 'closed'
+        reason: args.error ? args.error : ''
       })
     if (this.closeHook) {
       this.closeHook()
@@ -411,6 +515,7 @@ export class Http3WTSession {
    * @param {DatagramReceivedEvent} args
    */
   onDatagramReceived(args) {
+    log.trace('datagram received', args.datagram)
     // console.log('datagram received', args.datagram, Date.now())
     if (this.incomDatagramController.byobRequest) {
       /** @type {ReadableStreamBYOBRequest} */
@@ -458,10 +563,12 @@ export class Http3WTSession {
   }
 
   /**
-   * @param {SessionReadyEvent | SessionCloseEvent | DatagramReceivedEvent | DatagramSendEvent | GoawayReceivedEvent | NewStreamEvent} args
+   * @param {SessionReadyEvent | SessionCloseEvent | DatagramReceivedEvent | DatagramSendEvent | GoawayReceivedEvent | SessionStatsEvent | DatagramStatsEvent | NewStreamEvent} args
    */
   static callback(args) {
-    // console.log('Session callback called', args)
+    log('callback', args?.purpose)
+    log.trace(args)
+
     if (!args || !args.object || !args.object.jsobj)
       throw new Error('Session callback without jsobj')
     const visitor = args.object.jsobj
@@ -483,6 +590,12 @@ export class Http3WTSession {
         case 'GoawayReceived':
           visitor.onGoAwayReceived(args)
           break
+        case 'SessionStats':
+          visitor.onSessionStats(args)
+          break
+        case 'DatagramStats':
+          visitor.onDatagramStats(args)
+          break
         case 'Http3WTStreamVisitor':
           if (
             visitor &&

package/lib/stream.js

@@ -1,4 +1,8 @@
 import { ReadableStream, WritableStream } from 'node:stream/web'
+import { logger } from './utils.js'
+import { WebTransportError } from './error.js'
+
+const log = logger(`webtransport:http3wtstream(${process.pid})`)
 
 /**
  * WebTransport stream events
@@ -11,6 +15,9 @@ import { ReadableStream, WritableStream } from 'node:stream/web'
  *
  * @typedef {import('./types').NativeHttp3WTStream} NativeHttp3WTStream
  *
+ * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
+ * @typedef {import('./dom').WebTransportSendStream} WebTransportSendStream
+ *
  * @typedef {import('./session').Http3WTSession} Http3WTSession
  *
  * @typedef {import('stream/web').WritableStreamDefaultController} WritableStreamDefaultController
@@ -38,6 +45,11 @@ export class Http3WTStream {
     this.pendingoperation = null
     this.pendingres = null
 
+    /** @type {WebTransportReceiveStream} */
+    this.readable // eslint-disable-line no-unused-expressions
+    /** @type {WebTransportSendStream} */
+    this.writable // eslint-disable-line no-unused-expressions
+
     /** @type {Promise<void> | null} */
     this.pendingoperationRead = null
     this.pendingresRead = null
@@ -49,15 +61,14 @@ export class Http3WTStream {
       this.incomingbufferreadpos = 0
       if (!this.objint.readbuffer)
         throw new Error('No readbuffer for read stream')
-      // @ts-expect-error `getStats` property is missing from ReadableStream
       /** @type {WebTransportReceiveStream} */
+      // @ts-expect-error `getStats` property is missing from ReadableStream
       this.readable = new ReadableStream(
         {
           start: (
             /** @type {import("stream/web").ReadableByteStreamController} */ controller
           ) => {
             this.readableController = controller
-            this.parentobj.addReceiveStream(this.readable, controller)
             this.objint.startReading()
           },
           pull: async (
@@ -74,8 +85,7 @@ export class Http3WTStream {
               })
               await this.pendingoperationRead
             }
-            if (this.incomingbufferfilled === 0)
-              throw new Error('error reading')
+            if (this.incomingbufferfilled === 0) return Promise.resolve()
 
             this.drainBuffer()
           },
@@ -103,18 +113,19 @@ export class Http3WTStream {
         return Promise.resolve({
           timestamp: 0,
           bytesReceived: 0n,
-          bytesResd: 0n
+          bytesRead: 0n
         })
       }
+      // @ts-ignore
+      this.parentobj.addReceiveStream(this.readable, this.readableController)
     }
     if (this.bidirectional || !this.incoming) {
-      // @ts-expect-error `getStats` property is missing from WritableStream
       /** @type {WebTransportSendStream} */
+      // @ts-expect-error `getStats` property is missing from WritableStream
       this.writable = new WritableStream(
         {
           start: (controller) => {
             this.writableController = controller
-            this.parentobj.addSendStream(this.writable, controller)
           },
           write: (chunk, controller) => {
             if (this.writableclosed) {
@@ -124,13 +135,17 @@ export class Http3WTStream {
               this.pendingoperation = new Promise((resolve, reject) => {
                 this.pendingres = resolve
               })
-              const dataprom = this.parentobj.waitForDatagramsSend()
-              dataprom.finally(() => {
-                this.objint.writeChunk(chunk)
-              })
+              this.parentobj
+                .waitForDatagramsSend()
+                .finally(() => {
+                  this.objint.writeChunk(chunk)
+                })
+                .catch((/** @type {any} */ err) => {
+                  log.error(err)
+                })
               return this.pendingoperation
             } else {
-              console.log('chunk info:', chunk)
+              log.trace('chunk info:', chunk)
               throw new Error('chunk is not of instanceof Uint8Array ')
             }
           },
@@ -174,6 +189,8 @@ export class Http3WTStream {
           bytesAcknowledged: 0n
         })
       }
+      // @ts-ignore
+      this.parentobj.addSendStream(this.writable, this.writableController)
     }
 
     /** @type {(() => void) | null} */
@@ -245,12 +262,13 @@ export class Http3WTStream {
    * @returns {void}
    */
   onStreamRecvSignal(args) {
-    // console.log('onStreamRecvSignal', args)
+    log('callback', args?.purpose, args?.nettask)
+    log.trace('onStreamRecvSignal', args)
     // check if transport is closed
     let parentcleanup = true
     const parentstate = this.parentobj.state
     if (parentstate === 'closed' || parentstate === 'failed') {
-      console.log('no parent cleanup as parent was closed or failed')
+      log('no parent cleanup as parent was closed or failed')
       parentcleanup = false
     }
     switch (args.nettask) {
@@ -262,8 +280,12 @@ export class Http3WTStream {
               this.readableController
             )
           this.readableclosed = true
-          this.readableController.error(args.code || 0)
-        } else console.log('stopSending without readable')
+          this.readableController.error(
+            new WebTransportError('Resetstream with code:' + (args.code || 0))
+          )
+        } else {
+          log.error('resetStream without readable')
+        }
         break
 
       case 'stopSending':
@@ -275,11 +297,15 @@ export class Http3WTStream {
             )
 
           this.writableclosed = true
-          this.writableController.error(args.code || 0)
-        } else console.log('stopSending wihtout writable')
+          this.writableController.error(
+            new WebTransportError('StopSending with code:' + (args.code || 0))
+          )
+        } else {
+          log.error('stopSending without writable')
+        }
         break
       default:
-        console.log('unhandled onStreamRecvSignal')
+        log.error('unhandled onStreamRecvSignal')
     }
 
     if (this.pendingoperation) {
@@ -306,6 +332,7 @@ export class Http3WTStream {
    */
   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) {
@@ -323,7 +350,7 @@ export class Http3WTStream {
     }
     if (args.fin) {
       if (this.incomingbufferfilled > 0) {
-        console.log('Warning buffer filled and we got a fin')
+        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?')
 
@@ -378,7 +405,8 @@ export class Http3WTStream {
    * @param {StreamNetworkFinishEvent} args
    */
   onStreamNetworkFinish(args) {
-    // console.log('networkfinish args', args)
+    log('callback', args?.purpose)
+    log.trace('networkfinish args', args)
     switch (args.nettask) {
       case 'stopSending':
         if (this.cancelres) {
@@ -408,7 +436,7 @@ export class Http3WTStream {
         }
         break
       default:
-        console.log('onStreamNetworkFinish unknown task')
+        log.error('onStreamNetworkFinish unknown task', args.nettask)
     }
     // we could differentiate....
   }
@@ -417,7 +445,8 @@ export class Http3WTStream {
    * @param {StreamRecvSignalEvent | StreamReadEvent | StreamWriteEvent | StreamResetEvent | StreamNetworkFinishEvent} args
    */
   static callback(args) {
-    // console.log('Stream callback called', 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
@@ -433,7 +462,6 @@ export class Http3WTStream {
           ) {
             visitor.onStreamRead(args)
           } else {
-            console.log('Stream callback called', visitor, args)
             throw new Error('Malformed StreamRead')
           }
           break

package/lib/transport.js

@@ -1,24 +1,61 @@
 import { Http3EventLoop } from './event-loop.js'
 import { wtrouter } from './native.js'
+import { WebTransportError } from './error.js'
+import { logger } from './utils.js'
+
+const log = logger(`webtransport:http3webtransport(${process.pid})`)
+
+/**
+ * @typedef {import('./types').Http3WebTransportInit} Http3WebTransportInit
+ */
 
 export class Http3WebTransport {
   /**
-   * @param {*} args
+   * @param {Http3WebTransportInit} args
    * @param {'server' | 'client'} purpose
    */
   constructor(args, purpose) {
+    /** @type {Http3WebTransportInit | undefined} */
+    this.args = args
+    /** @type {'server' | 'client' | undefined} */
+    this.purpose = purpose
+    this.sessions = {}
+  }
+
+  createTransportInt() {
+    if (this.transportInt != null) {
+      return
+    }
     const eventloop = Http3EventLoop.getGlobalEventLoop(this, {
-      quicheLogVerbose: args.quicheLogVerbose
+      quicheLogVerbose: this.args?.quicheLogVerbose
+        ? this.args.quicheLogVerbose
+        : -1
     }).eventloopInt
 
-    if (purpose === 'server')
-      this.transportInt = new wtrouter.Http3WebTransportServer(args, eventloop)
-    else if (purpose === 'client')
-      this.transportInt = new wtrouter.Http3WebTransportClient(args, eventloop)
-    else throw new Error('unknown purpose')
-    this.transportInt.jsobj = this
+    try {
+      if (this.purpose === 'server') {
+        this.transportInt = new wtrouter.Http3WebTransportServer(
+          this.args,
+          eventloop
+        )
+      } else if (this.purpose === 'client') {
+        this.transportInt = new wtrouter.Http3WebTransportClient(
+          this.args,
+          eventloop
+        )
+      } else {
+        throw new Error('unknown purpose')
+      }
+    } catch (/** @type {any} */ err) {
+      const error = new WebTransportError('Opening handshake failed.')
+      error.stack = err.stack
 
-    this.sessions = {}
+      throw error
+    }
+
+    delete this.purpose
+    delete this.args
+    this.transportInt.jsobj = this
   }
 
   /**
@@ -29,7 +66,8 @@ export class Http3WebTransport {
    * @param {TransportCallbackEvent} args
    */
   static transportCallback(args) {
-    // console.log('incoming callback transport', args)
+    log('callback', args?.purpose)
+    log.trace(args)
     if (!args || !args.object || !args.object.jsobj)
       throw new Error('Transport callback without jsobj')
     const visitor = args.object.jsobj

package/lib/types.ts

@@ -1,4 +1,4 @@
-import type { WebTransport } from './dom'
+import type { WebTransport, WebTransportOptions } from './dom'
 
 /**
  * Native Http3WTSession counterpart
@@ -8,7 +8,8 @@ import type { WebTransport } from './dom'
   writeDatagram: (chunk: Uint8Array) => void
   orderUnidiStream: () => void
   orderBidiStream: () => void
-  // orderStats: () => void
+  orderSessionStats: () => void
+  orderDatagramStats: () => void
   notifySessionDraining(): () => void
   close: (arg: { code: number, reason: string }) => void
 }
@@ -82,6 +83,28 @@ export interface SessionCloseEvent {
   error: string
 }
 
+export interface SessionStatsEvent {
+  object: NativeHttp3WTSession
+  purpose: 'SessionStats'
+  timestamp: number
+  expiredOutgoing: bigint
+  lostOutgoing: bigint
+
+  // non Datagram
+  minRtt: number
+  smoothedRtt: number
+  rttVariation: number
+  estimatedSendRateBps: bigint
+}
+
+export interface DatagramStatsEvent {
+  object: NativeHttp3WTSession
+  purpose: 'DatagramStats'
+  timestamp: number
+  expiredOutgoing: bigint
+  lostOutgoing: bigint
+}
+
 export interface DatagramReceivedEvent {
   object: NativeHttp3WTSession
   purpose: 'DatagramReceived'
@@ -113,6 +136,8 @@ export interface WebTransportSessionEventHandler {
   onDatagramReceived: (evt: DatagramReceivedEvent) => void
   onDatagramSend: (evt: DatagramSendEvent) => void
   onGoAwayReceived: (evt: GoawayReceivedEvent) => void
+  onSessionStats: (evt: SessionStatsEvent) => void
+  onDatagramStats: (evt: DatagramStatsEvent) => void
   onStream: (evt: NewStreamEvent) => void
   closeHook?: (() => void) | null
 }
@@ -185,16 +210,39 @@ export interface Deferred<T = unknown> {
   reject: (reason?: any) => void
 }
 
-export type WebTransportSessionState = 'connected' | 'draining' | 'closed' | 'failed'
+// https://www.w3.org/TR/webtransport/#dom-webtransport-state-slot
+export type WebTransportSessionState =  'connecting' | 'connected' | 'draining' | 'closed' | 'failed'
 
 export interface WebTransportSession extends WebTransport {
   state: WebTransportSessionState
 }
 
-export interface Http3ServerInit {
-  port: number
+export interface Http3WebTransportInit extends WebTransportOptions {
+  host: string
+  port: string | number
+  quicheLogVerbose?: number
+}
+
+// see Http3ServerJS C++ type
+export interface Http3ServerInit extends Http3WebTransportInit {
+  port: string | number
   host: string
   secret: string
   cert: string
   privKey: string
+  maxConnections?: number
+  initialStreamFlowControlWindow?: number
+  initialSessionFlowControlWindow?: number
+}
+
+// see Http3ClientJS C++ type
+export interface Http3ClientInit extends Http3WebTransportInit {
+  forceIpv6?: boolean
+  localPort?: number
+}
+
+export interface Logger {
+  (formatter: any, ...args: any[]): void
+  error: (formatter: any, ...args: any[]) => void
+  trace: (formatter: any, ...args: any[]) => void
 }