@yz-social/webrtc 0.1.10 → 0.1.12

package/index.js

@@ -4,14 +4,14 @@ const wrtc = (typeof(process) === 'undefined') ? globalThis : (await import('#wr
 export class WebRTC {
   static iceServers = [ // Some default stun and even turn servers.
 
-    { urls: 'stun:stun.l.google.com:19302'},
+    { urls: 'stun:stun.l.google.com:19302'}, // As of 5/5/26, Edge and Firefox still require iceServers to be non-empty, even for localhost peers.
     // https://freestun.net/  Currently 50 KBit/s. (2.5 MBit/s fors $9/month)
-    { urls: 'stun:freestun.net:3478' },
+    //{ urls: 'stun:freestun.net:3478' },
 
     //{ urls: 'turn:freestun.net:3478', username: 'free', credential: 'free' },
     // Presumably traffic limited. Can generate new credentials at https://speed.cloudflare.com/turn-creds
     // Also https://developers.cloudflare.com/calls/ 1 TB/month, and $0.05 /GB after that.
-    { urls: 'turn:turn.speed.cloudflare.com:50000', username: '826226244cd6e5edb3f55749b796235f420fe5ee78895e0dd7d2baa45e1f7a8f49e9239e78691ab38b72ce016471f7746f5277dcef84ad79fc60f8020b132c73', credential: 'aba9b169546eb6dcc7bfb1cdf34544cf95b5161d602e3b5fa7c8342b2e9802fb' }
+    //{ urls: 'turn:turn.speed.cloudflare.com:50000', username: '826226244cd6e5edb3f55749b796235f420fe5ee78895e0dd7d2baa45e1f7a8f49e9239e78691ab38b72ce016471f7746f5277dcef84ad79fc60f8020b132c73', credential: 'aba9b169546eb6dcc7bfb1cdf34544cf95b5161d602e3b5fa7c8342b2e9802fb' }
 
     // See also:
     // https://fastturn.net/ Currently 500MB/month? (25 GB/month for $9/month)
@@ -20,7 +20,7 @@ export class WebRTC {
   ];
   cleanup() { // Attempt to allow everything to be garbage-collected.
     if (!this.pc) return;
-    this.pc.onicecandidate = this.pc.ondatachannel = this.pc.onnegotiationneeded = this.pc.onconnectionstatechange = this.pc.oniceconnectionstatechange = null;
+    this.pc.onicecandidate = this.pc.ondatachannel = this.pc.onnegotiationneeded = this.pc.onconnectionstatechange = this.pc.oniceconnectionstatechange = this.pc.onicecandidateerror = null;
     delete this.pc;
     delete this.dataChannelPromises;
     delete this.dataChannelOursPromises;
@@ -28,9 +28,11 @@ export class WebRTC {
   }
 
   // Number of instances at a time (if previous have been garbage collected), as of 1/27/26:
-  static suggestedInstancesLimit = globalThis.navigator.vendor?.startsWith('Apple') ? 95 : // Seems to be hardcoded?
-    globalThis.navigator.userAgent?.includes('Firefox') ? 190 :
-    200;
+  static suggestedInstancesLimit =
+    globalThis.navigator.vendor?.startsWith('Apple') ? 150 : // Safari will open 256, but it won't reliably keep them all open at once.
+    globalThis.navigator.userAgent?.includes('Firefox') ? 150 : // 256 on an M5 chip. On an i9 MBP, I can sometimes get more than 150, but not with refresh.
+    (typeof(globalThis.process) !== 'undefined') ? 249 :  // NodeJS
+    256;
   constructor({configuration = {iceServers: WebRTC.iceServers}, ...properties}) {
     Object.assign(this, properties);
 
@@ -63,9 +65,12 @@ export class WebRTC {
       this.signal({ candidate: e.candidate });
     };
     this.pc.ondatachannel = e => this.ondatachannel(e.channel);
+    this.pc.onicecandidateerror = error => {
+      const {errorCode, errorText, url, address, port} = error;
+      this.flog(`${errorCode}: ${errorText || '(ice failure)'} ${address}:${port} @${url}`);
+    };
     this.pc.oniceconnectionstatechange = () => {
       if (!this.pc) return;
-      //this.flog('iceConnectionState', this.pc.iceConnectionState);
       switch (this.pc.iceConnectionState) {
       case 'completed':
 	this._resolveIceCompleted?.(true);
@@ -325,11 +330,11 @@ export class WebRTC {
       return;
     }
     const remote = stats.get(candidatePair.remoteCandidateId);
-    const {protocol, candidateType} = remote;
+    const {protocol, candidateType, address} = remote;
     const now = Date.now();
     const statsElapsed = now - this.connectionStartTime;
     Object.assign(this, {stats, transport, candidatePair, remote, protocol, candidateType, statsTime: now, statsElapsed});
-    if (doLogging) console.info(this.name, 'connected', protocol, candidateType, (statsElapsed/1e3).toFixed(1));
+    if (doLogging) console.info(this.name, 'connected', protocol, candidateType, address, (statsElapsed/1e3).toFixed(1));
   }
 
   static getPublicIP(stunServer = "stun:stun.l.google.com:19302") { // Promise external/WAN/public IP addresses for this device.

package/package.json

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

package/spec/portal.js

@@ -13,8 +13,8 @@ import { WebRTC } from '../index.js';
 // The WebRTC does nothing except say 'Welcome!' on the data channel opened by the client.
 // 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 nPortals = parseInt(process.argv[2] || 256);
+const perPortalDelay = parseInt(process.argv[3] || 200);
 const port = parseInt(process.argv[4] || 3000);
 
 if (cluster.isPrimary) { // Parent process with portal webserver through which clienta can bootstrap
@@ -23,14 +23,22 @@ if (cluster.isPrimary) { // Parent process with portal webserver through which c
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = path.dirname(__filename);
   console.log('launching', nPortals, 'portals');
-  for (let i = 0; i < nPortals; i++) {
-    const worker = cluster.fork();
+  const workers = [];
+  function makeWorker(i) {
+    const worker = workers[i] = cluster.fork();
+    console.log(new Date(), 'creating worker', i, 'at', worker.id);
     worker.on('message', signals => { // Message from a worker, in response to a POST.
       worker.requestResolver?.(signals);
     });
+  }
+  for (let i = 0; i < nPortals; i++) {
+    makeWorker(i);
     await new Promise(resolve => setTimeout(resolve, perPortalDelay));
   }
-  const workers = Object.values(cluster.workers);
+  cluster.on('exit', (worker, code, signal) => { // Replace the worker at the same index in workers[].
+    const index = workers.indexOf(worker);
+    makeWorker(index);
+  });
   app.use(logger(':date[iso] :status :method :url :res[content-length] - :response-time ms'));
   app.use(express.json());
   app.use(express.static(path.resolve(__dirname, '..'))); // Serve files needed for testing browsers.
@@ -61,7 +69,6 @@ if (cluster.isPrimary) { // Parent process with portal webserver through which c
     process.send(response);
   });
   function setup() {
-    console.log(new Date(), 'launched bot', cluster.worker.id);
     portal = new WebRTC({name: 'portal'});
     portal.getDataChannelPromise('data').then(dc => {
       console.log(new Date(), 'connected bot', cluster.worker.id);
@@ -69,8 +76,7 @@ if (cluster.isPrimary) { // Parent process with portal webserver through which c
     });
     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());
+      process.exit(0); // cleaner for testing than repeating setup();
     });
   }
   setup();

package/spec/webrtcCapacitySpec.js

@@ -6,19 +6,26 @@ function delay(ms) {
 }
 
 describe("WebRTC capacity", function () {
-  let nNodes = 75; // When running all webrtc tests at once, it is important to keep this low. (Memory leak?)
-  let perPortalDelay = 1e3;
+  let perPortalDelay = 200;
   let portalSlopDelay = 2e3;
   let perConnectionDelay = 100;
-  let connectionSlopDelay = 2e3;
+  let connectionSlopDelay = 4e3;
   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;
+  // (And also likely comment out the import './webrtcSpec.js' in test.html,
+  //  and "resignals on restartIce..." tests.)
+  let nNodes = WebRTC.suggestedInstancesLimit;
+  let reNegotiate = false; // Should we attempt to test restartIce/re-negotiation?
+  if (reNegotiate) {
+    if (globalThis.navigator.userAgent?.includes('Firefox') ||
+	globalThis.navigator.vendor?.startsWith('Apple') ||
+	(typeof(globalThis.process) !== 'undefined'))
+      nNodes = Math.floor(0.5 * nNodes);
+  }
 
   const isNodeJS = typeof(globalThis.process) !== 'undefined';
   const portalIsLocal = isNodeJS && baseURL.startsWith('http://localhost');
@@ -60,18 +67,13 @@ describe("WebRTC capacity", function () {
       const dataOpened = node.getDataChannelPromise('data')
 	    .then(dc => node.dataReceived = new Promise(resolve => dc.onmessage = event => resolve(event.data)));
       node.createChannel('data', {negotiated: false});
-      await dataOpened;
+      await Promise.race([dataOpened, delay(perConnectionDelay)]);
       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(), 'pause after setup');
     await delay(connectionSlopDelay);
     console.log(new Date(), 'finished setup');
-  }, nNodes * perPortalDelay + portalSlopDelay + nNodes * perConnectionDelay + connectionSlopDelay + 1e3);
+  }, nNodes * perPortalDelay + portalSlopDelay + 2 * nNodes * perConnectionDelay + 2 * connectionSlopDelay);
   for (let index = 0; index < nNodes; index++) {
     it('opened connection ' + index, function () {      
       expect(nodes[index].pc.connectionState).toBe('connected');
@@ -79,17 +81,17 @@ describe("WebRTC capacity", function () {
     it('got data ' + index, async function () {
       expect(await nodes[index].dataReceived).toBe('Welcome!');
     });
-    it('resignals on restartIce ' + index, async function () {
-      const node = nodes[index];
-      expect(node.pc.iceConnectionState).toBe('completed');
-      node.nFetches = 0;
-      node.pc.restartIce();
-      await delay(100); // timing will vary
-      expect(node.pc.iceConnectionState).not.toBe('completed');
-      await delay(2e3); // timing will vary
-      expect(node.pc.iceConnectionState).toBe('completed');
-      expect(node.nFetches).toBeGreaterThan(0); // We will have re-signalled.
-    });
+    if (reNegotiate) {
+      it('resignals on restartIce ' + index, async function () {
+	const node = nodes[index];
+	expect(['connected', 'completed']).toContain(node.pc.iceConnectionState);
+	node.nFetches = 0;
+	const promise = node.renegotiate();
+	await Promise.race([promise, delay(1e3)]);
+	expect(['connected', 'completed']).toContain(node.pc.iceConnectionState);
+	expect(node.nFetches).toBeGreaterThan(0); // We will have re-signalled.
+      });
+    }
   }
   afterAll(async function () {
     console.log(new Date(), 'starting teardown');