@fails-components/webtransport 0.0.9 → 0.1.0-macarmbuild.6

package/lib/stream.js

@@ -0,0 +1,325 @@
+import { ReadableStream, WritableStream } from 'node:stream/web'
+
+/**
+ * WebTransport stream events
+ * @typedef {import('./types').WebTransportStreamEventHandler} WebTransportStreamEventHandler
+ * @typedef {import('./types').StreamRecvSignalEvent} StreamRecvSignalEvent
+ * @typedef {import('./types').StreamReadEvent} StreamReadEvent
+ * @typedef {import('./types').StreamWriteEvent} StreamWriteEvent
+ * @typedef {import('./types').StreamResetEvent} StreamResetEvent
+ * @typedef {import('./types').StreamNetworkFinishEvent} StreamNetworkFinishEvent
+ *
+ * @typedef {import('./types').NativeHttp3WTStream} NativeHttp3WTStream
+ *
+ * @typedef {import('./session').Http3WTSession} Http3WTSession
+ *
+ * @typedef {import('stream/web').WritableStreamDefaultController} WritableStreamDefaultController
+ */
+
+export class Http3WTStream {
+  /**
+   * @param {object} args
+   * @param {NativeHttp3WTStream} args.object
+   * @param {Http3WTSession} args.parentobj
+   * @param {object} args.transport
+   * @param {boolean} args.bidirectional
+   * @param {boolean} args.incoming
+   */
+  constructor(args) {
+    this.objint = args.object
+    this.objint.jsobj = this
+    this.parentobj = args.parentobj
+    this.transport = args.transport
+    this.bidirectional = args.bidirectional
+    this.incoming = args.incoming
+    this.closed = false
+
+    /** @type {Promise<void> | null} */
+    this.pendingoperation = null
+    this.pendingres = null
+
+    if (this.bidirectional || this.incoming) {
+      this.readable = new ReadableStream(
+        {
+          start: (controller) => {
+            this.readableController = controller
+            // @ts-expect-error this.readable could be undefined
+            this.parentobj.addReceiveStream(this.readable, controller)
+            this.objint.startReading()
+          },
+          pull: (controller) => {
+            if (this.readableclosed) {
+              return Promise.resolve()
+            }
+            this.objint.startReading()
+          },
+          cancel: (reason) => {
+            /** @type {Promise<void>} */
+            const promise = new Promise((resolve, reject) => {
+              this.cancelres = resolve
+            })
+            let code = 0
+            if (reason && reason.code) {
+              if (reason.code < 0) code = 0
+              else if (reason.code > 255) code = 255
+              else code = reason.code
+            }
+            this.readableclosed = true
+            this.objint.stopSending(code)
+            return promise
+          }
+        },
+        { highWaterMark: 4 }
+      )
+    }
+    if (this.bidirectional || !this.incoming) {
+      this.writable = new WritableStream(
+        {
+          start: (controller) => {
+            this.writableController = controller
+            // @ts-expect-error this.writable could be undefined
+            this.parentobj.addSendStream(this.writable, controller)
+          },
+          write: (chunk, controller) => {
+            if (this.writableclosed) {
+              return Promise.resolve()
+            }
+            if (chunk instanceof Uint8Array) {
+              this.pendingoperation = new Promise((resolve, reject) => {
+                this.pendingres = resolve
+              })
+              const dataprom = this.parentobj.waitForDatagramsSend()
+              dataprom.finally(() => {
+                this.objint.writeChunk(chunk)
+              })
+              return this.pendingoperation
+            } else {
+              console.log('chunk info:', chunk)
+              throw new Error('chunk is not of instanceof Uint8Array ')
+            }
+          },
+          close: () => {
+            if (this.writableclosed) {
+              return Promise.resolve()
+            }
+            this.objint.streamFinal()
+            this.pendingoperation = new Promise((resolve, reject) => {
+              this.pendingres = resolve
+            })
+            return this.pendingoperation
+          },
+          abort: (reason) => {
+            if (this.writableclosed) {
+              return new Promise((resolve, reject) => {
+                resolve()
+              })
+            }
+            let code = 0
+            if (reason && reason.code) {
+              if (reason.code < 0) code = 0
+              else if (reason.code > 255) code = 255
+              else code = reason.code
+            }
+            /** @type {Promise<void>} */
+            const promise = new Promise((resolve, reject) => {
+              this.abortres = resolve
+            })
+            this.objint.resetStream(code)
+            return promise
+          }
+        },
+        { highWaterMark: 4 }
+      )
+    }
+
+    /** @type {(() => void) | null} */
+    this.cancelres = null
+    /** @type {(() => void) | null} */
+    this.pendingres = null
+    /** @type {(() => void) | null} */
+    this.abortres = null
+  }
+
+  /**
+   * @param {import('./types').StreamRecvSignalEvent} args
+   * @returns {void}
+   */
+  onStreamRecvSignal(args) {
+    // console.log('onStreamRecvSignal', args)
+    // check if transport is closed
+    const parentstate = this.parentobj.state
+    if (parentstate === 'closed' || parentstate === 'failed') return
+    switch (args.nettask) {
+      case 'resetStream':
+        if (this.readable) {
+          this.parentobj.removeReceiveStream(
+            this.readable,
+            this.readableController
+          )
+          this.readableclosed = true
+          this.readableController.error(args.code || 0)
+        } else console.log('stopSending wihtout readable')
+        break
+
+      case 'stopSending':
+        if (this.writable) {
+          this.parentobj.removeSendStream(
+            this.writable,
+            this.writableController
+          )
+
+          this.writableclosed = true
+          this.writableController.error(args.code || 0)
+        } else console.log('stopSending wihtout writable')
+        break
+      default:
+        console.log('unhandled onStreamRecvSignal')
+    }
+
+    if (this.pendingoperation) {
+      const res = this.pendingres
+      this.pendingoperation = null
+      this.pendingres = null
+      if (res != null) {
+        res()
+      }
+    }
+  }
+
+  /**
+   * @param {StreamReadEvent} args
+   * @returns {void}
+   */
+  onStreamRead(args) {
+    if (args.data && args.data.length && !this.readableclosed) {
+      // console.log('stream read received', args.data, Date.now())
+      this.readableController.enqueue(args.data)
+      if (
+        this.readableController.desiredSize != null &&
+        this.readableController.desiredSize < 0
+      )
+        this.objint.stopReading()
+    }
+    if (args.fin) {
+      if (this.cancelres) {
+        const res = this.cancelres
+        this.cancelres = null
+        res()
+      }
+      if (!this.readableclosed) {
+        this.readableController.close()
+        this.readableclosed = true
+      }
+    }
+  }
+
+  /**
+   * @param {StreamWriteEvent} args
+   */
+  onStreamWrite(args) {
+    // we ignore success
+    if (this.pendingoperation) {
+      const res = this.pendingres
+      this.pendingoperation = null
+      this.pendingres = null
+      if (res != null) {
+        res()
+      }
+    }
+  }
+
+  /**
+   * @param {StreamResetEvent} args
+   */
+  onStreamReset(args) {
+    if (this.abortres) {
+      this.abortres()
+      if (this.readable)
+        this.parentobj.removeReceiveStream(
+          this.readable,
+          this.readableController
+        )
+      if (this.writable)
+        this.parentobj.removeSendStream(this.writable, this.writableController)
+      this.readableclosed = true
+      this.parentobj.removeStreamObj(this)
+    }
+  }
+
+  /**
+   * @param {StreamNetworkFinishEvent} args
+   */
+  onStreamNetworkFinish(args) {
+    // console.log('networkfinish args', args)
+    switch (args.nettask) {
+      case 'stopSending':
+        if (this.cancelres) {
+          const res = this.cancelres
+          this.cancelres = null
+          res()
+        }
+        this.stopSendingRecv = true
+        break
+      case 'resetStream':
+        if (this.abortres) {
+          const res = this.abortres
+          this.abortres = null
+          res()
+        }
+
+        break
+
+      case 'streamFinal':
+        if (this.pendingoperation) {
+          const res = this.pendingres
+          this.pendingoperation = null
+          this.pendingres = null
+          if (res != null) {
+            res()
+          }
+        }
+        break
+      default:
+        console.log('onStreamNetworkFinish unknown task')
+    }
+    // we could differentiate....
+  }
+
+  /**
+   * @param {StreamRecvSignalEvent | StreamReadEvent | StreamWriteEvent | StreamResetEvent | StreamNetworkFinishEvent} args
+   */
+  static callback(args) {
+    // console.log('Stream callback called', args)
+    if (!args || !args.object || !args.object.jsobj)
+      throw new Error('Stream callback without jsobj')
+    const visitor = args.object.jsobj
+    if (args.purpose) {
+      switch (args.purpose) {
+        case 'StreamRecvSignal':
+          visitor.onStreamRecvSignal(args)
+          break
+        case 'StreamRead':
+          if (visitor && Object.prototype.hasOwnProperty.call(args, 'data')) {
+            visitor.onStreamRead(args)
+          } else {
+            console.log('Stream callback called', visitor, args)
+            throw new Error('Malformed StreamRead')
+          }
+          break
+        case 'StreamWrite':
+          visitor.onStreamWrite(args)
+          break
+        case 'StreamReset':
+          visitor.onStreamReset(args)
+          break
+        case 'StreamNetworkFinish':
+          visitor.onStreamNetworkFinish(args)
+
+          break
+        default: {
+          throw new Error('unknown purpose Streamcb')
+        }
+      }
+    } else throw new Error('no purpose Streamcb')
+  }
+}

