teleportxr 1.0.55 → 1.0.57

package/client/client.js

@@ -73,19 +73,29 @@ class Client {
         console.log("[T+"+this.elapsedMsSinceStart()+"ms] Connection state is "+newState.toString());
 		if(newState=="connected")
 		{
-       		//this.webRtcConnection.sendGeometry("test");
 			this.webRtcConnected=true;
 			this.webRtcConnectedAtMs=Date.now();
-			console.log("[T+"+this.elapsedMsSinceStart()+"ms] WebRTC CONNECTED for client "+this.clientID+" — triggering immediate UpdateStreaming tick.");
-			// Kick an immediate tick so SetOriginNode and the first resource batch are
-			// sent without waiting for the next periodic interval (up to 1000 ms away).
-			setImmediate(this.UpdateStreaming.bind(this));
+			console.log("[T+"+this.elapsedMsSinceStart()+"ms] WebRTC CONNECTED for client "+this.clientID+" — awaiting data channels.");
+			// Do NOT call UpdateStreaming() here. The PeerConnection reaching
+			// 'connected' does not guarantee that the geometry/reliable data
+			// channels are in 'open' state yet; sends issued now will throw
+			// InvalidStateError. Instead, UpdateStreaming is triggered from the
+			// dataChannelsOpen callback registered in StartStreaming().
 		}
 		else
 		{
 			this.webRtcConnected=false;
 		}
     }
+	// Invoked once per WebRTC connection, the moment both reliable and geometry
+	// data channels are simultaneously in 'open' state. Kicks an immediate
+	// streaming tick so the first node/resource batch goes out without waiting
+	// for the next periodic interval (up to 1000 ms away).
+	onDataChannelsOpen()
+	{
+		console.log("[T+"+this.elapsedMsSinceStart()+"ms, conn+"+this.elapsedMsSinceConnected()+"ms] data channels open for client "+this.clientID+" — triggering immediate UpdateStreaming tick.");
+		setImmediate(this.UpdateStreaming.bind(this));
+	}
 	receivedMessageReliable(id,pkt)
 	{
         var dataView=new DataView(pkt.data,0,1);
@@ -246,7 +256,8 @@ class Client {
 										this.clientID
 										,this.streamingConnectionStateChanged.bind(this)
 										,this.receivedMessageReliable.bind(this)
-										,this.receivedMessageUnreliable.bind(this));
+										,this.receivedMessageUnreliable.bind(this)
+										,this.onDataChannelsOpen.bind(this));
 		//.then(
 		//	function(value) {myDisplayer(value);},
 		//	function(error) {myDisplayer(error);}
