@fails-components/webtransport 0.2.2 → 0.3.1

package/lib/utils.js

@@ -1,3 +1,5 @@
+import debug from 'debug'
+
 /**
  * @template {unknown} T
  * @returns {import('./types').Deferred<T>}
@@ -20,3 +22,14 @@ export function defer() {
     reject: rej
   }
 }
+
+/**
+ * @param {string} name
+ * @returns {import('./types').Logger}
+ */
+export function logger(name) {
+  return Object.assign(debug(name), {
+    error: debug(`${name}:error`),
+    trace: process.env.DEBUG_TRACE ? debug(`${name}:trace`) : () => {}
+  })
+}

package/lib/webtransport.js

@@ -10,6 +10,11 @@ const sessions = new WeakMap()
  * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
  */
 
+/**
+ * @template T
+ * @typedef {import('node:stream/web').ReadableStream<T>} ReadableStream<T>
+ */
+
 /**
  * @typedef {import('./dom').WebTransport} WebTransportInterface
  *
@@ -29,11 +34,11 @@ export class WebTransport {
       throw new Error('URL is not supported for webtransport')
     }
 
-    const hostname = ourl.hostname
+    const host = ourl.hostname
     let port = ourl.port
     if (port === '') port = '443'
 
-    const client = new Http3Client({ hostname, port, ...args })
+    const client = new Http3Client({ host, port, ...args })
 
     const sessionint = new Http3WTSession({
       /* object: args.session, */
@@ -49,7 +54,6 @@ export class WebTransport {
     /** @type {ReadableStream<WebTransportBidirectionalStream>} */
     this.incomingBidirectionalStreams = sessionint.incomingBidirectionalStreams
 
-    /** @type {ReadableStream<WebTransportReceiveStream>} */
     this.incomingUnidirectionalStreams =
       sessionint.incomingUnidirectionalStreams
 
@@ -57,23 +61,11 @@ export class WebTransport {
 
     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()
-          })
-      })
+      .then(() => client.createWTSession(sessionint, ourl.pathname))
       .catch((error) => {
-        sessionint.readyReject(new Error('Quic connection failed ' + error))
-        console.log('Quic connection failed ' + error)
         client.closeHookSession()
+        sessionint.readyReject(error)
+        sessionint.closedReject(error)
       })
   }
 

package/{test → old_test}/echoserver.js

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

package/{test → old_test}/test.js

@@ -4,7 +4,7 @@
 
 // this file runs various tests
 
-import { generateWebTransportCertificate } from './fixtures/certificate.js'
+import { generateWebTransportCertificate } from '../test/fixtures/certificate.js'
 import { Http3Server, WebTransport, testcheck } from '../lib/index.js'
 import { echoTestsConnection, runEchoServer } from './testsuite.js'
 
@@ -30,7 +30,7 @@ async function run() {
       }
     ]
   })
-  await badClient.ready
+  await Promise.all([badClient.ready, badClient.closed])
     .then(() => {
       console.error('Successfully connected to a non-running server?!')
       process.exit(1)
@@ -67,8 +67,8 @@ async function run() {
     privKey: certificate.private
   })
 
-  runEchoServer(http3server)
   http3server.startServer() // you can call destroy to remove the server
+  runEchoServer(http3server)
 
   console.log('server started now wait 2 seconds')
 
@@ -98,6 +98,8 @@ async function run() {
   await client.ready
   console.log('client is ready')
   await echoTestsConnection(client)
+  console.log('Test if getStats works')
+  console.log('getStats returned', await client.getStats())
   console.log('client test finished, now close the client but wait 2 seconds')
 
   await new Promise((resolve) => setTimeout(resolve, 2000))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fails-components/webtransport",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "description": "A component to add webtransport support (server and client) to node.js using libquiche",
   "main": "lib/index.js",
   "module": "lib/index.js",
@@ -11,15 +11,17 @@
   "types": "./dist/lib/index.d.ts",
   "scripts": {
     "start": "node test/echoserver.js",
-    "test": "mocha test/*.spec.js",
-    "oldtest": "node test/test.js",
+    "test": "npm run test:node && npm run test:chromium",
+    "test:node": "node test/index.js node",
+    "test:chromium": "node test/index.js chromium",
+    "oldtest": "node old_test/test.js",
     "install": "node build.js install",
     "build": "node build.js build",
     "rebuild": "node build.js rebuild",
     "rebuild-debug": "node build.js rebuild-debug -D",
     "build-debug": "node build.js build-debug",
     "types": "tsc",
-    "lint": "eslint lib test"
+    "lint": "eslint lib test old_test"
   },
   "repository": {
     "type": "git",
@@ -35,7 +37,9 @@
   },
   "homepage": "https://github.com/fails-components/webtransport#readme",
   "dependencies": {
+    "@types/debug": "^4.1.7",
     "bindings": "^1.5.0",
+    "debug": "^4.3.4",
     "node-addon-api": "^4.3.0",
     "prebuild-install": "^7.1.1"
   },
@@ -43,10 +47,12 @@
     "@babel/core": "^7.17.10",
     "@babel/eslint-parser": "^7.17.0",
     "@types/chai": "^4.3.3",
+    "@types/chai-as-promised": "^7.1.5",
     "@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",
     "cmake-js": "^6.3.2",
     "dirty-chai": "^2.0.1",
     "eslint": "^7.32.0",
@@ -57,15 +63,20 @@
     "eslint-plugin-prettier": "^3.4.1",
     "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": "^2.4.1",
-    "typescript": "4.8.4",
+    "typescript": "^4.8.4",
     "uint8arrays": "^4.0.2"
   },
   "binary": {
     "napi_versions": [
       6
     ]
+  },
+  "browser": {
+    "./test/fixtures/webtransport.js": "./test/fixtures/webtransport.browser.js"
   }
 }

