@yz-social/webrtc 0.1.3 → 0.1.5

package/README.md

@@ -1,10 +1,30 @@
+# @yz-social/webrtc
 
-## Data channel name event
+A wrapper around either the browser's WebRTC, or around @roamhq/wrtc on NodeJS.
+
+Installing this package in NodeJS - i.e., with `npm install` in either this package's directory or in some other module that imports this - will install the @roamhq/wrtc dependency. Succesfully installing _that_ may require extra C++ tools on the host system. 
+
+For example, you probably need to have `git bash` or the like installed, and to execute the various `npm` commands within that. During the Windows installation of NodeJS (prior to installing this package), you may be asked whether to install the additional tools for VC++, including Chocalety. You should check the box to install them, and follow those directions. Installing those tools will occur in a separate window, prompt for proceeding, and may take a very long time to execute.
+
+
+## Some Tweaks
+
+See the test cases and spec/ports.js for examples.
+
+### Semi-trickled ice
+
+RTCPeerConnection generates a bunch of ICE candidates right away, and then more over the next few seconds. It can be a while before it is finished. In this package, we have utilities to collect signals as they occur, and then gather them for sending while accumulating a new set of signals to be sent.
+
+### Simultaneous outreach
+
+Things can get confused if two nodes try to connect to each other at the same time. There is supposed to be some automatic rollback mechanism, but implementations vary. This code tries to sort that out, if the applicaiton can label one of the pair to be "polite" and the other not. 
+
+### Data channel name event
 
 RTCPeerConnection defines a 'datachannel' event, and RTCDataChannel defines an 'open' event, but it is difficult to use them correctly:
 - 'datachannel' fires only for one side of a connection, and only when negotiated:false. 
 - To listen for 'open', you must already have the data channel. Not all implementations fire a handler for this when assigned in a 'datachannel' handler, and it can fire multiple times for the same channel name when two sides initiate the channel simultaneously with negotiated:true.
 
-## close event
+### close event
 
 RTCPeerConnection defines a 'signalingstatechange' event in which application handlers can fire code when aPeerConnection.readyState === 'closed', but this not particuarly convenient.

package/index.js