@@ -486,21 +497,21 @@ class Client {
 		const MAX_NODE_SIZE=500;
 		const buffer = new ArrayBuffer(MAX_NODE_SIZE);
 		const nodeSize=node_encoder.encodeNode(node,buffer);
-		this.geometryService.EncodedResource(uid);
-		const view2 = new DataView(buffer, 0, nodeSize); 
-		console.log("Sending node "+uid+" "+node.name+" to Client "+this.clientID+", size: "+nodeSize+" bytes");
+		const view2 = new DataView(buffer, 0, nodeSize);
 		if(!this.webRtcConnection)
 		{
 			console.error("this.webRtcConnection is null");
 			return;
 		}
-		if(!this.webRtcConnection.sendGeometry)
+		if(!this.webRtcConnection.isGeometryOpen())
 		{
-			console.error("this.webRtcConnection.sendGeometry is null");
-			console.log(JSON.stringify(this.webRtcConnection));
+			// Channel not yet open; leave the resource unmarked so it retries on
+			// the next UpdateStreaming tick without waiting for the timeout.
 			return;
 		}
-		this.webRtcConnection.sendGeometry(view2);
+		console.log("Sending node "+uid+" "+node.name+" to Client "+this.clientID+", size: "+nodeSize+" bytes");
+		if(this.webRtcConnection.sendGeometry(view2))
+			this.geometryService.EncodedResource(uid);
 	}
 	SendGenericResource(uid)
 	{
@@ -513,21 +524,21 @@ class Client {
 		const MAX_BUFFER_SIZE=resource.encodedSize();;
 		const buffer = new ArrayBuffer(MAX_BUFFER_SIZE);
 		const resourceSize=resource_encoder.EncodeResource(resource,buffer);
-		this.geometryService.EncodedResource(uid);
 		const view2 = new DataView(buffer, 0, resourceSize);
-		console.log("Sending resource "+uid+" "+resource.url+" to Client "+this.clientID+", size: "+resourceSize+" bytes");
 		if(!this.webRtcConnection)
 		{
 			console.error("this.webRtcConnection is null");
 			return;
 		}
-		if(!this.webRtcConnection.sendGeometry)
+		if(!this.webRtcConnection.isGeometryOpen())
 		{
-			console.error("this.webRtcConnection.sendGeometry is null");
-			console.log(JSON.stringify(this.webRtcConnection));
+			// Channel not yet open; leave the resource unmarked so it retries on
+			// the next UpdateStreaming tick without waiting for the timeout.
 			return;
 		}
-		this.webRtcConnection.sendGeometry(view2);
+		console.log("Sending resource "+uid+" "+resource.url+" to Client "+this.clientID+", size: "+resourceSize+" bytes");
+		if(this.webRtcConnection.sendGeometry(view2))
+			this.geometryService.EncodedResource(uid);
 	}
 	SendMesh(uid)
 	{
@@ -571,10 +582,13 @@ class Client {
 				offset+=core.UID_SIZE;
 			}
 		}
+		// Kick WebRTC negotiation off first so the createOffer / setLocalDescription
+		// / ICE gathering pipeline overlaps the signaling round-trip for the ack
+		// below. The C++ client buffers offers and candidates that arrive while
+		// it is still processing the ack, so ordering is safe.
+		this.StartStreaming();
         var acknowledgeHandshakeCommand=new command.AcknowledgeHandshakeCommand;
         this.SendCommand(acknowledgeHandshakeCommand);
-		// And now, setup is complete. On the next geometry update, we can send nodes/resources.
-		this.StartStreaming();
     }
     receiveReliableBinaryMessage(data){
         const messageType=data[0];

package/connections/webrtcconnection.js

@@ -56,7 +56,9 @@ class WebRtcConnection extends EventEmitter
 		this.messageReceivedReliableCb		=options.messageReceivedReliable;
 		this.messageReceivedUnreliableCb	=options.messageReceivedUnreliable;
 		this.connectionStateChangedCb=options.connectionStateChanged;
+		this.dataChannelsOpenCb		=options.dataChannelsOpen;
 		this.sendConfigMessage		=options.sendConfigMessage;
+		this._dataChannelsOpenFired	=false;
 
 		this._onIceConnectionStateChange = this.onIceConnectionStateChange.bind(this);
 		this._onIceGatheringStateChange  = this.onIceGatheringStateChange.bind(this);
@@ -348,25 +350,58 @@ class WebRtcConnection extends EventEmitter
 		this.state = 'closed';
 		this.emit('closed');
 	};
