@fails-components/webtransport 0.3.1 → 1.0.1

package/lib/server.js

@@ -1,36 +1,136 @@
-import { Http3WebTransport } from './transport.js'
 import { ReadableStream } from 'node:stream/web'
-import { Http3WTSession } from './session.js'
+import { HttpWTSession } from './session.js'
+import { WebTransportError } from './error.js'
+import { Http2WebTransportServer } from './http2/node/index.js'
 import { isIPv4 } from 'net'
 import { defer, logger } from './utils.js'
 
-const log = logger(`webtransport:http3server(${process.pid})`)
+const log = logger(`webtransport:httpserver(${process?.pid})`)
 
 /**
- * @typedef {import('./types').WebTransportSession} WebTransportSession
- * @typedef {import('./types').NativeHttp3WTSession} NativeHttp3WTSession
- * @typedef {import('./types').Http3ServerEventHandler} Http3ServerEventHandler
- * @typedef {import('./types').Http3WTServerSessionVisitorEvent} Http3WTServerSessionVisitorEvent
- * @typedef {import('./types').ServerStatusEvent} ServerStatusEvent
+ * @type {(arg: { path: string; } | undefined) => void}
+ */
+let checkQuicheInit
+/**
+ * @type {new (arg: import("./types").HttpServerInit) => any}
+ */
+let Http3WebTransportServer
+/**
+ * @type {new (arg: import("./types").HttpServerInit) => any}
+ */
+let Http3WebTransportServerSocket
+const quicheLoaded = new Promise((resolve, reject) => {
+  // @ts-ignore
+  import('@fails-components/webtransport-transport-http3-quiche')
+    .then(
+      /**
+       * @type {import("./types").TransportHttp3Quiche}
+       */
+      (http3lib) => {
+        ;({
+          checkQuicheInit,
+          Http3WebTransportServer,
+          Http3WebTransportServerSocket
+        } = http3lib)
+        resolve(undefined)
+      }
+    )
+    .catch((error) => {
+      console.error('Problem loading http3-quiche transport')
+      console.error(
+        'Did you install @fails-components/webtransport-transport-http3-quiche?'
+      )
+      log('Problem loading http3-quiche transport', error)
+      log(
+        'Did you install @fails-components/webtransport-transport-http3-quiche?'
+      )
+      reject(error)
+    })
+}).catch((error) => {
+  console.log('http3 loader:', error)
+})
+
+/**
+ * @typedef {import('./types').WebTransportSessionImpl} WebTransportSession
+ * @typedef {import('./types').NativeHttpWTSession} NativeHttpWTSession
+ * @typedef {import('./types').HttpServerEventHandler} HttpServerEventHandler
+ * @typedef {import('./types').HttpWTServerSessionVisitorEvent} HttpWTServerSessionVisitorEvent
+ * @typedef {import('./types').HttpServerListeningEvent} HttpServerListeningEvent
  * @typedef {import('./types').ServerSessionRequestEvent} ServerSessionRequestEvent
- * @typedef {import('./types').Http3ServerInit} Http3ServerInit
+ * @typedef {import('./types').HttpServerInit} HttpServerInit
  */
 
+// @ts-ignore
+class TransportIntServerProxy {
+  /**
+   * @param {Array<any>} transportInts
+   * */
+  constructor(transportInts) {
+    this.transportsInts = new Set(transportInts)
+  }
+
+  startServer() {
+    this.transportsInts.forEach((transport) => {
+      if (transport.startServer) transport.startServer()
+    })
+  }
+
+  stopServer() {
+    this.transportsInts.forEach((transport) => {
+      if (transport.stopServer) transport.stopServer()
+    })
+  }
+
+  /**
+   * @param {string} cert
+   * @param {string} privKey
+   * @param {boolean} http2only
+   * */
+  updateCert(cert, privKey, http2only) {
+    this.transportsInts.forEach((transport) => {
+      if (transport.updateCert) transport.updateCert(cert, privKey, http2only)
+    })
+  }
+
+  /**
+   * @param {boolean} hasHandler
+   */
+  setJSRequestHandler(hasHandler) {
+    this.transportsInts.forEach((transport) =>
+      transport.setJSRequestHandler(hasHandler)
+    )
+  }
+
+  /**
+   * @param {string} path
+   */
+  addPath(path) {
+    this.transportsInts.forEach((transport) => transport.addPath(path))
+  }
+
+  set jsobj(newJSobj) {
+    this.transportsInts.forEach((transport) => (transport.jsobj = newJSobj))
+  }
+
+  get jsobj() {
+    return this.transportsInts.values().next().value
+  }
+}
+
 /**
- * @implements {Http3ServerEventHandler}
+ * @implements {HttpServerEventHandler}
  */