package/readme.md

@@ -85,3 +85,67 @@ The WebTransport client only supports certification validation using fingerprint
 * [outgoingMaxAge](https://www.w3.org/TR/webtransport/#dom-webtransportdatagramduplexstream-outgoingmaxage)
 * [incomingHighWaterMark](https://www.w3.org/TR/webtransport/#dom-webtransportdatagramduplexstream-incominghighwatermark)
 * [outgoingHighWaterMark](https://www.w3.org/TR/webtransport/#dom-webtransportdatagramduplexstream-outgoinghighwatermark)
+
+## Development notes
+
+### Tests
+
+The unit test suite can be run on both node.js and Chrome to ensure behaviour is consistent between the two environments.
+
+[Mocha](https://www.npmjs.com/package/mocha) is used as a test runner in both environments, in the browser it is run via [playwright-test](https://www.npmjs.com/package/playwright-test).
+
+#### Running all tests:
+
+```console
+$ npm test
+```
+
+#### Running in node
+
+```console
+$ npm run test:node
+```
+
+#### Running in Chromium
+
+```console
+$ npm run test:chrome
+```
+
+#### Forward args
+
+Forward args are supported so you can pass any Mocha or playwright-test options after the `--`:
+
+E.g.:
+
+Run only "unidirectional streams" tests:
+
+```console
+$ npm run test:node -- --grep '"unidirectional streams"'
+```
+
+Disable headless mode to watch tests run in Chromium:
+
+```console
+$ npm run test:chromium -- --debug
+```
+
+### Logging
+
+This module uses the [debug](https://www.npmjs.com/package/debug) module for logging.
+
+To enable logging, specify the `DEBUG` environmental variable:
+
+```console
+$ DEBUG=webtransport* node my-script.js
+// debug output
+```
+
+#### Trace logging
+
+To enable detailed output, additionally set the `DEBUG_TRACE` environmental variable:
+
+```console
+$ DEBUG=webtransport* DEBUG_TRACE=true node my-script.js
+// lots of debug output
+```

package/src/http3client.cc

@@ -1329,9 +1329,9 @@ namespace quic
                     return;
                 }
 
-                if (lobj.Has("hostname") && !(lobj).Get("hostname").IsEmpty())
+                if (lobj.Has("host") && !(lobj).Get("host").IsEmpty())
                 {
-                    Napi::Value hostnameValue = (lobj).Get("hostname");
+                    Napi::Value hostnameValue = (lobj).Get("host");
                     hostname = hostnameValue.ToString().Utf8Value();
                 }
                 else

package/src/http3dispatcher.cc

@@ -43,13 +43,14 @@ std::unique_ptr<QuicSession> Http3Dispatcher::CreateQuicSession(
     QuicConnectionId connection_id, const QuicSocketAddress& self_address,
     const QuicSocketAddress& peer_address, absl::string_view /*alpn*/,
     const ParsedQuicVersion& version,
-    const ParsedClientHello& /*parsed_chlo*/) {
+    const ParsedClientHello& /*parsed_chlo*/,
+    ConnectionIdGeneratorInterface& connection_id_generator) {
   // The QuicServerSessionBase takes ownership of |connection| below.
   QuicConnection* connection =
       new QuicConnection(connection_id, self_address, peer_address, helper(),
                          alarm_factory(), writer(),
                          /* owns_writer= */ false, Perspective::IS_SERVER,
-                         ParsedQuicVersionVector{version}, connection_id_generator());
+                         ParsedQuicVersionVector{version}, connection_id_generator);
 
   auto session = std::make_unique<Http3ServerSession>(
       config(), GetSupportedVersions(), connection, this, session_helper(),

package/src/http3dispatcher.h

@@ -40,7 +40,8 @@ namespace quic
         QuicConnectionId connection_id, const QuicSocketAddress &self_address,
         const QuicSocketAddress &peer_address, absl::string_view alpn,
         const ParsedQuicVersion &version,
-        const ParsedClientHello &parsed_chlo) override;
+        const ParsedClientHello &parsed_chlo,
+        ConnectionIdGeneratorInterface& connection_id_generator) override;
 
     Http3ServerBackend *server_backend()
     {

package/src/http3eventloop.cc

@@ -33,6 +33,7 @@ namespace quic
   static const int kErrorBufferSize = 256;
 
   const size_t kNumSessionsToCreatePerSocketEvent = 16;
+  bool Http3EventLoop::hasSetLogging = false;
 
   Http3EventLoop::~Http3EventLoop()
   {
@@ -220,6 +221,31 @@ namespace quic
       progress_->Send(&report, 1);
   }
 
+  void  Http3EventLoop::informSessionStats(Http3WTSession *sessionobj, webtransport::SessionStats * sessstats)
+  {
+    Http3ProgressReport report;
+    report.type = Http3ProgressReport::SessionStats;
+    report.sessionobj = sessionobj;
+    report.sessionStats = sessstats;
+  
+    report.timestamp = new absl::Duration();
+    report.timestamp[0] = absl::Now() - absl::UnixEpoch();
+    if (progress_)
+      progress_->Send(&report, 1);
+  }
+
+  void  Http3EventLoop::informDatagramStats(Http3WTSession *sessionobj, webtransport::DatagramStats * datastats)
+  {
+    Http3ProgressReport report;
+    report.type = Http3ProgressReport::DatagramStats;
+    report.sessionobj = sessionobj;
+    report.datagramStats = datastats;
+    report.timestamp = new absl::Duration();
+    report.timestamp[0] = absl::Now() - absl::UnixEpoch();
+    if (progress_)
+      progress_->Send(&report, 1);
+  }
+
   void Http3EventLoop::informUnref(LifetimeHelper *obj)
   {
     Http3ProgressReport report;
@@ -591,6 +617,70 @@ namespace quic
     cbsession_.Call({retObj});
   }
 
+  void Http3EventLoop::processSessionStats(Http3WTSession *sessionobj, absl::Duration* timestamp, webtransport::SessionStats * sessstats)
+  {
+    if (!checkQw())
+      return;
+    HandleScope scope(qw_->Env());
+   
+
+    auto session = sessionobj->getJS();
+    if (!session)
+      return;
+    Napi::Object objVal = session->Value();
+
+    Napi::Object retObj = Napi::Object::New(qw_->Env());
+    retObj.Set("purpose", "SessionStats");
+    retObj.Set("object", objVal);
+    //  expiredOutgoing: bigint
+  // lostOutgoing: bigint
+
+  // non Datagram
+ //  minRtt: number
+ //  smoothedRtt: number
+ //  rttVariation: number
+  // estimatedSendRateBps: bigint
+    retObj.Set("timestamp", absl::ToDoubleMilliseconds(*timestamp)); // absl::Duration
+    // datagram
+    retObj.Set("expiredOutgoing", Napi::BigInt::New(qw_->Env(), sessstats->datagram_stats.expired_outgoing)); //uint64_t
+    retObj.Set("lostOutgoing", Napi::BigInt::New(qw_->Env(), sessstats->datagram_stats.lost_outgoing)); //uint64_t
+
+    // non Datagram
+    retObj.Set("minRtt", absl::ToDoubleMilliseconds(sessstats->min_rtt)); // absl::Duration
+    retObj.Set("smoothedRtt", absl::ToDoubleMilliseconds(sessstats->smoothed_rtt)); // absl::Duration
+    retObj.Set("rttVariation", absl::ToDoubleMilliseconds(sessstats->rtt_variation)); // absl::Duration
+    retObj.Set("estimatedSendRateBps", sessstats->estimated_send_rate_bps); // absl::Duration
+
+    cbsession_.Call({retObj});
+    delete sessstats;
+    delete timestamp;
+  }
+
+  void Http3EventLoop::processDatagramStats(Http3WTSession *sessionobj, absl::Duration* timestamp, webtransport::DatagramStats * datastats)
+  {
+    if (!checkQw())
+      return;
+    HandleScope scope(qw_->Env());
+   
+
+    auto session = sessionobj->getJS();
+    if (!session)
+      return;
+    Napi::Object objVal = session->Value();
+
+    Napi::Object retObj = Napi::Object::New(qw_->Env());
+    retObj.Set("purpose", "DatagramStats");
+    retObj.Set("object", objVal);
+    retObj.Set("timestamp", absl::ToDoubleMilliseconds(*timestamp)); // absl::Duration
+    // datagram
+    retObj.Set("expiredOutgoing", Napi::BigInt::New(qw_->Env(), datastats->expired_outgoing)); //uint64_t
+    retObj.Set("lostOutgoing", Napi::BigInt::New(qw_->Env(), datastats->lost_outgoing)); //uint64_t
+
+    cbsession_.Call({retObj});
+    delete datastats;
+    delete timestamp;
+  }
+
   void Http3EventLoop::processNewSessionRequest(Http3Server *serverobj, WebTransportSession *session, spdy::Http2HeaderBlock *reqheadcopy, WebTransportRespPromisePtr *promise)
   {
     if (!checkQw())
@@ -883,6 +973,18 @@ namespace quic
         processGoawayReceived(cur.sessionobj);
       }
       break;
+      case Http3ProgressReport::SessionStats:
+      {
+        processSessionStats(cur.sessionobj, cur.timestamp, cur.sessionStats);
+        cur.para = nullptr; // take ownership of the data
+      }
+      break;
+      case Http3ProgressReport::DatagramStats:
+      {
+        processDatagramStats(cur.sessionobj, cur.timestamp, cur.datagramStats);
+        cur.para = nullptr; // take ownership of the data
+      }
+      break;
       case Http3ProgressReport::Unref:
       {
         cur.obj->doUnref();
@@ -969,8 +1071,10 @@ namespace quic
     for (auto cur= quiche_cmd_line.begin(); cur != quiche_cmd_line.end(); cur++) {
       quiche_cmd_line_char.push_back((*cur).c_str());
     } 
-
-    quiche::QuicheParseCommandLineFlags("No use instruction.", quiche_cmd_line.size(), &(*quiche_cmd_line_char.begin()));
+    if (!hasSetLogging) {
+      quiche::QuicheParseCommandLineFlags("No use instruction.", quiche_cmd_line.size(), &(*quiche_cmd_line_char.begin()));
+      hasSetLogging = true;
+    }
   }
 
   void Http3EventLoop::startEventLoop(const Napi::CallbackInfo &info)

package/src/http3eventloop.h

@@ -94,6 +94,8 @@ namespace quic
             DatagramReceived,
             DatagramSend,
             GoawayReceived,
+            SessionStats,
+            DatagramStats,
             Unref
         } type;
         union
@@ -125,12 +127,15 @@ namespace quic
         {
             std::string *para = nullptr; // for session and others, we own it, and must delete it
             ServerStatusDetails *details;
+            webtransport::SessionStats * sessionStats; // we own it and must delete it after return from js
+            webtransport::DatagramStats * datagramStats; // we own it and must delete it after return from js
         };
         union
         {
             bool success;
             WebTransportRespPromisePtr *promise;
             Napi::Reference<Napi::Value> *header;
+            absl::Duration *timestamp; // for session and others, we own it, and must delete it
         };
     };
 
@@ -219,6 +224,9 @@ namespace quic
         void informDatagramReceived(Http3WTSession *sessionobj, absl::string_view datagram);
         void informDatagramSend(Http3WTSession *sessionobj, Napi::ObjectReference *bufferhandle);
 
+        void informSessionStats(Http3WTSession *sessionobj, webtransport::SessionStats * sessstats);
+        void informDatagramStats(Http3WTSession *sessionobj, webtransport::DatagramStats * datastats);
+
         void informGoawayReceived(Http3WTSession *sessionobj);
 
         void informUnref(LifetimeHelper *obj);
@@ -256,6 +264,8 @@ namespace quic
             return my_constructor;
         }
 
+        static bool hasSetLogging;
+
         void ExecuteScheduledActions();
 
         QuicMutex scheduled_actions_lock_;
@@ -286,6 +296,9 @@ namespace quic
         void processDatagramReceived(Http3WTSession *sessionobj, std::string *datagram);
         void processDatagramSend(Http3WTSession *sessionobj, Napi::ObjectReference *bufferhandle);
 
+        void processSessionStats(Http3WTSession *sessionobj, absl::Duration* timestamp, webtransport::SessionStats * sessstats);
+        void processDatagramStats(Http3WTSession *sessionobj, absl::Duration* timestamp, webtransport::DatagramStats * datastats);
+
         void processGoawayReceived(Http3WTSession *sessionobj);
 
         bool shutDownEventLoopInt();

package/src/http3wtsessionvisitor.cc

@@ -10,6 +10,7 @@ namespace quic
 
     Http3WTSession::Visitor::~Visitor()
     {
+        // printf("~Visitor %d %x %x\n", getpid(), this, session_);
         Http3WTSessionJS *sessobj = session_->getJS();
         if (sessobj)
             session_->eventloop_->informUnref(sessobj);
@@ -21,6 +22,7 @@ namespace quic
     void Http3WTSession::Visitor::OnSessionClosed(WebTransportSessionError error_code,
                                                 const std::string &error_message)
     {
+        // printf("OnSessionClosed %d %x %x\n", getpid(), this, session_);
         session_->session_ = nullptr;
         session_->eventloop_->informSessionClosed(session_, error_code, error_message);
     }

package/src/http3wtsessionvisitor.h

@@ -118,6 +118,7 @@ namespace quic
 
             void OnDatagramReceived(absl::string_view datagram) override
             {
+                // printf("OnDatagramReceived %d %x %x\n", getpid(), this, session_);
                 session_->eventloop_->informDatagramReceived(session_, datagram);
                 /*auto buffer = MakeUniqueBuffer(&allocator_, datagram.size());
                 memcpy(buffer.get(), datagram.data(), datagram.size());
@@ -230,6 +231,28 @@ namespace quic
             eventloop_->Schedule(task);
         }
 
+        void orderSessionStatsInt()
+        {
+            std::function<void()> task = [this](){
+                if (session_) {
+                    webtransport::SessionStats * stats = new webtransport::SessionStats();
+                    *stats = session_->GetSessionStats();
+                    eventloop_->informSessionStats(this, stats);
+            }};
+            eventloop_->Schedule(task);
+        }
+
+        void orderDatagramStatsInt()
+        {
+            std::function<void()> task = [this]()
+            {  if (session_) {
+                webtransport::DatagramStats * stats = new webtransport::DatagramStats();
+                *stats = session_->GetDatagramStats();
+                eventloop_->informDatagramStats(this, stats);
+            } };
+            eventloop_->Schedule(task);
+        }
+
         void closeInt(int code, std::string &reason)
         {
             std::function<void()> task = [this, code, reason]()
@@ -239,12 +262,15 @@ namespace quic
 
         void writeDatagramInt(char *buffer, size_t len, Napi::ObjectReference *bufferhandle)
         {
+            // printf("Datagram write %d %x %x\n", getpid(), this, session_ );
             if (!session_)
             {
+                // printf("Datagram session gone %d %x %x\n", getpid(), this, session_);
                 eventloop_->informDatagramSend(this, bufferhandle);
                 return;
             }
-            session_->SendOrQueueDatagram(absl::string_view(buffer, len));
+            auto status=session_->SendOrQueueDatagram(absl::string_view(buffer, len));
+            // printf("Datagram status %d %d %s %x %x\n", getpid(), status.code, status.error_message.c_str(), this, session_);
             eventloop_->informDatagramSend(this, bufferhandle);
         }
 
@@ -300,6 +326,16 @@ namespace quic
             wtsession_->notifySessionDrainingInt();
         }
 
+        void orderSessionStats(const Napi::CallbackInfo &info)
+        {
+             wtsession_->orderSessionStatsInt();
+        }
+
+        void orderDatagramStats(const Napi::CallbackInfo &info)
+        {
+             wtsession_->orderDatagramStatsInt();
+        }
+
         void close(const Napi::CallbackInfo &info)
         {
             int code = 0;
@@ -338,6 +374,10 @@ namespace quic
                                                                                                             static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
                                                            InstanceMethod<&Http3WTSessionJS::notifySessionDraining>("notifySessionDraining",
                                                                                                             static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                                                            InstanceMethod<&Http3WTSessionJS::orderSessionStats>("orderSessionStats",
+                                                                                                            static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                                                            InstanceMethod<&Http3WTSessionJS::orderDatagramStats>("orderDatagramStats",
+                                                                                                            static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
                                                            InstanceMethod<&Http3WTSessionJS::close>("close",
                                                                                                     static_cast<napi_property_attributes>(napi_writable | napi_configurable))});
             constr->session  = Napi::Persistent(tplwt);