package/lib/transport.js

@@ -0,0 +1,42 @@
+import { Http3EventLoop } from './event-loop.js'
+import { wtrouter } from './native.js'
+
+export class Http3WebTransport {
+  /**
+   * @param {*} args
+   * @param {'server' | 'client'} purpose
+   */
+  constructor(args, purpose) {
+    const eventloop = Http3EventLoop.getGlobalEventLoop(this).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
+
+    this.sessions = {}
+  }
+
+  /**
+   * @typedef {object} TransportCallbackEvent
+   * @property {{ jsobj: { customCallback: (args: any) => void }}} object
+   * @property {string} purpose
+   *
+   * @param {TransportCallbackEvent} args
+   */
+  static transportCallback(args) {
+    // console.log('incoming callback transport', args)
+    if (!args || !args.object || !args.object.jsobj)
+      throw new Error('Transport callback without jsobj')
+    const visitor = args.object.jsobj
+    if (args.purpose) {
+      if (visitor.customCallback) {
+        visitor.customCallback(args)
+      } else {
+        throw new Error('unknown purpose')
+      }
+    }
+  }
+}

package/lib/types.ts

@@ -0,0 +1,181 @@
+import type { WebTransport } from './dom'
+
+/**
+ * Native Http3WTSession counterpart
+ */
+ export interface NativeHttp3WTSession {
+  jsobj: WebTransportSessionEventHandler
+  writeDatagram: (chunk: Uint8Array) => void
+  orderUnidiStream: () => void
+  orderBidiStream: () => void
+  close: (arg: { code: number, reason: string }) => void
+}
+
+/**
+ * Native Http3WTStream counterpart
+ */
+export interface NativeHttp3WTStream {
+  jsobj: WebTransportStreamEventHandler
+  startReading: () => void
+  stopReading: () => void
+  stopSending: (code: number) => void
+  resetStream: (code: number) => void
+  writeChunk: (buf: Uint8Array) => void
+  streamFinal: () => void
+}
+
+export type Purpose = 'StreamRecvSignal' | 'StreamRead' | 'StreamWrite' | 'StreamReset' | 'StreamNetworkFinish'
+export type NetTask = 'stopSending' | 'resetStream' | 'streamFinal'
+
+export interface StreamRecvSignalEvent {
+  object: NativeHttp3WTStream
+  purpose: 'StreamRecvSignal'
+  code: number
+  nettask: NetTask
+}
+
+export interface StreamReadEvent {
+  object: NativeHttp3WTStream
+  purpose: 'StreamRead'
+  data?: Uint8Array
+  fin?: boolean
+}
+
+export interface StreamWriteEvent {
+  object: NativeHttp3WTStream
+  purpose: 'StreamWrite'
+}
+
+export interface StreamResetEvent {
+  object: NativeHttp3WTStream
+  purpose: 'StreamReset'
+}
+
+export interface StreamNetworkFinishEvent {
+  object: NativeHttp3WTStream
+  purpose: 'StreamNetworkFinish'
+  nettask: NetTask
+}
+
+export interface WebTransportStreamEventHandler {
+  onStreamRecvSignal: (evt: StreamRecvSignalEvent) => void
+  onStreamRead: (evt: StreamReadEvent) => void
+  onStreamWrite: (evt: StreamWriteEvent) => void
+  onStreamReset: (evt: StreamResetEvent) => void
+  onStreamNetworkFinish: (evt: StreamNetworkFinishEvent) => void
+}
+
+export interface SessionReadyEvent {
+  object: NativeHttp3WTSession
+  purpose: 'SessionReady'
+}
+
+export interface SessionCloseEvent {
+  object: NativeHttp3WTSession
+  purpose: 'SessionClose'
+  errorcode: number
+  error: string
+}
+
+export interface DatagramReceivedEvent {
+  object: NativeHttp3WTSession
+  purpose: 'DatagramReceived'
+  datagram: Uint8Array
+}
+
+export interface DatagramSendEvent {
+  object: NativeHttp3WTSession
+  purpose: 'DatagramSend'
+}
+
+export interface NewStreamEvent {
+  object: NativeHttp3WTSession
+  purpose: 'Http3WTStreamVisitor'
+  stream: NativeHttp3WTStream
+  transport: object
+  bidirectional: boolean
+  incoming: boolean
+}
+
+export interface WebTransportSessionEventHandler {
+  onReady: (evt: SessionReadyEvent) => void
+  onClose: (evt: SessionCloseEvent) => void
+  onDatagramReceived: (evt: DatagramReceivedEvent) => void
+  onDatagramSend: (evt: DatagramSendEvent) => void
+  onStream: (evt: NewStreamEvent) => void
+  closeHook?: (() => void) | null
+}
+
+export interface ClientConnectedEvent {
+  purpose: 'ClientConnected'
+  success: boolean
+}
+
+export interface ClientWebtransportSupportEvent {
+  purpose: 'ClientWebtransportSupport'
+}
+
+export interface Http3WTSessionVisitorEvent {
+  purpose: 'Http3WTSessionVisitor'
+  session: NativeHttp3WTSession
+}
+
+export interface Http3ClientEventHandler {
+  onClientConnected: (evt: ClientConnectedEvent) => void
+  onClientWebTransportSupport: (evt: ClientWebtransportSupportEvent) => void
+  onHttp3WTSessionVisitor: (evt: Http3WTSessionVisitorEvent) => void
+}
+
+export interface Http3WTServerSessionVisitorEvent extends Http3WTSessionVisitorEvent {
+  path: string
+  object: any
+}
+
+/**
+ * The Http3 server is listening on the specified port
+ */
+export interface Http3ServerListeningEvent {
+  purpose: 'Http3ServerListening'
+}
+
+/**
+ * The Http3 server has stopped listening on the specified port
+ */
+ export interface ServerStatusEvent {
+  port: number | null
+  host: string | null
+  purpose: 'ServerStatus',
+  status: 'error' | 'listening' | 'close'
+}
+
+
+export interface Http3ServerEventHandler {
+  onHttp3WTSessionVisitor: (evt: Http3WTServerSessionVisitorEvent) => void
+  onServerError: () => void
+  onServerListening: () => void
+  onServerClose: () => void
+  onServerStatus: (evt: ServerStatusEvent) => void
+}
+
+/**
+ * A defered promise with the value T
+ */
+export interface Deferred<T = unknown> {
+  promise: Promise<T>
+  resolve: (value?: T) => void
+  reject: (reason?: any) => void
+}
+
+export type WebTransportSessionState = 'connected' | 'closed' | 'failed'
+
+export interface WebTransportSession extends WebTransport {
+  state: WebTransportSessionState
+}
+
+export interface Http3ServerInit {
+  port: number
+  host: string
+  secret: string
+  cert: string
+  privKey: string
+}