-export class Http3Server extends Http3WebTransport {
+export class HttpServer {
   /**
    *
-   * @param {Http3ServerInit} args
+   * @param {HttpServerInit} args
    */
   constructor(args) {
-    super(args, 'server')
-
+    this.args = args
     /** @type {Record<string, ReadableStream>} */
     this.sessionStreams = {}
 
-    /** @type {Record<string, ReadableStreamDefaultController<Http3WTSession>>} */
+    /** @type {Record<string, ReadableStreamDefaultController<HttpWTSession>>} */
     this.sessionController = {}
 
     this.port = null
@@ -45,11 +145,33 @@ export class Http3Server extends Http3WebTransport {
 
     this._closed = defer()
     this.closed = this._closed.promise
+    /**
+     * @type {string[]}
+     */
+    this._pendingPaths = []
+
+    /**
+     * @type {undefined|boolean}
+     */
+    this._pendingRequestCallback = undefined
   }
 
   startServer() {
     this.createTransportInt()
-    this.transportInt.startServer()
+      .then(() => {
+        if (this.transportInt.startServer) this.transportInt.startServer()
+        while (this._pendingPaths.length > 0) {
+          const path = this._pendingPaths.shift()
+          this.transportInt.addPath(path)
+        }
+        if (typeof this._pendingRequestCallback !== 'undefined') {
+          this.transportInt.setJSRequestHandler(this._pendingRequestCallback)
+          delete this._pendingRequestCallback
+        }
+      })
+      .catch((error) => {
+        log('Problem in startServer', error)
+      })
   }
 
   stopServer() {
@@ -61,12 +183,21 @@ export class Http3Server extends Http3WebTransport {
     this.stopped = true
   }
 
+  /**
+   * @param {string} cert
+   * @param {string} privKey
+   * @param {boolean} http2only
+   * */
+  updateCert(cert, privKey, http2only) {
+    if (this.transportInt.updateCert)
+      this.transportInt.updateCert(cert, privKey, http2only)
+  }
+
   /**
    * @returns {{ port: number, host: string, family: 'IPv4' | 'IPv6' } | null}
    */
   address() {
     if (this.port == null || this.host == null) {
-      console.info('returning null')
       return null
     }
 
@@ -84,6 +215,8 @@ export class Http3Server extends Http3WebTransport {
     this.requestHandler = callback
 
     this.transportInt.setJSRequestHandler(!!callback)
+    if (this.transportInt) this.transportInt.setJSRequestHandler(!!callback)
+    else this._pendingRequestCallback = !!callback
   }
 
   /**
@@ -102,7 +235,8 @@ export class Http3Server extends Http3WebTransport {
       }
     })
     if (!args || !args.noAutoPaths) {
-      this.transportInt.addPath(path)
+      if (this.transportInt) this.transportInt.addPath(path)
+      else this._pendingPaths.push(path)
     }
     return this.sessionStreams[path]
   }
@@ -116,10 +250,11 @@ export class Http3Server extends Http3WebTransport {
       this.requestHandler({ header: args.header })
         .then((/** @type {any} */ result) => {
           log('oSR', result)
-          this.transportInt.finishSessionRequest({
+          args.object.finishSessionRequest({
             promise: args.promise,
             header: args.header,
             session: args.session,
+            head: args.head,
             ...result
           })
         })
@@ -130,30 +265,33 @@ export class Http3Server extends Http3WebTransport {
   }
 
   /**
-   * @param {Http3WTServerSessionVisitorEvent} args
+   * @param {HttpWTServerSessionVisitorEvent} args
    */
-  onHttp3WTSessionVisitor(args) {
+  onHttpWTSessionVisitor(args) {
     // create Http3 Visitor
-    if (args.object) {
-      const sesobj = new Http3WTSession({
-        object: args.session,
-        header: args.header,
-        parentobj: this
-      })
-      if (this.sessionController[args.path])
-        this.sessionController[args.path].enqueue(sesobj)
-    } else throw new Error('Http3WTSessionVisitor')
+    const sesobj = new HttpWTSession({
+      object: args.session,
+      header: args.header,
+      parentobj: this
+    })
+    args.session.jsobj = sesobj
+    if (this.sessionController[args.path])
+      this.sessionController[args.path].enqueue(sesobj)
   }
 
   /**
+   * @param {Error} [error]
    */
-  onServerError() {
-    this._ready.reject()
+  onServerError(error) {
+    this._ready.reject(error)
   }
 
   /**
+   * @param {HttpServerListeningEvent} evt
    */
-  onServerListening() {
+  onServerListening(evt) {
+    if (evt.host) this.host = evt.host
+    if (evt.port) this.port = evt.port
     this._ready.resolve()
   }
 
@@ -164,49 +302,94 @@ export class Http3Server extends Http3WebTransport {
   }
 
   /**
-   * @param {ServerStatusEvent} evt
-   */
-  onServerStatus(evt) {
-    if (evt.host) this.host = evt.host
-    if (evt.port) this.port = evt.port
+   * @param{{path: string} |undefined} [args]
+   **/
+  async createTransportInt(args) {
+    if (this.transportInt != null) {
+      return
+    }
 
-    switch (evt.status) {
-      case 'close':
-        this.onServerClose()
-        break
-      case 'listening':
-        this.onServerListening()
-        break
-      case 'error':
-        this.onServerListening()
-        break
-      default: {
-        throw new Error('unknown status')
-      }
+    if (
+      // @ts-ignore
+      this.args &&
+      // @ts-ignore
+      (this.args?.reliability === 'unreliableOnly' ||
+        // @ts-ignore
+        typeof this.args?.reliability === 'undefined' ||
+        // @ts-ignore
+        this.args?.reliability === 'both')
+    ) {
+      await quicheLoaded
+      checkQuicheInit(args)
     }
-  }
 
-  /**
-   * @param {Http3WTServerSessionVisitorEvent | ServerStatusEvent | ServerSessionRequestEvent} args
-   */
-  customCallback(args) {
-    log('callback', args?.purpose)
-    log.trace(args)
-    if (args.purpose) {
-      switch (args.purpose) {
-        case 'SessionRequest':
-          this.onSessionRequest(args)
+    try {
+      let socket
+      // @ts-ignore
+      const reliability = this.args?.reliability || 'unreliableOnly'
+      switch (reliability) {
+        case 'unreliableOnly':
+          socket = new Http3WebTransportServerSocket(this.args)
+          this.transportInt = new Http3WebTransportServer(this.args)
+          this.transportInt.stopServer = socket.stopServer.bind(socket)
+          socket.init()
+          socket.cobj = this.transportInt
+          // @ts-ignore
+          socket.jsobj = this
+          // @ts-ignore
+          this.transportInt.socket = socket
           break
-        case 'Http3WTSessionVisitor':
-          this.onHttp3WTSessionVisitor(args)
+        case 'reliableOnly':
+          // @ts-ignore
+          this.transportInt = new Http2WebTransportServer(this.args)
           break
-        case 'ServerStatus':
-          this.onServerStatus(args)
+        case 'both':
+          {
+            socket = new Http3WebTransportServerSocket(this.args)
+            const server3 = new Http3WebTransportServer(this.args)
+            server3.stopServer = socket.stopServer.bind(socket)
+            socket.init()
+            server3.socket = socket
+            socket.cobj = server3
+            // @ts-ignore
+            socket.jsobj = this
+            // @ts-ignore
+            const server2 = new Http2WebTransportServer(this.args)
+            server2.jsobj = this
+            this.transportInt = new TransportIntServerProxy([server2, server3])
+          }
           break
-        default: {
-          throw new Error('unknown purpose')
-        }
       }
+    } catch (/** @type {any} */ err) {
+      const error = new WebTransportError('Opening handshake failed.')
+      error.stack = err.stack
+
+      throw error
+    }
+
+    this.transportInt.jsobj = this
+    if (this.transportInt.createTransport) {
+      this.transportInt.createTransport()
     }
   }
 }
+
+export class Http3Server extends HttpServer {
+  /**
+   *
+   * @param {HttpServerInit} args
+   */
+  constructor(args) {
+    super({ ...args, reliability: 'unreliableOnly' })
+  }
+}
+
+export class Http2Server extends HttpServer {
+  /**
+   *
+   * @param {HttpServerInit} args
+   */
+  constructor(args) {
+    super({ ...args, reliability: 'reliableOnly' })
+  }
+}

package/lib/session.js

@@ -1,9 +1,10 @@
-import { ReadableStream, WritableStream } from 'node:stream/web'
-import { Http3WTStream } from './stream.js'
+import { ReadableStream, WritableStream } from './webstreams.js'
+import { HttpWTStream } from './stream.js'
 import { WebTransportError } from './error.js'
 import { logger } from './utils.js'
 
-const log = logger(`webtransport:http3wtsession(${process.pid})`)
+const pid = typeof process !== 'undefined' ? process.pid : 0
+const log = logger(`webtransport:httpwtsession(${pid})`)
 
 /**
  * WebTransport session events
@@ -27,13 +28,13 @@ const log = logger(`webtransport:http3wtsession(${process.pid})`)
  * @typedef {import('./dom').WebTransportStats} WebTransportStats
  * @typedef {import('./dom').WebTransportDatagramStats} WebTransportDatagramStats
  *
- * @typedef {import('./types').NativeHttp3WTSession} NativeHttp3WTSession
+ * @typedef {import('./types').NativeHttpWTSession} NativeHttpWTSession
  *
  * Public API
- * @typedef {import('./types').WebTransportSession} WebTransportSession
+ * @typedef {import('./types').WebTransportSessionImpl} WebTransportSession
  *
- * @typedef {import('./server').Http3Server} Http3Server
- * @typedef {import('./client').Http3Client} Http3Client
+ * @typedef {import('./server').HttpServer} HttpServer
+ * @typedef {import('./client').HttpClient} HttpClient
  *
  * @typedef {import('stream/web').WritableStreamDefaultController} WritableStreamDefaultController
  */
@@ -42,17 +43,20 @@ const log = logger(`webtransport:http3wtsession(${process.pid})`)
  * @implements {WebTransportSessionEventHandler}
  * @implements {WebTransportSession}
  */
-export class Http3WTSession {
+export class HttpWTSession {
   /**
    * @param {object} args
-   * @param {import('./types').NativeHttp3WTSession} [args.object]
-   * @param {Http3Server | Http3Client} args.parentobj
+   * @param {import('./types').NativeHttpWTSession} [args.object]
+   * @param {HttpServer | HttpClient} args.parentobj
    * @param {any | undefined} [args.header= undefined]
    */
   constructor(args) {
     if (args.object) {
       this.objint = args.object
       this.objint.jsobj = this
+      if (this.objint.sendInitialParameters) {
+        this.objint.sendInitialParameters()
+      }
     }
     this.parentobj = args.parentobj
     /** @type {import('./types').WebTransportSessionState} */
@@ -87,6 +91,7 @@ export class Http3WTSession {
     })
 
     /** @type {ReadableStream<WebTransportBidirectionalStream>} */
+    // @ts-ignore
     this.incomingBidirectionalStreams = new ReadableStream({
       /** @param {ReadableStreamDefaultController<WebTransportBidirectionalStream>} controller */
       start: (controller) => {
@@ -94,6 +99,7 @@ export class Http3WTSession {
       }
     })
     /** @type {ReadableStream<WebTransportReceiveStream>} */
+    // @ts-ignore
     this.incomingUnidirectionalStreams = new ReadableStream({
       /** @param {ReadableStreamDefaultController<WebTransportReceiveStream>} controller */
       start: (controller) => {
@@ -111,6 +117,7 @@ export class Http3WTSession {
     /** @type {WebTransportDatagramDuplexStream} */
     this.datagrams = {
       /** @type {ReadableStream<Uint8Array>} */
+      // @ts-ignore
       readable: new ReadableStream({
         start: (
           /** @type {import("stream/web").ReadableByteStreamController} */ controller
@@ -169,7 +176,7 @@ export class Http3WTSession {
     this.sendStreams = new Set()
     /** @type {Set<WebTransportReceiveStream>} */
     this.receiveStreams = new Set()
-    /** @type {Set<Http3WTStream>} */
+    /** @type {Set<HttpWTStream>} */
     this.streamObjs = new Set()
 
     /** @type {Set<WritableStreamDefaultController>} */
@@ -179,12 +186,14 @@ export class Http3WTSession {
   }
 
   /**
-   * @param {NativeHttp3WTSession} object
+   * @param {NativeHttpWTSession} object
+   * @param {boolean} reliable
    */
-  setSessionObj(object) {
+  setSessionObj(object, reliable) {
     if (object) {
       this.objint = object
       this.objint.jsobj = this
+      this.reliable = !!reliable
     }
   }
 
@@ -275,14 +284,14 @@ export class Http3WTSession {
   }
 
   /**
-   * @param {Http3WTStream} stream
+   * @param {HttpWTStream} stream
    */
   addStreamObj(stream) {
     this.streamObjs.add(stream)
   }
 
   /**
-   * @param {Http3WTStream} stream
+   * @param {HttpWTStream} stream
    */
   removeStreamObj(stream) {
     this.streamObjs.delete(stream)
@@ -375,7 +384,8 @@ export class Http3WTSession {
 
   onReady(/* error */) {
     this.state = 'connected'
-    this.reliability = 'supports-unreliable'
+    if (!this.reliable) this.reliability = 'supports-unreliable'
+    else this.reliability = 'reliable-only'
     if (this.readyResolve) this.readyResolve()
     delete this.readyResolve
   }
@@ -407,6 +417,8 @@ export class Http3WTSession {
     }
 
     log('onClose')
+    this.streamObjs.forEach((ele) => ele.finalDrain())
+
     const error = new WebTransportError('Session closed')
 
     for (const rej of this.rejectBiDi) rej(error)
@@ -435,7 +447,7 @@ export class Http3WTSession {
     this.state = 'closed'
 
     const wtError = new WebTransportError(
-      `Session closed (on process ${process.pid}) with code ` +
+      `Session closed (on process ${pid}) with code ` +
         args.errorcode +
         ' and reason' +
         args.error
@@ -467,7 +479,7 @@ export class Http3WTSession {
    * @param {NewStreamEvent} args
    */
   onStream(args) {
-    const strobj = new Http3WTStream({
+    const strobj = new HttpWTStream({
       object: args.stream,
       parentobj: this,
       transport: this.parentobj,
@@ -537,7 +549,7 @@ export class Http3WTSession {
       destview.set(args.datagram)
       byob.respond(args.datagram.byteLength)
     }
-    this.incomDatagramController.enqueue(args.datagram)
+    this.incomDatagramController.enqueue(new Uint8Array(args.datagram))
   }
 
   /**
@@ -561,53 +573,4 @@ export class Http3WTSession {
     if (this.drainingResolve) this.drainingResolve(undefined)
     this.state = 'draining'
   }
-
-  /**
-   * @param {SessionReadyEvent | SessionCloseEvent | DatagramReceivedEvent | DatagramSendEvent | GoawayReceivedEvent | SessionStatsEvent | DatagramStatsEvent | NewStreamEvent} args
-   */
-  static callback(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
-    if (args.purpose) {
-      switch (args.purpose) {
-        case 'SessionReady':
-          visitor.onReady(args)
-          break
-        case 'SessionClose':
-          visitor.onClose(args)
-          break
-        case 'DatagramReceived':
-          if (visitor && Object.prototype.hasOwnProperty.call(args, 'datagram'))
-            visitor.onDatagramReceived(args)
-          break
-        case 'DatagramSend':
-          if (visitor) visitor.onDatagramSend(args)
-          break
-        case 'GoawayReceived':
-          visitor.onGoAwayReceived(args)
-          break
-        case 'SessionStats':
-          visitor.onSessionStats(args)
-          break
-        case 'DatagramStats':
-          visitor.onDatagramStats(args)
-          break
-        case 'Http3WTStreamVisitor':
-          if (
-            visitor &&
-            Object.prototype.hasOwnProperty.call(args, 'bidirectional') &&
-            Object.prototype.hasOwnProperty.call(args, 'incoming')
-          ) {
-            visitor.onStream(args)
-          } else throw new Error('Malformed Http3WTStreamVisitor')
-          break
-        default:
-          throw new Error('unknown purpose Sessioncb')
-      }
-    } else throw new Error('no purpose Sessioncb')
-  }
 }