@webex/plugin-meetings 3.0.0-beta.291 → 3.0.0-beta.293

package/src/meeting/index.ts

@@ -38,6 +38,7 @@ import {
   UserInLobbyError,
   NoMediaEstablishedYetError,
   UserNotJoinedError,
+  AddMediaFailed,
 } from '../common/errors/webex-errors';
 import {StatsAnalyzer, EVENTS as StatsAnalyzerEvents} from '../statsAnalyzer';
 import NetworkQualityMonitor from '../networkQualityMonitor';
@@ -569,6 +570,7 @@ export default class Meeting extends StatelessWebexPlugin {
   allowMediaInLobby: boolean;
   turnDiscoverySkippedReason: string;
   turnServerUsed: boolean;
+  private retriedWithTurnServer: boolean;
   private sendSlotManager: SendSlotManager = new SendSlotManager(LoggerProxy);
   private deferSDPAnswer?: Defer; // used for waiting for a response
   private sdpResponseTimer?: ReturnType<typeof setTimeout>;
@@ -1304,6 +1306,15 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     this.turnServerUsed = false;
+
+    /**
+     * Whether retry was done using TURN Discovery.
+     * @instance
+     * @type {boolean}
+     * @private
+     * @memberof Meeting
+     */
+    this.retriedWithTurnServer = false;
   }
 
   /**
@@ -5708,8 +5719,8 @@ export default class Meeting extends StatelessWebexPlugin {
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.ice.end',
         payload: {
-          canProceed: false,
-          icePhase: 'JOIN_MEETING_FINAL',
+          canProceed: !this.turnServerUsed, // If we haven't done turn tls retry yet we will proceed with join attempt
+          icePhase: this.turnServerUsed ? 'JOIN_MEETING_FINAL' : 'JOIN_MEETING_RETRY',
           errors: [
             // @ts-ignore
             this.webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode({
@@ -5817,20 +5828,109 @@ export default class Meeting extends StatelessWebexPlugin {
   }
 
   /**
-   * Does TURN discovery, SDP offer/answer exhange, establishes ICE connection and DTLS handshake
+   * Calls establishMediaConnection with isForced = true to force turn discovery to happen
    *
    * @private
    * @param {RemoteMediaManagerConfiguration} [remoteMediaManagerConfig]
    * @param {BundlePolicy} [bundlePolicy]
    * @returns {Promise<void>}
    */