@@ -80,7 +80,9 @@ export class WebRTC {
     // Do not try to close or wait for data channels. It confuses Safari.
     const pc = this.pc;
     if (!pc) return null;
-    pc.close();
+    const state = pc.connectionState;
+    if (state === 'connected' || state === 'failed') pc.close();
+    else this.flog("WebRTC close in unexpected state", state);
     this.closed.resolve(pc); // We do not automatically receive 'connectionstatechange' when our side explicitly closes. (Only if the other does.)
     this.cleanup();
     return this.closed;
@@ -127,7 +129,7 @@ export class WebRTC {
 	this.settingRemote = true;
 	try {
 	  await this.pc.setRemoteDescription(description)
-	    .catch(e => this[offerCollision ? 'log' : 'flog'](this.name, 'ignoring error in setRemoteDescription while in state', this.pc.signalingState, e));
+	    .catch(e => this.log(this.name, 'ignoring error in setRemoteDescription while in state', this.pc.signalingState, e));
 	  if (offerCollision) this.rolledBack = true;
 	} finally {
 	  this.settingRemote = false;
@@ -137,7 +139,7 @@ export class WebRTC {
       if (description.type === "offer") {
 	const answer = await this.pc.createAnswer();
         await this.pc.setLocalDescription(answer)
-	  .catch(e => this.flog(this.name, 'ignoring error setLocalDescription of answer', e));
+	  .catch(e => this.log(this.name, 'ignoring error setLocalDescription of answer', e));
         this.signal({ description: this.pc.localDescription });
       }
 
@@ -233,10 +235,11 @@ export class WebRTC {
     this.log('setupChannel:', label, dc.id, readyState, 'negotiated:', dc.negotiated);
     const kind = isTheirs ? 'Theirs' : 'Ours';
     dc.webrtc = this;
-    dc.onopen = async () => { // Idempotent (except for logging), if we do not bash dataChannePromises[label] multiple times.
+    dc.onopen = () => { // Idempotent (except for logging), if we do not bash dataChannePromises[label] multiple times.
+      dc.onopen = null;
       this.log('channel onopen:', label, dc.id, readyState, 'negotiated:', dc.negotiated);
-      this[this.restrictablePromiseKey()][label]?.resolve(dc);
-      this[this.restrictablePromiseKey(kind)][label]?.resolve(dc);
+      this[this.restrictablePromiseKey()]?.[label]?.resolve(dc);
+      this[this.restrictablePromiseKey(kind)]?.[label]?.resolve(dc);
     };
     if (isTheirs) dc.onopen();
     return dc;
@@ -246,7 +249,6 @@ export class WebRTC {
     // This our chance to setupChannel, just as if we had called createChannel
     this.log('ondatachannel:', dc.label, dc.id, dc.readyState, dc.negotiated);
     this.setupChannel(dc);
-    dc.onopen(); // It had been opened before we setup, so invoke handler now.
   }
   channelId = 128; // Non-negotiated channel.id get assigned at open by the peer, starting with 0. This avoids conflicts.
   createChannel(name = 'data', {negotiated = false, id = this.channelId++, ...options} = {}) { // Explicitly create channel and set it up.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yz-social/webrtc",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Streamlined portable webrtc management of p2p and client2server.",
   "keywords": [
     "webrtc",

package/spec/portal.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import process from 'node:process';
 import cluster from 'node:cluster';
 import express from 'express';
@@ -13,6 +14,8 @@ import { WebRTC } from '../index.js';
 // For a more complete example, see https://github.com/YZ-social/kdht/blob/main/spec/portal.js
 
 const nPortals = parseInt(process.argv[2] || WebRTC.suggestedInstancesLimit);
+const perPortalDelay = parseInt(process.argv[3] || 1e3);
+const port = parseInt(process.argv[4] || 3000);
 
 if (cluster.isPrimary) { // Parent process with portal webserver through which clienta can bootstrap
   process.title = 'webrtc-test-portal';
@@ -25,6 +28,7 @@ if (cluster.isPrimary) { // Parent process with portal webserver through which c
     worker.on('message', signals => { // Message from a worker, in response to a POST.
       worker.requestResolver?.(signals);
     });
+    await new Promise(resolve => setTimeout(resolve, perPortalDelay));
   }
   const workers = Object.values(cluster.workers);
   app.use(logger(':date[iso] :status :method :url :res[content-length] - :response-time ms'));
@@ -32,7 +36,6 @@ if (cluster.isPrimary) { // Parent process with portal webserver through which c
   app.use(express.static(path.resolve(__dirname, '..'))); // Serve files needed for testing browsers.
   app.post('/join/:to', async (req, res, next) => { // Handler for JSON POST requests that provide an array of signals and get signals back.
     const {params, body} = req;
-    // Find the specifed worker, or pick one at random. TODO CLEANUP: Remove. We now use as separate /name/:label to pick one.
     const worker = workers[params.to];
     if (!worker) {
       console.warn('no worker', params.to);
@@ -48,7 +51,8 @@ if (cluster.isPrimary) { // Parent process with portal webserver through which c
 
     return res.send(response);
   });
-  app.listen(3000);
+  app.listen(port);
+  console.log(new Date(), 'listening on', port);
 } else {
   process.title = 'webrtc-test-bot-' + cluster.worker.id;
   let portal;
@@ -59,8 +63,15 @@ if (cluster.isPrimary) { // Parent process with portal webserver through which c
   function setup() {
     console.log(new Date(), 'launched bot', cluster.worker.id);
     portal = new WebRTC({name: 'portal'});
-    portal.getDataChannelPromise('data').then(dc => dc.send('Welcome!'));
-    portal.closed.then(setup); // Without any explicit message, this is 15 seconds after the other end goes away.
+    portal.getDataChannelPromise('data').then(dc => {
+      console.log('connected', cluster.worker.id);
+      dc.send('Welcome!');
+    });
+    portal.closed.then(() => {  // Without any explicit message, this is 15 seconds after the other end goes away.
+      console.log('disconnected', cluster.worker.id);
+      // Not needed for this test, but for other purposes:
+      // setup());
+    });
   }
   setup();
 }

package/spec/webrtcCapacitySpec.js

@@ -1,18 +1,28 @@
 const { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach} = globalThis; // For linters.
 import { WebRTC } from '../index.js';
 
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
 describe("WebRTC capacity", function () {
   let nNodes = 20; // When running all webrtc tests at once, it is important to keep this low. (Memory leak?)
+  let perPortalDelay = 1e3;
+  let port = 3000;
+  let baseURL = `http://localhost:${port}`;
+  // Alas, I can't seem to get more than about 150-160 nodes through ngrok, even on a machine that can handle 200 directly.
+  //let baseURL = 'https://dorado.ngrok.dev'; // if E.g., node spec/portal.js 200 100; ngrok http 3000 --url https://dorado.ngrok.dev
 
   // Uncomment this line if running a stand-alone capacity test.
   // (And also likely comment out the import './webrtcSpec.js' in test.html.)
   // nNodes = WebRTC.suggestedInstancesLimit;
 
   const isNodeJS = typeof(globalThis.process) !== 'undefined';
+  const portalIsLocal = isNodeJS && baseURL.startsWith('http://localhost');
   let nodes = [];
   beforeAll(async function () {
 
-    if (isNodeJS) {
+    if (portalIsLocal) {
       const { spawn } = await import('node:child_process');
       const path = await import('path');
       const { fileURLToPath } = await import('url');
@@ -20,29 +30,42 @@ describe("WebRTC capacity", function () {
       const __filename = fileURLToPath(import.meta.url);
       const __dirname = path.dirname(__filename);
       function echo(data) { data = data.slice(0, -1); console.log(data.toString()); }
-      const portalProcess = spawn('node', [path.resolve(__dirname, 'portal.js'), nNodes]);
+      const portalProcess = spawn('node', [path.resolve(__dirname, 'portal.js'), nNodes, perPortalDelay, port]);
       portalProcess.stdout.on('data', echo);
       portalProcess.stderr.on('data', echo);
-      await new Promise(resolve => setTimeout(resolve, 6e3));
+      await delay(perPortalDelay * (5 + nNodes));
     }
 
     console.log(new Date(), 'creating', nNodes, 'nodes');
     for (let index = 0; index < nNodes; index++) {
-      const node = nodes[index] = new WebRTC({name: 'node'});
-      node.transferSignals = messages => fetch(`http://localhost:3000/join/${index}`, {
+      const node = nodes[index] = new WebRTC({name: 'node' + index});
+      console.log('connecting', index);
+      node.transferSignals = messages => fetch(`${baseURL}/join/${index}`, {
 	method: 'POST',
 	headers: { 'Content-Type': 'application/json', 'Connection': 'close' },
 	body: JSON.stringify(messages)
-      }).then(response => response.json());
+      }).then(response => {
+	if (!response.ok) {
+	  console.log('fetch', index, 'failed', response.status, response.statusText);
+	  return null;
+	}
+	return response.json();
+      });
       node.closed.then(() => console.log('closed', index)); // Just for debugging.
       const dataOpened = node.getDataChannelPromise('data')
 	    .then(dc => node.dataReceived = new Promise(resolve => dc.onmessage = event => resolve(event.data)));
-      node.createChannel('data', {negotiated: false});      
+      node.createChannel('data', {negotiated: false});
       await dataOpened;
       console.log('opened', index);
+      if (!portalIsLocal) {
+	const maxConnectionsPerNode = 3;
+	const maxNgrokConnectionsPerSecond = 120 / 60;
+	const secondsPerNode = maxConnectionsPerNode / maxNgrokConnectionsPerSecond;
+	await delay(secondsPerNode * 1.5e3); // fudge factor milliseconds/second
+      }
     }
     console.log(new Date(), 'finished setup');
-  }, Math.max(20e3, nNodes * (500 + 300)));
+  }, nNodes * 4 * perPortalDelay);
   for (let index = 0; index < nNodes; index++) {
     it('opened connection ' + index, function () {      
       expect(nodes[index].pc.connectionState).toBe('connected');
@@ -60,7 +83,7 @@ describe("WebRTC capacity", function () {
 	expect(pc.connectionState).toBe('closed'));
       delete nodes[index];
     }
-    if (isNodeJS) {
+    if (portalIsLocal) {
       const { exec } = await import('node:child_process');      
       exec('pkill webrtc-test-');
     }