@livedigital/client 2.4.2 → 2.5.0-join-retries.1

package/README.md

@@ -30,7 +30,8 @@ There are three log severities:
 All the logs generated by LiveDigital client have a namespace starting with “LiveDigital” plus colon, followed by the log severity in upper case plus colon (just if “warn” or “error”), and followed by the internal component name (if any) and the log message.  
 
 ### Enable Logging
-By default, logging is turned off. In order to enable it, the debug key in the browser's localStorage must be set.  
+By default, logging is turned off. In order to enable it, the debug key in the browser's
+localStorage must be set.  
 >Check the [debug](https://www.npmjs.com/package/debug) module documentation for further information regarding how to filter specific log messages based on namespace matching rules.
 
 ### Example

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "2.4.2",
+  "version": "2.5.0-join-retries.1",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"

package/src/engine/index.ts

@@ -26,6 +26,7 @@ import { GetNodeRequest } from '../types/network';
 import VideoTrack from './media/tracks/VideoTrack';
 import AudioTrack from './media/tracks/AudioTrack';
 import PeerTrack from './media/tracks/PeerTrack';
+import { retryAsync } from '../helpers/retry';
 
 type EngineParams = {
   clientEventEmitter: EnhancedEventEmitter,
@@ -118,7 +119,7 @@ class Engine {
     this.network.socket.observer.on('state', ({ state }: { state: SocketIOEvents }) => {
       this.clientEventEmitter.emit(state);
 
-      if (state === SocketIOEvents.Reconnected) {
+      if (state === SocketIOEvents.Reconnecting) {
         this.network.socket.disconnect();
         this.clientEventEmitter.emit(CLIENT_EVENTS.channelRejoinRequired);
       }
@@ -145,12 +146,7 @@ class Engine {
     try {
       this.logger.debug('join()', { params });
       this.isRoomJoining = true;
-      const { webSocketUrl } = await this.getAvailableNode({
-        channelId: params.channelId,
-        role: params.role,
-      });
-      this.network.socket.connect(webSocketUrl);
-      await this.waitForSocketConnection();
+      await this.connectToSocketServerWithRetry(params);
       await this.performJoin(params);
     } catch (error) {
       this.logger.error('join()', { error });
@@ -424,6 +420,37 @@ class Engine {
     return this.app;
   }
 
+  private async connectToSocketServerWithRetry(params: { channelId: string, role: Role }): Promise<void> {
+    const connectToSocketServerAction = async () => this.connectToSocketServer(params);
+    return retryAsync(connectToSocketServerAction, {
+      maxRetries: 15,
+      minBackoffDelayMs: 150,
+      maxBackoffDelayMs: 5_000,
+      actionName: 'connectToSocketServer',
+    });
+  }
+
+  private async connectToSocketServer(params: { channelId: string, role: Role }): Promise<void> {
+    const { webSocketUrl } = await this.getAvailableNode({
+      channelId: params.channelId,
+      role: params.role,
+    });
+    this.network.socket.connect(webSocketUrl);
+
+    try {
+      await this.waitForSocketConnection();
+    } catch (error: unknown) {
+      this.logger.error('Failed to connect to socket server', {
+        error,
+        role: params.role,
+        channelId: params.channelId,
+      });
+
+      this.network.socket.disconnect();
+      throw error;
+    }
+  }
+
   private async getAvailableNode(params: GetNodeRequest): Promise<{ webSocketUrl: string }> {
     try {
       const response = await this.network.loadBalancerClient.getNode(params);
@@ -438,14 +465,17 @@ class Engine {
     return new Promise((resolve, reject) => {
       const onSocketStateChange = async (data: { state: SocketIOEvents, error?: string }) => {
         const { error, state } = data;
-        if (error) {
-          this.network.socket.observer.removeListener('state', onSocketStateChange);
-          reject(error);
+        const stopListening = () => this.network.socket.observer.removeListener('state', onSocketStateChange);
+        const isStateNotExpected = [SocketIOEvents.Disconnected, SocketIOEvents.Reconnecting].includes(state);
+
+        if (error || (this.isRoomJoining && isStateNotExpected)) {
+          stopListening();
+          reject(error || 'Not expected socket state for new connection');
           return;
         }
 
-        if (this.isRoomJoining && state === SocketIOEvents.Connected) {
-          this.network.socket.observer.removeListener('state', onSocketStateChange);
+        if (this.isRoomJoining && [SocketIOEvents.Connected, SocketIOEvents.Reconnected].includes(state)) {
+          stopListening();
           resolve();
         }
       };
@@ -456,7 +486,7 @@ class Engine {
 
   private async performJoin(params: JoinChannelParams): Promise<void> {
     try {
-      await this.network.socket.request(CHANNEL_EVENTS.channelJoin, params);
+      await this.sendJoinChannelRequestWithRetry(params);
       await this.initialize();
       this.channelEventsHandler.subscribeToEvents();
       this.mediaSoupEventsHandler.subscribeToEvents();
@@ -470,6 +500,19 @@ class Engine {
     }
   }
 
+  private async sendJoinChannelRequestWithRetry(params: JoinChannelParams): Promise<SocketResponse> {
+    const joinChannelAction = async () => this.sendJoinChannelRequest(params);
+    return retryAsync(joinChannelAction, {
+      maxRetries: 3,
+      minBackoffDelayMs: 300,
+      actionName: 'sendJoinChannelRequest',
+    });
+  }
+
+  private async sendJoinChannelRequest(params: JoinChannelParams): Promise<SocketResponse> {
+    return this.network.socket.request(CHANNEL_EVENTS.channelJoin, params);
+  }
+
   get cahPublish(): boolean {
     return this.peers.find((item) => item.isMe)?.role === 'host';
   }

package/src/engine/network/Socket.ts

@@ -45,7 +45,7 @@ class SocketIO {
         : SocketIOEvents.Reconnected;
 
       this.isConnected = true;
-      this.reconnectingAttempt = 0;
+      this.setReconnectingAttempt(0);
 
       this.logger.debug('connection.on(`connect`)');
       this.observer.safeEmit('state', { state });
@@ -59,14 +59,14 @@ class SocketIO {
 
     connection.on('disconnect', ((reason: string) => {
       this.isConnected = false;
-      this.reconnectingAttempt = 0;
+      this.setReconnectingAttempt(0);
       this.disconnectReason = reason;
-      this.logger.error('connection.on(`disconnect`)', reason);
+      this.logger.warn('connection.on(`disconnect`)', reason);
       this.observer.safeEmit('state', { state: SocketIOEvents.Disconnected });
     }));
 
     connection.io.on('reconnect_attempt', (attempt: number) => {
-      this.reconnectingAttempt = attempt;
+      this.setReconnectingAttempt(attempt);
       this.logger.warn('connection.on(`reconnect_attempt`)', attempt);
       this.observer.safeEmit('state', { state: SocketIOEvents.Reconnecting });
     });
@@ -82,6 +82,8 @@ class SocketIO {
       this.connection.offAny();
       this.connection.volatile.offAny();
       this.connection.disconnect();
+      // we need to reset this counter in order not to get Reconnected event on retry
+      this.setReconnectingAttempt(0);
     }
   }
 
@@ -103,6 +105,10 @@ class SocketIO {
       });
     });
   }
+
+  private setReconnectingAttempt(attemptNo: number): void {
+    this.reconnectingAttempt = attemptNo;
+  }
 }
 
 export default SocketIO;

package/src/helpers/datetime.ts

@@ -0,0 +1,13 @@
+class DefaultTimeProvider {
+  // eslint-disable-next-line class-methods-use-this
+  async sleepMs(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  now(): Date {
+    return new Date(Date.now());
+  }
+}
+
+export default DefaultTimeProvider;

package/src/helpers/retry.ts

@@ -0,0 +1,50 @@
+import DefaultTimeProvider from './datetime';
+import Logger from '../engine/Logger';
+
+export type RetryOpts = {
+  maxRetries?: number;
+  minBackoffDelayMs?: number;
+  maxBackoffDelayMs?: number;
+  actionName?: string; // human-readable action name for debug purposes
+};
+
+const logger = new Logger('Retry');
+const timeProvider = new DefaultTimeProvider();
+
+const retryAsync = async <ReturnType>(
+  action: () => Promise<ReturnType>,
+  opts: RetryOpts = {},
+): Promise<ReturnType> => {
+  const maxRetries = opts.maxRetries || 2;
+  const minBackoffDelayMs = opts.minBackoffDelayMs || 50;
+  let currentAttempt = 0;
+  let lastError;
+
+  while (currentAttempt < maxRetries) {
+    currentAttempt += 1;
+
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      return await action();
+    } catch (err: unknown) {
+      lastError = err;
+      logger.warn('Action retry failed', currentAttempt, opts.actionName, err);
+
+      if (currentAttempt < maxRetries) {
+        const delay = 2 ** (currentAttempt - 1) * minBackoffDelayMs;
+        // eslint-disable-next-line no-await-in-loop
+        await timeProvider.sleepMs(Math.min(delay, opts.maxBackoffDelayMs ?? delay));
+      }
+    }
+  }
+
+  throw lastError;
+};
+
+const retry = async <ReturnType>(
+  action: () => ReturnType,
+  opts: RetryOpts = {},
+): Promise<ReturnType> => retryAsync(async () => action(), opts);
+
+export { retryAsync };
+export default retry;