package/lib/utils.js

@@ -0,0 +1,22 @@
+/**
+ * @template {unknown} T
+ * @returns {import('./types').Deferred<T>}
+ */
+export function defer() {
+  /** @type {(value?: T) => void} */
+  let res = () => {}
+
+  /** @type {(reason?: Error) => void} */
+  let rej = () => {}
+
+  const promise = new Promise((resolve, reject) => {
+    res = resolve
+    rej = reject
+  })
+
+  return {
+    promise,
+    resolve: res,
+    reject: rej
+  }
+}

package/lib/webtransport.js

@@ -0,0 +1,114 @@
+import { Http3Client } from './client.js'
+import { Http3WTSession } from './session.js'
+
+/** @type {WeakMap<WebTransport, Http3WTSession>} */
+const sessions = new WeakMap()
+
+/**
+ * @typedef {import('./dom').WebTransportCloseInfo} WebTransportCloseInfo
+ * @typedef {import('./dom').WebTransportBidirectionalStream} WebTransportBidirectionalStream
+ * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
+ */
+
+/**
+ * @typedef {import('./dom').WebTransport} WebTransportInterface
+ *
+ * @implements {WebTransportInterface}
+ */
+export class WebTransport {
+  /**
+   * @param {string} url
+   * @param {import('./dom').WebTransportOptions} [args]
+   */
+  constructor(url, args) {
+    if (!url) throw new Error('no URL supplied')
+
+    const ourl = new URL(url)
+
+    if (ourl.protocol !== 'https:') {
+      throw new Error('URL is not supported for webtransport')
+    }
+
+    const hostname = ourl.hostname
+    let port = ourl.port
+    if (port === '') port = '443'
+
+    const client = new Http3Client({ hostname, port, ...args })
+
+    const sessionint = new Http3WTSession({
+      /* object: args.session, */
+      parentobj: client
+    })
+
+    this.ready = sessionint.ready
+    this.closed = sessionint.closed
+
+    this.datagrams = sessionint.datagrams
+
+    /** @type {ReadableStream<WebTransportBidirectionalStream>} */
+    this.incomingBidirectionalStreams = sessionint.incomingBidirectionalStreams
+
+    /** @type {ReadableStream<WebTransportReceiveStream>} */
+    this.incomingUnidirectionalStreams =
+      sessionint.incomingUnidirectionalStreams
+
+    sessions.set(this, sessionint)
+
+    client
+      .handleConnection()
+      .then(() => {
+        client.quicconnected
+          ?.then(() => {
+            return client.createWTSession(sessionint, ourl.pathname)
+          })
+          .catch((err) => {
+            sessionint.readyReject(
+              new Error('Establishing session failed ' + err)
+            )
+            console.log('Establishing session failed ' + err)
+            client.closeHookSession()
+          })
+      })
+      .catch((error) => {
+        sessionint.readyReject(new Error('Quic connection failed ' + error))
+        console.log('Quic connection failed ' + error)
+        client.closeHookSession()
+      })
+  }
+
+  /**
+   * @param {WebTransportCloseInfo} [closeinfo]
+   */
+  close(closeinfo) {
+    const session = sessions.get(this)
+
+    if (session == null) {
+      // should never happen as session is only removed when this instance is garbage collected
+      throw new Error('Http3WTSession was undefined')
+    }
+
+    return session.close(closeinfo)
+  }
+
+  createBidirectionalStream() {
+    const session = sessions.get(this)
+
+    if (session == null) {
+      // should never happen as session is only removed when this instance is garbage collected
+      throw new Error('Http3WTSession was undefined')
+    }
+
+    return session.createBidirectionalStream()
+  }
+
+  createUnidirectionalStream() {
+    const session = sessions.get(this)
+
+    if (session == null) {
+      // should never happen as session is only removed when this instance is garbage collected
+      throw new Error('Http3WTSession was undefined')
+    }
+
+    return session.createUnidirectionalStream()
+  }
+}