-  private async establishMediaConnection(
+  private async retryEstablishMediaConnectionWithForcedTurnDiscovery(
     remoteMediaManagerConfig?: RemoteMediaManagerConfiguration,
     bundlePolicy?: BundlePolicy
+  ): Promise<void> {
+    const LOG_HEADER =
+      'Meeting:index#addMedia():retryEstablishMediaConnectionWithForcedTurnDiscovery -->';
+
+    try {
+      await this.establishMediaConnection(remoteMediaManagerConfig, bundlePolicy, true);
+    } catch (err) {
+      LoggerProxy.logger.error(
+        `${LOG_HEADER} retry with TURN-TLS failed, media connection unable to connect, `,
+        err
+      );
+
+      throw err;
+    }
+  }
+
+  /**
+   * Does relevant clean up before retrying to establish media connection
+   * and performs the retry with forced turn discovery
+   *
+   * @private
+   * @param {RemoteMediaManagerConfiguration} [remoteMediaManagerConfig]
+   * @param {BundlePolicy} [bundlePolicy]
+   * @returns {Promise<void>}
+   */
+  private async retryWithForcedTurnDiscovery(
+    remoteMediaManagerConfig?: RemoteMediaManagerConfiguration,
+    bundlePolicy?: BundlePolicy
+  ): Promise<void> {
+    this.retriedWithTurnServer = true;
+
+    await this.cleanUpBeforeRetryWithTurnServer();
+
+    await this.retryEstablishMediaConnectionWithForcedTurnDiscovery(
+      remoteMediaManagerConfig,
+      bundlePolicy
+    );
+  }
+
+  /**
+   * If waitForMediaConnectionConnected() fails when we haven't done turn discovery then we
+   * attempt to establish a media connection again, but this time using turn discovery. If we
+   * used turn discovery on the first pass we do not attempt connection again.
+   *
+   * @private
+   * @param {Error} error
+   * @param {RemoteMediaManagerConfiguration} [remoteMediaManagerConfig]
+   * @param {BundlePolicy} [bundlePolicy]
+   * @returns {Promise<void>}
+   */
+  private async handleWaitForMediaConnectionConnectedError(
+    error: Error,
+    remoteMediaManagerConfig?: RemoteMediaManagerConfiguration,
+    bundlePolicy?: BundlePolicy
+  ): Promise<void> {
+    const LOG_HEADER = 'Meeting:index#addMedia():handleWaitForMediaConnectionConnectedError -->';
+
+    // @ts-ignore - config coming from registerPlugin
+    if (!this.turnServerUsed) {
+      LoggerProxy.logger.info(
+        `${LOG_HEADER} error waiting for media to connect on UDP, TCP, retrying using TURN-TLS, `,
+        error
+      );
+
+      await this.retryWithForcedTurnDiscovery(remoteMediaManagerConfig, bundlePolicy);
+    } else {
+      LoggerProxy.logger.error(
+        `${LOG_HEADER} error waiting for media to connect using UDP, TCP and TURN-TLS`,
+        error
+      );
+
+      throw new AddMediaFailed();
+    }
+  }
+
+  /**
+   * Does TURN discovery, SDP offer/answer exhange, establishes ICE connection and DTLS handshake.
+   *
+   * @private
+   * @param {RemoteMediaManagerConfiguration} [remoteMediaManagerConfig]
+   * @param {BundlePolicy} [bundlePolicy]
+   * @param {boolean} [isForced] - let isForced be true to do turn discovery regardless of reachability results
+   * @returns {Promise<void>}
+   */
+  private async establishMediaConnection(
+    remoteMediaManagerConfig?: RemoteMediaManagerConfiguration,
+    bundlePolicy?: BundlePolicy,
+    isForced?: boolean
   ): Promise<void> {
     const LOG_HEADER = 'Meeting:index#addMedia():establishMediaConnection -->';
     // @ts-ignore
     const cdl = this.webex.internal.newMetrics.callDiagnosticLatencies;
+    const isRetry = this.retriedWithTurnServer;
 
     try {
       // @ts-ignore
@@ -5838,7 +5938,7 @@ export default class Meeting extends StatelessWebexPlugin {
         name: 'internal.client.add-media.turn-discovery.start',
       });
 
-      const turnDiscoveryObject = await this.roap.doTurnDiscovery(this, false);
+      const turnDiscoveryObject = await this.roap.doTurnDiscovery(this, isRetry, isForced);
 
       this.turnDiscoverySkippedReason = turnDiscoveryObject?.turnDiscoverySkippedReason;
       this.turnServerUsed = !this.turnDiscoverySkippedReason;
@@ -5853,6 +5953,7 @@ export default class Meeting extends StatelessWebexPlugin {
           correlation_id: this.correlationId,
           latency: cdl.getTurnDiscoveryTime(),
           turnServerUsed: this.turnServerUsed,
+          retriedWithTurnServer: this.retriedWithTurnServer,
         });
       }
 
@@ -5898,7 +5999,15 @@ export default class Meeting extends StatelessWebexPlugin {
       throw error;
     }
 
-    await this.waitForMediaConnectionConnected();
+    try {
+      await this.waitForMediaConnectionConnected();
+    } catch (error) {
+      await this.handleWaitForMediaConnectionConnectedError(
+        error,
+        remoteMediaManagerConfig,
+        bundlePolicy
+      );
+    }
   }
 
   /**
@@ -5907,7 +6016,7 @@ export default class Meeting extends StatelessWebexPlugin {
    * @private
    * @returns {Promise<void>}
    */
