@livedigital/client 2.4.0-beta.2 → 2.4.0

package/package.json

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

package/src/engine/index.ts

@@ -26,7 +26,6 @@ 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,
@@ -119,7 +118,7 @@ class Engine {
     this.network.socket.observer.on('state', ({ state }: { state: SocketIOEvents }) => {
       this.clientEventEmitter.emit(state);
 
-      if (state === SocketIOEvents.Reconnecting) {
+      if (state === SocketIOEvents.Reconnected) {
         this.network.socket.disconnect();
         this.clientEventEmitter.emit(CLIENT_EVENTS.channelRejoinRequired);
       }
@@ -146,7 +145,12 @@ class Engine {
     try {
       this.logger.debug('join()', { params });
       this.isRoomJoining = true;
-      await this.connectToSocketServerWithRetry(params);
+      const { webSocketUrl } = await this.getAvailableNode({
+        channelId: params.channelId,
+        role: params.role,
+      });
+      this.network.socket.connect(webSocketUrl);
+      await this.waitForSocketConnection();
       await this.performJoin(params);
     } catch (error) {
       this.logger.error('join()', { error });
@@ -420,37 +424,6 @@ 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);
@@ -465,17 +438,14 @@ class Engine {
     return new Promise((resolve, reject) => {
       const onSocketStateChange = async (data: { state: SocketIOEvents, error?: string }) => {
         const { error, state } = data;
-        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');
+        if (error) {
+          this.network.socket.observer.removeListener('state', onSocketStateChange);
+          reject(error);
           return;
         }
 
-        if (this.isRoomJoining && [SocketIOEvents.Connected, SocketIOEvents.Reconnected].includes(state)) {
-          stopListening();
+        if (this.isRoomJoining && state === SocketIOEvents.Connected) {
+          this.network.socket.observer.removeListener('state', onSocketStateChange);
           resolve();
         }
       };
@@ -486,7 +456,7 @@ class Engine {
 
   private async performJoin(params: JoinChannelParams): Promise<void> {
     try {
-      await this.sendJoinChannelRequestWithRetry(params);
+      await this.network.socket.request(CHANNEL_EVENTS.channelJoin, params);
       await this.initialize();
       this.channelEventsHandler.subscribeToEvents();
       this.mediaSoupEventsHandler.subscribeToEvents();
@@ -500,19 +470,6 @@ 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.setReconnectingAttempt(0);
+      this.reconnectingAttempt = 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.setReconnectingAttempt(0);
+      this.reconnectingAttempt = 0;
       this.disconnectReason = reason;
-      this.logger.warn('connection.on(`disconnect`)', reason);
+      this.logger.error('connection.on(`disconnect`)', reason);
       this.observer.safeEmit('state', { state: SocketIOEvents.Disconnected });
     }));
 
     connection.io.on('reconnect_attempt', (attempt: number) => {
-      this.setReconnectingAttempt(attempt);
+      this.reconnectingAttempt = attempt;
       this.logger.warn('connection.on(`reconnect_attempt`)', attempt);
       this.observer.safeEmit('state', { state: SocketIOEvents.Reconnecting });
     });
@@ -82,8 +82,6 @@ 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);
     }
   }
 
@@ -105,10 +103,6 @@ class SocketIO {
       });
     });
   }
-
-  private setReconnectingAttempt(attemptNo: number): void {
-    this.reconnectingAttempt = attemptNo;
-  }
 }
 
 export default SocketIO;

package/dist/helpers/datetime.d.ts

@@ -1,5 +0,0 @@
-declare class DefaultTimeProvider {
-    sleepMs(ms: number): Promise<void>;
-    now(): Date;
-}
-export default DefaultTimeProvider;

package/dist/helpers/retry.d.ts

@@ -1,10 +0,0 @@
-export declare type RetryOpts = {
-    maxRetries?: number;
-    minBackoffDelayMs?: number;
-    maxBackoffDelayMs?: number;
-    actionName?: string;
-};
-declare const retryAsync: <ReturnType_1>(action: () => Promise<ReturnType_1>, opts?: RetryOpts) => Promise<ReturnType_1>;
-declare const retry: <ReturnType_1>(action: () => ReturnType_1, opts?: RetryOpts) => Promise<ReturnType_1>;
-export { retryAsync };
-export default retry;

package/src/helpers/datetime.ts

@@ -1,13 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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;