Fix using signaling settings while being refetched

When the external signaling server returns the error "token_expired" the
signaling settings are fetched again. However, if there are further
requests and "token_expired" is returned again the previous fetch is
canceled and a new one started instead, which caused the settings to be
temporary set to "null". The signaling settings are expected to always
be an object, so setting them to "null" could cause an error if they
were used during that time (for example, during a reconnection, which
caused the signaling object to "hang" and not do any further connection
attempt).

Preventing the settings to be nullified is only half of the story,
though; "token_expired" can be thrown when trying to connect, and errors
thrown when trying to connect cause a reconnection attempt. This could
end in a reconnection loop, as each "token_expired" error would
cause another fetch of the settings, cancelling the previous fetch and
thus preventing the settings to be updated, and as the previous settings
would be still used any connection attempt would end again in another
"token_expired" error.

To solve all that now any connection attempt done after receiving a
"token_expired" error is deferred until the signaling settings were
updated.

Note that the previous signaling settings are kept to ensure that a
signaling object is always available, even if outdated. However, any
usage of the outdated signaling settings is expected to cause a
"token_expired" error to be thrown; right now that only happens during
connections, so only that code needs to wait for the settings to be
fetched again.

Signed-off-by: Daniel Calviño Sánchez <[email protected]>

Author: danxuliu

src/utils/signaling.js

@@ -141,6 +141,20 @@ Signaling.Base.prototype._trigger = function(ev, args) {
 	EventBus.$emit('signaling-' + kebabCase(ev), args)
 }
 
+Signaling.Base.prototype.setSettings = function(settings) {
+	if (!settings) {
+		// Signaling object is expected to always have a settings object
+		return
+	}
+
+	this.settings = settings
+
+	if (this._pendingUpdateSettingsPromise) {
+		this._pendingUpdateSettingsPromise.resolve()
+		delete this._pendingUpdateSettingsPromise
+	}
+}
+
 Signaling.Base.prototype.isNoMcuWarningEnabled = function() {
 	return !this.settings.hideWarning
 }
@@ -654,6 +668,19 @@ Signaling.Standalone.prototype.connect = function() {
 		}, 2000)
 	}
 
+	if (this._pendingUpdateSettingsPromise) {
+		console.info('Deferring establishing signaling connection until signaling settings are updated')
+
+		this._pendingUpdateSettingsPromise.then(() => {
+			// "reconnect()" is called instead of "connect()", even if that
+			// slightly delays the connection, as "reconnect()" prevents
+			// duplicated connection requests.
+			this.reconnect()
+		})
+
+		return
+	}
+
 	console.debug('Connecting to ' + this.url + ' for ' + this.settings.token)
 	this.callbacks = {}
 	this.id = 1
@@ -1423,6 +1450,17 @@ Signaling.Standalone.prototype.processRoomParticipantsEvent = function(data) {
 Signaling.Standalone.prototype.processErrorTokenExpired = function() {
 	console.info('The signaling token is expired, need to update settings')
 
+	if (!this._pendingUpdateSettingsPromise) {
+		let pendingUpdateSettingsPromiseResolve
+		this._pendingUpdateSettingsPromise = new Promise((resolve, reject) => {
+			// The Promise executor is run even before the Promise constructor has
+			// finished, so "this._pendingUpdateSettingsPromise" is not available
+			// yet.
+			pendingUpdateSettingsPromiseResolve = resolve
+		})
+		this._pendingUpdateSettingsPromise.resolve = pendingUpdateSettingsPromiseResolve
+	}
+
 	this._trigger('updateSettings')
 }
 

src/utils/webrtc/index.js

@@ -134,7 +134,7 @@ async function connectSignaling(token) {
 		signaling.on('updateSettings', async function() {
 			const settings = await getSignalingSettings(token)
 			console.debug('Received updated settings', settings)
-			signaling.settings = settings
+			signaling.setSettings(settings)
 		})
 
 		signalingTypingHandler?.setSignaling(signaling)