-  private async cleanUpOnAddMediaFailure() {
+  private async cleanUpOnAddMediaFailure(): Promise<void> {
     if (this.statsAnalyzer) {
       await this.statsAnalyzer.stopAnalyzer();
     }
@@ -5924,6 +6033,36 @@ export default class Meeting extends StatelessWebexPlugin {
     }
   }
 
+  /**
+   * Sends stats report, closes peer connection and cleans up any media connection
+   * related things before trying to establish media connection again with turn server
+   *
+   * @private
+   * @returns {Promise<void>}
+   */
+  private async cleanUpBeforeRetryWithTurnServer(): Promise<void> {
+    // when media fails, we want to upload a webrtc dump to see whats going on
+    // this function is async, but returns once the stats have been gathered
+    await this.forceSendStatsReport({callFrom: 'cleanUpBeforeRetryWithTurnServer'});
+
+    if (this.mediaProperties.webrtcMediaConnection) {
+      if (this.remoteMediaManager) {
+        this.remoteMediaManager.stop();
+        this.remoteMediaManager = null;
+      }
+
+      Object.values(this.mediaRequestManagers).forEach((mediaRequestManager) =>
+        mediaRequestManager.reset()
+      );
+
+      this.receiveSlotManager.reset();
+      this.mediaProperties.webrtcMediaConnection.close();
+      this.sendSlotManager.reset();
+
+      this.mediaProperties.unsetPeerConnection();
+    }
+  }
+
   /**
    * Creates a media connection to the server. Media connection is required for sending or receiving any audio/video.
    *
@@ -5932,7 +6071,8 @@ export default class Meeting extends StatelessWebexPlugin {
    * @public
    * @memberof Meeting
    */
-  async addMedia(options: AddMediaOptions = {}) {
+  async addMedia(options: AddMediaOptions = {}): Promise<void> {
+    this.retriedWithTurnServer = false;
     const LOG_HEADER = 'Meeting:index#addMedia -->';
     LoggerProxy.logger.info(`${LOG_HEADER} called with: ${JSON.stringify(options)}`);
 
@@ -6028,7 +6168,7 @@ export default class Meeting extends StatelessWebexPlugin {
 
       this.createStatsAnalyzer();
 
-      await this.establishMediaConnection(remoteMediaManagerConfig, bundlePolicy);
+      await this.establishMediaConnection(remoteMediaManagerConfig, bundlePolicy, false);
 
       await Meeting.handleDeviceLogging();
 
@@ -6074,6 +6214,7 @@ export default class Meeting extends StatelessWebexPlugin {
         code: error.code,
         turnDiscoverySkippedReason: this.turnDiscoverySkippedReason,
         turnServerUsed: this.turnServerUsed,
+        retriedWithTurnServer: this.retriedWithTurnServer,
         isMultistream: this.isMultistream,
         signalingState:
           this.mediaProperties.webrtcMediaConnection?.multistreamConnection?.pc?.pc

package/src/meetings/index.ts

@@ -681,21 +681,6 @@ export default class Meetings extends WebexPlugin {
     }
   }
 
-  /**
-   * API to enable or disable TURN discovery
-   * @param {Boolean} enable
-   * @private
-   * @memberof Meetings
-   * @returns {undefined}
-   */
-  private _toggleTurnDiscovery(enable: boolean) {
-    if (typeof enable !== 'boolean') {
-      return;
-    }
-    // @ts-ignore
-    this.config.experimental.enableTurnDiscovery = enable;
-  }
-
   /**
    * API to toggle starting adhoc meeting
    * @param {Boolean} changeState

package/src/reconnection-manager/index.ts

@@ -563,8 +563,8 @@ export default class ReconnectionManager {
       'ReconnectionManager:index#reconnectMedia --> Begin reestablishment of media'
     );
 
-    // do the TURN server discovery again since the TURN server might change
-    const turnServerResult = await this.meeting.roap.doTurnDiscovery(this.meeting, true);
+    // do the TURN server discovery again and ignore reachability results since the TURN server might change
+    const turnServerResult = await this.meeting.roap.doTurnDiscovery(this.meeting, true, true);
 
     const iceServers = [];
 

package/src/roap/index.ts

@@ -222,9 +222,10 @@ export default class Roap extends StatelessWebexPlugin {
    * @param {Meeting} meeting
    * @param {Boolean} isReconnecting should be set to true if this is a new
    *                                 media connection just after a reconnection
+   * @param {Boolean} [isForced]
    * @returns {Promise}
    */
-  doTurnDiscovery(meeting: Meeting, isReconnecting: boolean) {
-    return this.turnDiscovery.doTurnDiscovery(meeting, isReconnecting);
+  doTurnDiscovery(meeting: Meeting, isReconnecting: boolean, isForced?: boolean) {
+    return this.turnDiscovery.doTurnDiscovery(meeting, isReconnecting, isForced);
   }
 }

package/src/roap/turnDiscovery.ts

@@ -237,15 +237,6 @@ export default class TurnDiscovery {
       return 'reachability';
     }
 
-    // @ts-ignore - fix type
-    if (!meeting.config.experimental.enableTurnDiscovery) {
-      LoggerProxy.logger.info(
-        'Roap:turnDiscovery#getSkipReason --> TURN discovery disabled in config, skipping it'
-      );
-
-      return 'config';
-    }
-
     return '';
   }
 
@@ -274,12 +265,17 @@ export default class TurnDiscovery {
    * so it works fine no matter if TURN discovery is done or not.
    *
    * @param {Meeting} meeting
-   * @param {Boolean} isReconnecting should be set to true if this is a new
+   * @param {Boolean} [isReconnecting] should be set to true if this is a new
    *                                 media connection just after a reconnection
+   * @param {Boolean} [isForced]
    * @returns {Promise}
    */
-  async doTurnDiscovery(meeting: Meeting, isReconnecting?: boolean) {
-    const turnDiscoverySkippedReason = await this.getSkipReason(meeting);
+  async doTurnDiscovery(meeting: Meeting, isReconnecting?: boolean, isForced?: boolean) {
+    let turnDiscoverySkippedReason: string;
+
+    if (!isForced) {
+      turnDiscoverySkippedReason = await this.getSkipReason(meeting);
+    }
 
     if (turnDiscoverySkippedReason) {
       return {