teleportxr 1.0.65 → 1.0.67

package/client/client.js

@@ -16,6 +16,11 @@ const { BackgroundMode } = require("../core/core.js");
 // gives roughly MAX_ACK_RESENDS*3 seconds before we stop trying.
 const MAX_ACK_RESENDS = 5;
 
+// Timeout in milliseconds for WebRTC connection establishment.
+// Clients that don't establish WebRTC within this time will be disconnected.
+// Configurable via WEBRTC_CONNECT_TIMEOUT_MS environment variable.
+const WEBRTC_CONNECT_TIMEOUT_MS = parseInt(process.env.WEBRTC_CONNECT_TIMEOUT_MS || '10000', 10);
+
 class OriginState
 {
     constructor() {
@@ -56,6 +61,7 @@ class Client {
 		this.next_ack_id=BigInt(1);
 		this.clientStartMs=Date.now();
 		this.webRtcConnectedAtMs=0;
+		this.webRtcConnectionInitiatedAtMs=0; // Track when WebRTC connection attempt started
     }
 	elapsedMsSinceStart(){
 		return Date.now()-this.clientStartMs;
@@ -63,6 +69,18 @@ class Client {
 	elapsedMsSinceConnected(){
 		return this.webRtcConnectedAtMs?Date.now()-this.webRtcConnectedAtMs:-1;
 	}
+	hasWebRtcConnectionTimedOut(){
+		// If WebRTC isn't connected yet and we initiated the connection attempt,
+		// check if we've exceeded the timeout
+		if(!this.webRtcConnected && this.webRtcConnectionInitiatedAtMs > 0) {
+			const elapsedMs = Date.now() - this.webRtcConnectionInitiatedAtMs;
+			if(elapsedMs > WEBRTC_CONNECT_TIMEOUT_MS) {
+				console.log("[T+"+this.elapsedMsSinceStart()+"ms] WebRTC connection timeout for client "+this.clientID+" ("+elapsedMs+"ms > "+WEBRTC_CONNECT_TIMEOUT_MS+"ms)");
+				return true;
+			}
+		}
+		return false;
+	}
 	tick(timestamp){
 		this.geometryService.GetNodesToSend();
 	}
@@ -250,6 +268,7 @@ class Client {
     StartStreaming()
     {
 		console.log("[T+"+this.elapsedMsSinceStart()+"ms] Client.StartStreaming() — creating WebRTC connection for client "+this.clientID);
+		this.webRtcConnectionInitiatedAtMs=Date.now(); // Record when we started trying to establish WebRTC
 		this.webRtcConnectionManager=WebRtcConnectionManager.getInstance();
         // We make sure WebRTC has a connection for this client.
   		this.webRtcConnection = this.webRtcConnectionManager.createConnection(
@@ -274,6 +293,7 @@ class Client {
 	// Generic message acknowledgement. Certain kinds of message are expected to be ack'ed.
 	ReceiveAcknowledgement(data)
 	{
+		console.log("ReceiveAcknowledgement called with " + data.byteLength + " bytes");
 		if (data.byteLength!=message.AcknowledgementMessage.sizeof())
 		{
 			console.log("Client: Received malformed AcknowledgementMessage packet of length: ",data.length);
@@ -291,13 +311,16 @@ class Client {
 			?new DataView(data.buffer,data.byteOffset,data.byteLength)
 			:new DataView(data,0,data.byteLength);
 		core.decodeFromDataView(msg,dataView,0);
+		console.log("ReceiveAcknowledgement decoded ack_id="+msg.uint64_ackId+", waiting for origin="+this.currentOriginState.ackId+", lighting="+this.currentLightingState.ackId);
 		if(msg.uint64_ackId==this.currentOriginState.ackId)
 		{
+			console.log("ReceiveAcknowledgement: acknowledged SetOriginNodeCommand");
 			this.currentOriginState.acknowledged=true;
 			this.currentOriginState.resendCount=0;
 		}
 		if(msg.uint64_ackId==this.currentLightingState.ackId)
 		{
+			console.log("ReceiveAcknowledgement: acknowledged SetLightingCommand");
 			this.currentLightingState.acknowledged=true;
 			this.currentLightingState.resendCount=0;
 		}

package/client/client_manager.js

@@ -29,8 +29,26 @@ class ClientManager
 			clearInterval(this.geometryIntervalId);
 	}
 	UpdateStreaming() {
+		// Track clients to remove due to timeout (can't modify Map during iteration)
+		const clientsToRemove = [];
+
 		for (let [cl_id,cl] of this.clients) {
-			cl.UpdateStreaming();
+			// Check if this client's WebRTC connection has timed out
+			if(cl.hasWebRtcConnectionTimedOut()) {
+				clientsToRemove.push(cl_id);
+			} else {
+				cl.UpdateStreaming();
+			}
+		}
+
+		// Remove clients that timed out
+		for (const cl_id of clientsToRemove) {
+			console.log("Removing client "+cl_id+" due to WebRTC connection timeout");
+			const cl = this.clients.get(cl_id);
+			if(cl) {
+				cl.StopStreaming();
+			}
+			this.RemoveClient(cl_id);
 		}
 	}
     GetOrCreateClient(clientID)

package/package.json

@@ -16,7 +16,7 @@
   },
   "name": "teleportxr",
   "description": "Teleport Spatial Server on node.js",
-  "version": "1.0.65",
+  "version": "1.0.67",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/simul/teleport-nodejs.git"

package/test/test_webrtc_connection_timeout.js

@@ -0,0 +1,90 @@
+'use strict';
+// Tests for WebRTC connection timeout functionality.
+// Verifies that clients that don't establish WebRTC within the configured
+// timeout are automatically disconnected.
+
+const test = require('node:test');
+const assert = require('node:assert');
+const { Client } = require('../client/client');
+const { ClientManager } = require('../client/client_manager');
+
+// Helper to create a stub client
+function makeStubClient(opts = {}) {
+	const c = Object.create(Client.prototype);
+	c.clientID = opts.clientID || 1;
+	c.scene = { GetAllNodeUids: () => [] };
+	c.geometryService = {
+		StreamNode: () => {},
+		GetNodesToSend: () => [],
+		GetMeshesToSend: () => [],
+		GetCanvasesToSend: () => [],
+		GetFontAtlasesToSend: () => [],
+		GetTexturesToSend: () => [],
+	};
+	c.clientStartMs = opts.clientStartMs || Date.now();
+	c.webRtcConnectedAtMs = 0;
+	c.webRtcConnected = false;
+	c.webRtcConnection = null;
+	c.webRtcConnectionInitiatedAtMs = opts.webRtcConnectionInitiatedAtMs || 0;
+	c.StopStreaming = opts.StopStreaming || (() => {});
+	return c;
+}
+
+test('hasWebRtcConnectionTimedOut returns false when no connection attempt', () => {
+	const c = makeStubClient();
+	assert.strictEqual(c.hasWebRtcConnectionTimedOut(), false);
+});
+
+test('hasWebRtcConnectionTimedOut returns false when already connected', () => {
+	const c = makeStubClient();
+	c.webRtcConnected = true;
+	c.webRtcConnectionInitiatedAtMs = Date.now() - 100000; // old time
+	assert.strictEqual(c.hasWebRtcConnectionTimedOut(), false);
+});
+
+test('hasWebRtcConnectionTimedOut returns false when under timeout', () => {
+	const c = makeStubClient({
+		webRtcConnectionInitiatedAtMs: Date.now() - 5000, // 5 seconds ago
+	});
+	c.webRtcConnected = false;
+	assert.strictEqual(c.hasWebRtcConnectionTimedOut(), false);
+});
+
+test('hasWebRtcConnectionTimedOut returns true when over timeout', async () => {
+	const c = makeStubClient({
+		webRtcConnectionInitiatedAtMs: Date.now() - 15000, // 15 seconds ago
+	});
+	c.webRtcConnected = false;
+	assert.strictEqual(c.hasWebRtcConnectionTimedOut(), true);
+});
+
+test('ClientManager.UpdateStreaming removes timed-out clients', async () => {
+	const cm = new ClientManager();
+	const clientsRemoved = [];
+
+	// Create two stub clients
+	const client1 = makeStubClient({ clientID: 1 });
+	const client2 = makeStubClient({
+		clientID: 2,
+		webRtcConnectionInitiatedAtMs: Date.now() - 15000, // Will timeout
+	});
+
+	client2.webRtcConnected = false;
+
+	cm.clients.set(1, client1);
+	cm.clients.set(2, client2);
+
+	// Mock the RemoveClient to track removals
+	const originalRemoveClient = cm.RemoveClient.bind(cm);
+	cm.RemoveClient = (clientID) => {
+		clientsRemoved.push(clientID);
+		originalRemoveClient(clientID);
+	};
+
+	cm.UpdateStreaming();
+
+	// Client 2 should have been removed due to timeout
+	assert.deepStrictEqual(clientsRemoved, [2]);
+	assert.strictEqual(cm.clients.has(1), true, 'Client 1 should still exist');
+	assert.strictEqual(cm.clients.has(2), false, 'Client 2 should be removed');
+});