feat(xmpp): resume the connection when online

The XmppConnection will try to resume the connection
only when the internet is online. This speeds up the process
by avoiding unnecessary connect attempts while offline as each
failed attempt increases the backoff delay.

modules/xmpp/ResumeTask.js

@@ -0,0 +1,152 @@
+import { getLogger } from 'jitsi-meet-logger';
+
+import {
+    default as NetworkInfo,
+    NETWORK_INFO_EVENT
+} from '../connectivity/NetworkInfo';
+import { getJitterDelay } from '../util/Retry';
+
+const logger = getLogger(__filename);
+
+/**
+ * The class contains the logic for triggering connection resume via XEP-0198 stream management.
+ * It does two things, the first one is it tracks the internet online/offline status and it makes sure that
+ * the reconnect is attempted only while online. The seconds thing is that it tracks the retry attempts and extends
+ * the retry interval using the full jitter pattern.
+ */
+export default class ResumeTask {
+    /**
+     * Initializes new {@code RetryTask}.
+     * @param {Strophe.Connection} stropheConnection - The Strophe connection instance.
+     */
+    constructor(stropheConnection) {
+        this._stropheConn = stropheConnection;
+
+        /**
+         * The counter increased before each resume retry attempt, used to calculate exponential backoff.
+         * @type {number}
+         * @private
+         */
+        this._resumeRetryN = 0;
+
+        this._retryDelay = undefined;
+    }
+
+    /**
+     * @returns {number|undefined} - How much the app will wait before trying to resume the XMPP connection. When
+     * 'undefined' it means that no resume task was not scheduled.
+     */
+    get retryDelay() {
+        return this._retryDelay;
+    }
+
+    /**
+     * Called by {@link XmppConnection} when the connection drops and it's a signal it wants to schedule a reconnect.
+     *
+     * @returns {void}
+     */
+    schedule() {
+        this._cancelResume();
+
+        this._resumeRetryN += 1;
+
+        this._networkOnlineListener
+            = NetworkInfo.addEventListener(
+                NETWORK_INFO_EVENT,
+                ({ isOnline }) => {
+                    if (isOnline) {
+                        this._scheduleResume();
+                    } else {
+                        this._cancelResume();
+                    }
+                });
+
+        NetworkInfo.isOnline() && this._scheduleResume();
+    }
+
+    /**
+     * Schedules a delayed timeout which will execute the resume action.
+     * @private
+     * @returns {void}
+     */
+    _scheduleResume() {
+        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._resumeRetryN = Math.min(3, this._resumeRetryN);
+        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 delayed resume task.
+     *
+     * @private
+     * @returns {void}
+     */
+    _cancelResume() {
+        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}
+     */
+    _resumeConnection() {
+        const { streamManagement } = this._stropheConn;
+        const resumeToken = streamManagement.getResumeToken();
+
+        // Things may have changed since when the task was scheduled
+        if (!resumeToken) {
+            return;
+        }
+
+        logger.info('Trying to resume the XMPP connection');
+
+        const url = new URL(this._stropheConn.service);
+        let { search } = url;
+
+        search += search.indexOf('?') === -1 ? `?previd=${resumeToken}` : `&previd=${resumeToken}`;
+
+        url.search = search;
+
+        this._stropheConn.service = url.toString();
+
+        streamManagement.resume();
+    }
+
+    /**
+     * 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() {
+        this._cancelResume();
+        this._resumeRetryN = 0;
+        if (this._networkOnlineListener) {
+            this._networkOnlineListener();
+            this._networkOnlineListener = null;
+        }
+    }
+}

modules/xmpp/ResumeTask.spec.js

@@ -0,0 +1,144 @@
+import networkInfo, { default as NetworkInfo } from '../connectivity/NetworkInfo';
+import { nextTick } from '../util/TestUtils';
+
+import ResumeTask from './ResumeTask';
+
+/**
+ * A mock of the stream management plugin.
+ */
+class MockStreamManagement {
+    /**
+     * @return {string}
+     */
+    getResumeToken() {
+        return '1234';
+    }
+
+    /**
+     * @returns {void}
+     */
+    // eslint-disable-next-line no-empty-function,require-jsdoc
+    resume() {
+
+    }
+}
+
+/**
+ * A minimal set of Strophe.Connection class required by the {@link ResumeTask}.
+ */
+class MockStropheConection {
+    /**
+     * A constructor.
+     */
+    constructor() {
+        this.streamManagement = new MockStreamManagement();
+        this.service = 'wss://something.com/xmpp-websocket';
+    }
+}
+
+describe('ResumeTask', () => {
+    let connection, resumeTask;
+
+    beforeEach(() => {
+        NetworkInfo.updateNetworkInfo({ isOnline: true });
+
+        connection = new MockStropheConection();
+        resumeTask = new ResumeTask(connection);
+
+        jasmine.clock().install();
+    });
+    afterEach(() => {
+        jasmine.clock().uninstall();
+
+        // Need to unregister the listener added to the networkInfo global
+        resumeTask.cancel();
+    });
+    describe('the retry task', () => {
+        it('should be scheduled immediately if the internet is online', () => {
+            const retrySpy = spyOn(connection.streamManagement, 'resume');
+
+            resumeTask.schedule();
+
+            expect(resumeTask.retryDelay).not.toBe(undefined);
+
+            return nextTick(resumeTask.retryDelay + 10).then(() => {
+                expect(retrySpy).toHaveBeenCalled();
+            });
+        });
+        it('should be scheduled when the internet comes back online', () => {
+            NetworkInfo.updateNetworkInfo({ isOnline: false });
+
+            resumeTask.schedule();
+
+            expect(resumeTask.retryDelay).toBe(undefined);
+
+            NetworkInfo.updateNetworkInfo({ isOnline: true });
+
+            expect(resumeTask.retryDelay).not.toBe(undefined);
+        });
+        it('should not execute first scheduled and then canceled', () => {
+            const retrySpy = spyOn(connection.streamManagement, 'resume');
+
+            resumeTask.schedule();
+
+            const retryDelay = resumeTask.retryDelay;
+
+            resumeTask.cancel();
+
+            return nextTick(retryDelay + 10).then(() => {
+                expect(retrySpy).not.toHaveBeenCalled();
+            });
+        });
+        it('should be rescheduled if internet goes offline/online', () => {
+            resumeTask.schedule();
+
+            expect(resumeTask.retryDelay).not.toBe(undefined);
+
+            NetworkInfo.updateNetworkInfo({ isOnline: false });
+
+            expect(resumeTask.retryDelay).toBe(undefined);
+
+            NetworkInfo.updateNetworkInfo({ isOnline: true });
+
+            expect(resumeTask.retryDelay).not.toBe(undefined);
+        });
+    });
+    describe('the retryDelay', () => {
+        const between1and3seconds = delay => delay >= 1000 && delay <= 3000;
+        const between3and9seconds = delay => delay >= 3000 && delay <= 9000;
+        const between4500msAnd27seconds = delay => delay >= 4500 && delay <= 27000;
+
+        it('should be between 1 - 3 seconds for the first attempt', () => {
+            resumeTask.schedule();
+
+            expect(between1and3seconds(resumeTask.retryDelay)).toBeTruthy();
+        });
+        it('should be between 3 - 9 seconds for the second attempt', () => {
+            resumeTask.schedule();
+            resumeTask.schedule();
+
+            expect(between3and9seconds(resumeTask.retryDelay)).toBeTruthy(`retryDelay=${resumeTask.retryDelay}`);
+        });
+        it('should be between 4.5 - 27 seconds for the third attempt', () => {
+            resumeTask.schedule();
+            resumeTask.schedule();
+            resumeTask.schedule();
+
+            expect(between4500msAnd27seconds(resumeTask.retryDelay)).toBeTruthy();
+
+            // It should remain within the last range after the 3rd retry
+            resumeTask.schedule();
+            expect(between4500msAnd27seconds(resumeTask.retryDelay)).toBeTruthy();
+        });
+        it('should not increase when internet goes offline/online', () => {
+            resumeTask.schedule();
+
+            networkInfo.updateNetworkInfo({ isOnline: false });
+            networkInfo.updateNetworkInfo({ isOnline: true });
+            networkInfo.updateNetworkInfo({ isOnline: false });
+            networkInfo.updateNetworkInfo({ isOnline: true });
+
+            expect(between1and3seconds(resumeTask.retryDelay)).toBeTruthy();
+        });
+    });
+});

modules/xmpp/XmppConnection.js

@@ -3,8 +3,8 @@ import { $pres, Strophe } from 'strophe.js';
 import 'strophejs-plugin-stream-management';
 
 import Listenable from '../util/Listenable';
-import { getJitterDelay } from '../util/Retry';
 
+import ResumeTask from './ResumeTask';
 import LastSuccessTracker from './StropheLastSuccess';
 import PingConnectionPlugin from './strophe.ping';
 
@@ -53,12 +53,6 @@ export default class XmppConnection extends Listenable {
             websocketKeepAlive: typeof websocketKeepAlive === 'undefined' ? 4 * 60 * 1000 : Number(websocketKeepAlive)
         };
 
-        /**
-         * The counter increased before each resume retry attempt, used to calculate exponential backoff.
-         * @type {number}
-         * @private
-         */
-        this._resumeRetryN = 0;
         this._stropheConn = new Strophe.Connection(serviceUrl);
         this._usesWebsocket = serviceUrl.startsWith('ws:') || serviceUrl.startsWith('wss:');
 
@@ -68,6 +62,8 @@ export default class XmppConnection extends Listenable {
         this._lastSuccessTracker = new LastSuccessTracker();
         this._lastSuccessTracker.startTracking(this, this._stropheConn);
 
+        this._resumeTask = new ResumeTask(this._stropheConn);
+
         /**
          * @typedef DeferredSendIQ Object
          * @property {Element} iq - The IQ to send.
@@ -255,6 +251,7 @@ export default class XmppConnection extends Listenable {
             this._maybeEnableStreamResume();
             this._maybeStartWSKeepAlive();
             this._processDeferredIQs();
+            this._resumeTask.cancel();
             this.ping.startInterval(this.domain);
         } else if (status === Strophe.Status.DISCONNECTED) {
             this.ping.stopInterval();
@@ -302,7 +299,7 @@ export default class XmppConnection extends Listenable {
      * @returns {void}
      */
     disconnect(...args) {
-        clearTimeout(this._resumeTimeout);
+        this._resumeTask.cancel();
         clearTimeout(this._wsKeepAlive);
         this._clearDeferredIQs();
         this._stropheConn.disconnect(...args);
@@ -555,32 +552,7 @@ export default class XmppConnection extends Listenable {
         const resumeToken = streamManagement && streamManagement.getResumeToken();
 
         if (resumeToken) {
-            clearTimeout(this._resumeTimeout);
-
-            // FIXME detect internet offline
-            // The retry delay will be:
-            //   1st retry: 1.5s - 3s
-            //   2nd retry: 3s - 9s
-            //   3rd retry: 3s - 27s
-            this._resumeRetryN = Math.min(3, this._resumeRetryN + 1);
-            const retryTimeout = getJitterDelay(this._resumeRetryN, 1500, 3);
-
-            logger.info(`Will try to resume the XMPP connection in ${retryTimeout}ms`);
-
-            this._resumeTimeout = setTimeout(() => {
-                logger.info('Trying to resume the XMPP connection');
-
-                const url = new URL(this._stropheConn.service);
-                let { search } = url;
-
-                search += search.indexOf('?') === -1 ? `?previd=${resumeToken}` : `&previd=${resumeToken}`;
-
-                url.search = search;
-
-                this._stropheConn.service = url.toString();
-
-                streamManagement.resume();
-            }, retryTimeout);
+            this._resumeTask.schedule();
 
             return true;
         }