feat(connection): Adds token refresh and cancel resume.

Author: damencho

JitsiConference.ts

@@ -4435,7 +4435,14 @@ export default class JitsiConference extends Listenable {
      */
     public joinLobby(displayName: string, email: string): Promise<void> {
         if (this.room) {
-            return this.room.getLobby().join(displayName, email);
+            if (!this.room.getLobby()?.lobbyRoom?.joined) {
+                return this.room.getLobby().join(displayName, email);
+            } else {
+                logger.warn('Already joined the lobby');
+
+                return Promise.resolve();
+            }
+
         }
 
         return Promise.reject(new Error('The conference not started'));

JitsiConnection.ts

@@ -156,8 +156,17 @@ export default class JitsiConnection {
      * This method allows renewal of the tokens if they are expiring.
      * @param token - The new token.
      */
-    setToken(token: string): void {
+    refreshToken(token: string): Promise<void> {
         this.token = token;
+
+        return this._xmpp.refreshToken(this.token);
+    }
+
+    /**
+     * Cancels the connection resume process if it is in progress.
+     */
+    cancelResume() {
+        this.xmpp.cancelResume();
     }
 
     /**

JitsiConnectionEvents.ts

@@ -40,6 +40,11 @@ export enum JitsiConnectionEvents {
      */
     CONNECTION_REDIRECTED = 'connection.redirected',
 
+    /**
+     * The connection will try to resume.
+     */
+    CONNECTION_RESUMING = 'connection.resuming',
+
     /**
      * Indicates that the display name is required over this connection and need to be supplied when
      * joining the room.
@@ -59,5 +64,6 @@ export const CONNECTION_DISCONNECTED = JitsiConnectionEvents.CONNECTION_DISCONNE
 export const CONNECTION_ESTABLISHED = JitsiConnectionEvents.CONNECTION_ESTABLISHED;
 export const CONNECTION_FAILED = JitsiConnectionEvents.CONNECTION_FAILED;
 export const CONNECTION_REDIRECTED = JitsiConnectionEvents.CONNECTION_REDIRECTED;
+export const CONNECTION_RESUMING = JitsiConnectionEvents.CONNECTION_RESUMING;
 export const DISPLAY_NAME_REQUIRED = JitsiConnectionEvents.DISPLAY_NAME_REQUIRED;
 export const PROPERTIES_UPDATED = JitsiConnectionEvents.PROPERTIES_UPDATED;

modules/xmpp/ResumeTask.ts

@@ -55,40 +55,64 @@ export default class ResumeTask {
     }
 
     /**
-     * Cancels the delayed resume task.
+     * Removes network online listener for the NETWORK_INFO_EVENT event.
      *
      * @private
      * @returns {void}
      */
-    private _cancelResume(): void {
+    private _removeNetworkOnlineListener(): void {
+        if (this._networkOnlineListener) {
+            this._networkOnlineListener();
+            this._networkOnlineListener = null;
+        }
+    }
+
+    /**
+     * Schedules a delayed timeout which will execute the resume action.
+     * @private
+     * @returns {void}
+     */
+    private _scheduleResume(): void {
         if (this._resumeTimeout) {
-            logger.info('Canceling connection resume task');
-            clearTimeout(this._resumeTimeout);
-            this._resumeTimeout = undefined;
-            this._retryDelay = undefined;
+            // NO-OP
+            return;
         }
+
+        // The retry delay will be:
+        //   1st retry: 1.5s - 3s
+        //   2nd retry: 3s - 9s
+        //   3rd and next retry: 4.5s - 27s
+        this._retryDelay = getJitterDelay(
+            /* retry */ this._resumeRetryN,
+            /* minDelay */ this._resumeRetryN * 1500,
+            3
+        );
+
+        logger.info(`Will try to resume the XMPP connection in ${this.retryDelay}ms`);
+
+        this._resumeTimeout = setTimeout(() => this.resumeConnection(), this.retryDelay);
     }
 
     /**
-     * Removes network online listener for the NETWORK_INFO_EVENT event.
+     * Cancels the delayed resume task.
      *
-     * @private
      * @returns {void}
      */
-    private _removeNetworkOnlineListener(): void {
-        if (this._networkOnlineListener) {
-            this._networkOnlineListener();
-            this._networkOnlineListener = null;
+    cancelResume(): void {
+        if (this._resumeTimeout) {
+            logger.info('Canceling connection resume task');
+            clearTimeout(this._resumeTimeout);
+            this._resumeTimeout = undefined;
+            this._retryDelay = undefined;
         }
     }
 
     /**
      * Resumes the XMPP connection using the stream management plugin.
      *
-     * @private
      * @returns {void}
      */
-    private _resumeConnection(): void {
+    resumeConnection(): void {
         this._resumeTimeout = undefined;
 
         const { streamManagement } = this._stropheConn;
@@ -126,40 +150,14 @@ export default class ResumeTask {
         }
     }
 
-    /**
-     * Schedules a delayed timeout which will execute the resume action.
-     * @private
-     * @returns {void}
-     */
-    private _scheduleResume(): void {
-        if (this._resumeTimeout) {
-            // NO-OP
-            return;
-        }
-
-        // The retry delay will be:
-        //   1st retry: 1.5s - 3s
-        //   2nd retry: 3s - 9s
-        //   3rd and next retry: 4.5s - 27s
-        this._retryDelay = getJitterDelay(
-            /* retry */ this._resumeRetryN,
-            /* minDelay */ this._resumeRetryN * 1500,
-            3
-        );
-
-        logger.info(`Will try to resume the XMPP connection in ${this.retryDelay}ms`);
-
-        this._resumeTimeout = setTimeout(() => this._resumeConnection(), this.retryDelay);
-    }
-
     /**
      * Cancels the retry task. It's called by {@link XmppConnection} when it's no longer interested in reconnecting for
      * example when the disconnect method is called.
      *
      * @returns {void}
      */
     cancel(): void {
-        this._cancelResume();
+        this.cancelResume();
         this._removeNetworkOnlineListener();
         this._resumeRetryN = 0;
     }
@@ -170,7 +168,7 @@ export default class ResumeTask {
      * @returns {void}
      */
     schedule(): void {
-        this._cancelResume();
+        this.cancelResume();
         this._removeNetworkOnlineListener();
 
         this._resumeRetryN += 1;
@@ -181,7 +179,7 @@ export default class ResumeTask {
                 if (isOnline) {
                     this._scheduleResume();
                 } else {
-                    this._cancelResume();
+                    this.cancelResume();
                 }
             }
         ) as () => void;

modules/xmpp/XmppConnection.ts

@@ -82,6 +82,15 @@ interface IInternalOptions {
     websocketKeepAliveUrl?: string;
 }
 
+const TOKEN_REFRESH = 'token_refresh';
+
+/**
+ * Adds one more status to Strophe.Status enum.
+ */
+enum ExtendedStatus {
+    RESUMING = 15
+}
+
 /**
  * The lib-jitsi-meet layer for {@link Strophe.Connection}.
  * @internal
@@ -128,7 +137,7 @@ export default class XmppConnection extends Listenable {
      * @returns {Strophe.Status}
      */
     static get Status() {
-        return Strophe.Status;
+        return { ...Strophe.Status, ...ExtendedStatus };
     }
 
     /**
@@ -395,8 +404,6 @@ export default class XmppConnection extends Listenable {
     _stropheConnectionCb(targetCallback: IConnectionStatusCallback, status: Strophe.Status, condition?: string, element?: Element): void {
         this._status = status;
 
-        let blockCallback = false;
-
         if (status === Strophe.Status.CONNECTED || status === Strophe.Status.ATTACHED) {
             this._maybeEnableStreamResume();
 
@@ -421,17 +428,24 @@ export default class XmppConnection extends Listenable {
         } else if (status === Strophe.Status.DISCONNECTED) {
             this.ping.stopInterval();
 
-            // FIXME add RECONNECTING state instead of blocking the DISCONNECTED update
-            blockCallback = this._tryResumingConnection();
-            if (!blockCallback) {
-                clearTimeout(this._wsKeepAlive);
+            // if resumption is scheduled skip disconnecting state event fire
+            if (this._tryResumingConnection(condition === TOKEN_REFRESH)) {
+
+                if (condition !== TOKEN_REFRESH) {
+                    // let's fire event that status changed to resuming
+                    // we do not fire it on refresh, as consumers should get
+                    // the event and execute refresh with a new token
+                    this.eventEmitter.emit(XmppConnection.Events.CONN_STATUS_CHANGED, ExtendedStatus.RESUMING);
+                }
+
+                return;
             }
-        }
 
-        if (!blockCallback) {
-            targetCallback(status, condition, element);
-            this.eventEmitter.emit(XmppConnection.Events.CONN_STATUS_CHANGED, status);
+            clearTimeout(this._wsKeepAlive);
         }
+
+        targetCallback(status, condition, element);
+        this.eventEmitter.emit(XmppConnection.Events.CONN_STATUS_CHANGED, status);
     }
 
     /**
@@ -758,14 +772,22 @@ export default class XmppConnection extends Listenable {
      * the token is present it means the connection can be resumed.
      *
      * @private
-     * @returns {boolean}
+     * @returns {boolean} - Whether a resume attempt was scheduled or executed.
      */
-    _tryResumingConnection(): boolean {
+    _tryResumingConnection(force = false): boolean {
         const { streamManagement } = this._stropheConn;
         const resumeToken = streamManagement?.getResumeToken();
 
         if (resumeToken) {
-            this._resumeTask.schedule();
+            if (force) {
+                logger.info('Trying to resume XMPP connection immediately due to token refresh');
+
+                this._resumeTask.resumeConnection();
+
+                return true;
+            } else {
+                this._resumeTask.schedule();
+            }
 
             const r = this._resumeTask.retryCount <= MAX_CONNECTION_RETRIES;
 
@@ -778,4 +800,34 @@ export default class XmppConnection extends Listenable {
 
         return false;
     }
+
+    /**
+     * This method allows renewal of the tokens if they are expiring.
+     * @param token - The new token.
+     */
+    refreshToken(serviceUrl: string): Promise<void> {
+        this._stropheConn.service = serviceUrl;
+
+        // this will trigger a resume
+        this._stropheConn._doDisconnect(TOKEN_REFRESH);
+
+        return new Promise((resolve, reject) => {
+            const handler = status => {
+                if (status === Strophe.Status.CONNECTED && this._stropheConn.restored) {
+                    resolve();
+                }
+            };
+
+            this.addCancellableListener(XmppConnection.Events.CONN_STATUS_CHANGED, handler);
+
+            setTimeout(() => {
+                this.removeListener(XmppConnection.Events.CONN_STATUS_CHANGED, handler);
+                reject();
+            }, 3000);
+        });
+    }
+
+    cancelResume() {
+        this._resumeTask.cancelResume();
+    }
 }

modules/xmpp/xmpp.ts

@@ -368,6 +368,12 @@ export default class XMPP extends Listenable {
             }
         });
 
+        this.connection.on(XmppConnection.Events.CONN_STATUS_CHANGED, status => {
+            if (status === XmppConnection.Status.RESUMING) {
+                this.eventEmitter.emit(JitsiConnectionEvents.CONNECTION_RESUMING);
+            }
+        });
+
         this._initStrophePlugins();
 
         this.caps = new Caps(this.connection, /* clientNode */ 'https://jitsi.org/jitsi-meet');
@@ -1334,4 +1340,20 @@ export default class XMPP extends Listenable {
 
         return false;
     }
+
+    /**
+     * This method allows renewal of the tokens if they are expiring.
+     * @param token - The new token.
+     */
+    refreshToken(token: string): Promise<void> {
+        let serviceUrl = this.options.serviceUrl;
+
+        serviceUrl += `${serviceUrl.indexOf('?') === -1 ? '?' : '&'}token=${token}`;
+
+        return this.connection.refreshToken(serviceUrl);
+    }
+
+    cancelResume() {
+        this.connection.cancelResume();
+    }
 }