feat(BridgeChannel): Add retries for WS.

modules/RTC/BridgeChannel.js

 import { getLogger } from 'jitsi-meet-logger';
 
 import RTCEvents from '../../service/RTC/RTCEvents';
+import { createBridgeChannelClosedEvent } from '../../service/statistics/AnalyticsEvents';
+import Statistics from '../statistics/statistics';
 import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 
 const logger = getLogger(__filename);
         // @type {string} "datachannel" / "websocket"
         this._mode = null;
 
+        // Indicates whether the connection retries are enabled or not.
+        this._areRetriesEnabled = false;
+
+        // Indicates whether the connection was closed from the client or not.
+        this._closedFromClient = false;
+
         // If a RTCPeerConnection is given, listen for new RTCDataChannel
         // event.
         if (peerconnection) {
 
         // Otherwise create a WebSocket connection.
         } else if (wsUrl) {
-            // Create a WebSocket instance.
-            const ws = new WebSocket(wsUrl);
+            this._areRetriesEnabled = true;
+            this._wsUrl = wsUrl;
+            this._initWebSocket();
+        }
+    }
 
-            // Handle the WebSocket.
-            this._handleChannel(ws);
-            this._mode = 'websocket';
+    /**
+     * Initializes the web socket channel.
+     *
+     * @returns {void}
+     */
+    _initWebSocket() {
+        // Create a WebSocket instance.
+        const ws = new WebSocket(this._wsUrl);
+
+        // Handle the WebSocket.
+        this._handleChannel(ws);
+        this._mode = 'websocket';
+    }
+
+    /**
+     * Starts the websocket connection retries.
+     *
+     * @returns {void}
+     */
+    _startConnectionRetries() {
+        let timeoutS = 1;
+
+        const reload = () => {
+            if (this.isOpen()) {
+                return;
+            }
+            this._initWebSocket(this._wsUrl);
+            timeoutS = Math.min(timeoutS * 2, 60);
+            this._retryTimeout = setTimeout(reload, timeoutS * 1000);
+        };
+
+        this._retryTimeout = setTimeout(reload, timeoutS * 1000);
+    }
+
+    /**
+     * Stops the websocket connection retries.
+     *
+     * @returns {void}
+     */
+    _stopConnectionRetries() {
+        if (this._retryTimeout) {
+            clearTimeout(this._retryTimeout);
+            this._retryTimeout = undefined;
+        }
+    }
+
+    /**
+     * Retries to establish the websocket connection after the connection was closed by the server.
+     *
+     * @param {CloseEvent} closeEvent - The close event that triggered the retries.
+     * @returns {void}
+     */
+    _retryWebSocketConnection(closeEvent) {
+        if (!this._areRetriesEnabled) {
+            return;
         }
+        const { code, reason } = closeEvent;
+
+        Statistics.sendAnalytics(createBridgeChannelClosedEvent(code, reason));
+        this._areRetriesEnabled = false;
+        this._eventEmitter.once(RTCEvents.DATA_CHANNEL_OPEN, () => {
+            this._stopConnectionRetries();
+            this._areRetriesEnabled = true;
+        });
+        this._startConnectionRetries();
     }
 
     /**
      * Closes the currently opened channel.
      */
     close() {
+        this._closedFromClient = true;
+        this._stopConnectionRetries();
+        this._areRetriesEnabled = false;
         if (this._channel) {
             try {
                 this._channel.close();
             }
         };
 
-        channel.onclose = () => {
-            logger.info('Channel closed');
+        channel.onclose = event => {
+            logger.info(`Channel closed by ${this._closedFromClient ? 'client' : 'server'}`);
+
+            if (this._mode === 'websocket') {
+                if (!this._closedFromClient) {
+                    this._retryWebSocketConnection(event);
+                }
+            }
 
             // Remove the channel.
             this._channel = null;
         const channel = this._channel;
 
         if (!this.isOpen()) {
+            logger.error('Bridge Channel send: no opened channel.');
             throw new Error('No opened channel');
         }
 

service/statistics/AnalyticsEvents.js

     };
 };
 
+/**
+ * Creates an event which contains an information related to the bridge channel close event.
+ *
+ * @param {string} code - A code from {@link https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent}
+ * @param {string} reason - A string which describes the reason for closing the bridge channel.
+ * @returns {{type: string, action: string, attributes: { code: string, reason: string }}}
+ */
+export const createBridgeChannelClosedEvent = function(code, reason) {
+    return {
+        type: TYPE_OPERATIONAL,
+        action: 'bridge-channel.error',
+        attributes: {
+            code,
+            reason
+        }
+    };
+};
+
 /**
  * Creates an event which indicates the Time To First Media (TTFM).
  * It is measured in milliseconds relative to the beginning of the document's