-    sendGeometry(buffer) {
+	isGeometryOpen() {
+		return !!(this.geometryDataChannel && this.geometryDataChannel.readyState === 'open');
+	}
+	isReliableOpen() {
+		return !!(this.reliableDataChannel && this.reliableDataChannel.readyState === 'open');
+	}
+	// Invoked from each data channel's onopen. Fires the dataChannelsOpen callback
+	// exactly once per PeerConnection, the moment both reliable and geometry
+	// channels are in 'open' state. This lets Client.UpdateStreaming run as soon
+	// as the channels can accept traffic rather than waiting for the next
+	// periodic tick (up to 1 s away).
+	_handleDataChannelOpen(label) {
+		if (this._dataChannelsOpenFired)
+			return;
+		if (!this.isGeometryOpen() || !this.isReliableOpen())
+			return;
+		this._dataChannelsOpenFired = true;
+		if (this.dataChannelsOpenCb)
+		{
+			try { this.dataChannelsOpenCb(); }
+			catch (e) { console.error('dataChannelsOpenCb threw: '+e.message); }
+		}
+	}
+	// Returns true if the buffer was handed to the underlying transport, false if the
+	// channel was not in the 'open' state or send() threw. Callers must use the
+	// return value to gate any "this resource has been transmitted" bookkeeping;
+	// otherwise a dropped send leaves the resource marked Sent and it won't be
+	// retried until geometry_service.timeout_us elapses (default 10 s).
+	sendGeometry(buffer) {
+		if (!this.isGeometryOpen())
+			return false;
 		try {
-        	this.geometryDataChannel.send(buffer);
+			this.geometryDataChannel.send(buffer);
+			return true;
 		}
 		catch(exception) {
-            console.error('datachannel.sendGeometry exception: '+exception.message);
+			console.error('datachannel.sendGeometry exception: '+exception.message);
+			return false;
 		}
-    }
-	isReliableOpen() {
-		return !!(this.reliableDataChannel && this.reliableDataChannel.readyState === 'open');
 	}
-    sendReliable(buffer) {
+	sendReliable(buffer) {
+		if (!this.isReliableOpen())
+			return false;
 		try {
 			this.reliableDataChannel.send(buffer);
+			return true;
 		}
 		catch(exception) {
-            console.error('datachannel.sendReliable exception: '+exception.message);
+			console.error('datachannel.sendReliable exception: '+exception.message);
+			return false;
 		}
-    }
+	}
     beforeOffer() {
           
         this.videoDataChannel = this.createDataChannel("video",20);
@@ -425,6 +460,7 @@ class WebRtcConnection extends EventEmitter
   
           dc.onopen = (event) => {
             console.log('datachannel '+label+' open');
+            this._handleDataChannelOpen(label);
            //dc.send('XXXX');
         };
   

package/connections/webrtcconnectionmanager.js

@@ -37,7 +37,7 @@ class WebRtcConnectionManager
 		this.deleteConnection(connection);
 	}
 
-	createConnection(clientID,connectionStateChangedCb,messageReceivedReliableCb,messageReceivedUnreliableCb)
+	createConnection(clientID,connectionStateChangedCb,messageReceivedReliableCb,messageReceivedUnreliableCb,dataChannelsOpenCb)
 	{
 		const existing = this.connections.get(clientID);
 		if (existing)
@@ -52,6 +52,7 @@ class WebRtcConnectionManager
 		options.messageReceivedReliable		=messageReceivedReliableCb;
 		options.messageReceivedUnreliable	=messageReceivedUnreliableCb;
 		options.connectionStateChanged		=connectionStateChangedCb;
+		options.dataChannelsOpen			=dataChannelsOpenCb;
         const connection = new WebRtcConnection(clientID,options);
         //  We will not add a "closed" listener, because only the client object will be permitted to close its connection.
 		//this.createConnection = (clientID) => this.closedListeners.set(connection, this.closedListener);

package/package.json

@@ -11,11 +11,12 @@
     "ws": "^8.13.0"
   },
   "scripts": {
-    "start": "node server.js"
+    "start": "node server.js",
+    "test": "node --test test/"
   },
   "name": "teleportxr",
   "description": "Teleport Spatial Server on node.js",
-  "version": "1.0.55",
+  "version": "1.0.57",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/simul/teleport-nodejs.git"

package/test/test_client_send_node_gate.js

@@ -0,0 +1,129 @@
+'use strict';
+// Regression tests for Client.SendNode / Client.SendGenericResource. Before the
+// fix, EncodedResource(uid) was called unconditionally before sendGeometry, so
+// a failed send still marked the resource as transmitted and the
+// geometry_service refused to retry it until its 10 s timeout elapsed.
+
+const test = require('node:test');
+const assert = require('node:assert');
+const { Client } = require('../client/client');
+const resources = require('../scene/resources');
+
+function makeStubClient(opts) {
+	const c = Object.create(Client.prototype);
+	c.clientID = 7;
+	c.scene = {
+		GetNode: () => ({
+			name: 'stub-node',
+			encodeIntoDataView: (_dv, off) => off + 1,
+		}),
+	};
+	c.geometryService = {
+		EncodedResource: (uid) => { c._encodedCalls.push(uid); },
+	};
+	c._encodedCalls = [];
+	c.webRtcConnection = opts.webRtcConnection;
+	return c;
+}
+
+test('SendNode does not mark resource encoded when geometry channel is not open', () => {
+	const c = makeStubClient({
+		webRtcConnection: {
+			isGeometryOpen: () => false,
+			sendGeometry: () => { throw new Error('sendGeometry must not be called when not open'); },
+		},
+	});
+	c.SendNode(42n);
+	assert.strictEqual(c._encodedCalls.length, 0);
+});
+
+test('SendNode marks resource encoded when sendGeometry returns true', () => {
+	const c = makeStubClient({
+		webRtcConnection: {
+			isGeometryOpen: () => true,
+			sendGeometry: () => true,
+		},
+	});
+	c.SendNode(42n);
+	assert.deepStrictEqual(c._encodedCalls, [42n]);
+});
+
+test('SendNode does not mark resource encoded when sendGeometry returns false', () => {
+	// Simulates the race where the channel was "open" at the isGeometryOpen()
+	// check but transitioned to closing/closed before send() ran (or wrtc
+	// returned false synchronously). The resource must remain unmarked so the
+	// next UpdateStreaming tick re-attempts it.
+	const c = makeStubClient({
+		webRtcConnection: {
+			isGeometryOpen: () => true,
+			sendGeometry: () => false,
+		},
+	});
+	c.SendNode(42n);
+	assert.strictEqual(c._encodedCalls.length, 0);
+});
+
+test('SendNode short-circuits when webRtcConnection is null', () => {
+	const c = makeStubClient({ webRtcConnection: null });
+	// Must not throw; must not record an encoded resource.
+	c.SendNode(42n);
+	assert.strictEqual(c._encodedCalls.length, 0);
+});
+
+// SendGenericResource shares the same gating shape. Build a minimal Resource so
+// the encoder doesn't blow up.
+class StubResource {
+	constructor() {
+		this.url = 'stub://resource';
+		this.uid = 99n;
+	}
+	encodedSize() { return 64; }
+	encodeIntoDataView(_dv, off) { return off + 1; }
+}
+
+test('SendGenericResource does not mark resource encoded when channel is not open', () => {
+	const stub = new StubResource();
+	const originalGet = resources.GetResourceFromUid;
+	resources.GetResourceFromUid = () => stub;
+	try {
+		const c = makeStubClient({
+			webRtcConnection: {
+				isGeometryOpen: () => false,
+				sendGeometry: () => { throw new Error('must not be called'); },
+			},
+		});
+		c.SendGenericResource(99n);
+		assert.strictEqual(c._encodedCalls.length, 0);
+	}
+	finally {
+		resources.GetResourceFromUid = originalGet;
+	}
+});
+
+test('SendGenericResource marks resource encoded only after a successful send', () => {
+	const stub = new StubResource();
+	const originalGet = resources.GetResourceFromUid;
+	resources.GetResourceFromUid = () => stub;
+	try {
+		const c = makeStubClient({
+			webRtcConnection: {
+				isGeometryOpen: () => true,
+				sendGeometry: () => true,
+			},
+		});
+		c.SendGenericResource(99n);
+		assert.deepStrictEqual(c._encodedCalls, [99n]);
+
+		const c2 = makeStubClient({
+			webRtcConnection: {
+				isGeometryOpen: () => true,
+				sendGeometry: () => false,
+			},
+		});
+		c2.SendGenericResource(99n);
+		assert.strictEqual(c2._encodedCalls.length, 0);
+	}
+	finally {
+		resources.GetResourceFromUid = originalGet;
+	}
+});

package/test/test_data_channels_open_callback.js

@@ -0,0 +1,69 @@
+'use strict';
+// Regression tests for _handleDataChannelOpen. After both reliable and geometry
+// data channels are simultaneously in 'open' state, the dataChannelsOpenCb must
+// fire exactly once for the lifetime of the PeerConnection — additional channel
+// opens (e.g. the unreliable channel) must not retrigger it.
+
+const test = require('node:test');
+const assert = require('node:assert');
+const WebRtcConnection = require('../connections/webrtcconnection');
+
+function makeCtx() {
+	const ctx = Object.create(WebRtcConnection.prototype);
+	ctx._dataChannelsOpenFired = false;
+	return ctx;
+}
+
+test('callback fires once when both required channels reach "open"', () => {
+	let calls = 0;
+	const ctx = makeCtx();
+	ctx.dataChannelsOpenCb = () => { calls++; };
+	ctx.geometryDataChannel = { readyState: 'connecting' };
+	ctx.reliableDataChannel = { readyState: 'connecting' };
+
+	// First channel opens — callback must not fire yet.
+	ctx.geometryDataChannel.readyState = 'open';
+	ctx._handleDataChannelOpen('geometry_unframed');
+	assert.strictEqual(calls, 0, 'callback fired with only geometry open');
+
+	// Second channel opens — callback fires.
+	ctx.reliableDataChannel.readyState = 'open';
+	ctx._handleDataChannelOpen('reliable');
+	assert.strictEqual(calls, 1, 'callback did not fire when both channels open');
+
+	// Later channels opening must not retrigger.
+	ctx._handleDataChannelOpen('unreliable');
+	ctx._handleDataChannelOpen('video');
+	assert.strictEqual(calls, 1, 'callback fired a second time on later channel open');
+});
+
+test('callback never fires while only one of the required channels is open', () => {
+	let calls = 0;
+	const ctx = makeCtx();
+	ctx.dataChannelsOpenCb = () => { calls++; };
+	ctx.geometryDataChannel = { readyState: 'open' };
+	ctx.reliableDataChannel = { readyState: 'connecting' };
+
+	ctx._handleDataChannelOpen('geometry_unframed');
+	ctx._handleDataChannelOpen('video');
+	assert.strictEqual(calls, 0);
+});
+
+test('absent dataChannelsOpenCb does not throw when both channels open', () => {
+	const ctx = makeCtx();
+	ctx.geometryDataChannel = { readyState: 'open' };
+	ctx.reliableDataChannel = { readyState: 'open' };
+	// Must not throw.
+	ctx._handleDataChannelOpen('reliable');
+	assert.strictEqual(ctx._dataChannelsOpenFired, true);
+});
+
+test('callback that throws is caught and the fired flag remains set', () => {
+	const ctx = makeCtx();
+	ctx.dataChannelsOpenCb = () => { throw new Error('handler boom'); };
+	ctx.geometryDataChannel = { readyState: 'open' };
+	ctx.reliableDataChannel = { readyState: 'open' };
+	// Must not propagate the error to the caller.
+	ctx._handleDataChannelOpen('reliable');
+	assert.strictEqual(ctx._dataChannelsOpenFired, true);
+});

package/test/test_webrtcconnection_send_gate.js

@@ -0,0 +1,90 @@
+'use strict';
+// Regression tests for the send-gating behaviour added to WebRtcConnection.
+// Before the fix, sendGeometry/sendReliable swallowed InvalidStateError when
+// the data channel's readyState was still 'connecting' but returned no signal
+// to the caller, so client.js was free to mark resources as transmitted even
+// though nothing had been written. The geometry_service then refused to retry
+// them until its 10 s timeout elapsed.
+//
+// These tests don't construct a real RTCPeerConnection; they invoke the
+// methods on a stub object that inherits from WebRtcConnection.prototype.
+
+const test = require('node:test');
+const assert = require('node:assert');
+const WebRtcConnection = require('../connections/webrtcconnection');
+
+function makeCtx() {
+	return Object.create(WebRtcConnection.prototype);
+}
+
+test('sendGeometry returns false and does not call dc.send when channel is connecting', () => {
+	let sendCalls = 0;
+	const ctx = makeCtx();
+	ctx.geometryDataChannel = {
+		readyState: 'connecting',
+		send: () => { sendCalls++; },
+	};
+	const result = ctx.sendGeometry(new Uint8Array([1, 2, 3]));
+	assert.strictEqual(result, false);
+	assert.strictEqual(sendCalls, 0, 'send() must not be called while readyState is "connecting"');
+});
+
+test('sendGeometry returns false when geometryDataChannel is missing entirely', () => {
+	const ctx = makeCtx();
+	assert.strictEqual(ctx.sendGeometry(new Uint8Array([1])), false);
+});
+
+test('sendGeometry returns true when channel is open and forwards the buffer', () => {
+	let captured = null;
+	const ctx = makeCtx();
+	ctx.geometryDataChannel = {
+		readyState: 'open',
+		send: (b) => { captured = b; },
+	};
+	const buf = new Uint8Array([4, 5, 6]);
+	assert.strictEqual(ctx.sendGeometry(buf), true);
+	assert.strictEqual(captured, buf);
+});
+
+test('sendGeometry returns false when an open channel throws inside send()', () => {
+	const ctx = makeCtx();
+	ctx.geometryDataChannel = {
+		readyState: 'open',
+		send: () => { throw new Error('simulated wrtc failure'); },
+	};
+	assert.strictEqual(ctx.sendGeometry(new Uint8Array([1])), false);
+});
+
+test('sendReliable returns false and does not call dc.send when channel is connecting', () => {
+	let sendCalls = 0;
+	const ctx = makeCtx();
+	ctx.reliableDataChannel = {
+		readyState: 'connecting',
+		send: () => { sendCalls++; },
+	};
+	assert.strictEqual(ctx.sendReliable(new Uint8Array([1])), false);
+	assert.strictEqual(sendCalls, 0);
+});
+
+test('sendReliable returns true when channel is open and forwards the buffer', () => {
+	let captured = null;
+	const ctx = makeCtx();
+	ctx.reliableDataChannel = {
+		readyState: 'open',
+		send: (b) => { captured = b; },
+	};
+	const buf = new Uint8Array([7, 8, 9]);
+	assert.strictEqual(ctx.sendReliable(buf), true);
+	assert.strictEqual(captured, buf);
+});
+
+test('isGeometryOpen reports true only when readyState equals "open"', () => {
+	const ctx = makeCtx();
+	assert.strictEqual(ctx.isGeometryOpen(), false, 'no channel');
+	ctx.geometryDataChannel = { readyState: 'connecting' };
+	assert.strictEqual(ctx.isGeometryOpen(), false, 'connecting');
+	ctx.geometryDataChannel.readyState = 'open';
+	assert.strictEqual(ctx.isGeometryOpen(), true, 'open');
+	ctx.geometryDataChannel.readyState = 'closing';
+	assert.strictEqual(ctx.isGeometryOpen(), false, 'closing');
+});