@webex/plugin-meetings 3.0.0-stream-classes.4 → 3.0.0

package/src/reachability/request.ts

@@ -49,7 +49,7 @@ class ReachabilityRequest {
         const {clusters, joinCookie} = res.body;
 
         Object.keys(clusters).forEach((key) => {
-          clusters[key].isVideoMesh = res.body.clusterClasses?.hybridMedia?.includes(key);
+          clusters[key].isVideoMesh = !!res.body.clusterClasses?.hybridMedia?.includes(key);
         });
 
         LoggerProxy.logger.log(

package/src/reachability/util.ts

@@ -0,0 +1,24 @@
+/* eslint-disable import/prefer-default-export */
+/**
+ * Converts a stun url to a turn url
+ *
+ * @param {string} stunUrl url of a stun server
+ * @param {'tcp'|'udp'} protocol what protocol to use for the turn server
+ * @returns {string} url of a turn server
+ */
+export function convertStunUrlToTurn(stunUrl: string, protocol: 'udp' | 'tcp') {
+  // stunUrl looks like this: "stun:external-media91.public.wjfkm-a-10.prod.infra.webex.com:5004"
+  // and we need it to be like this: "turn:external-media91.public.wjfkm-a-10.prod.infra.webex.com:5004?transport=tcp"
+  const url = new URL(stunUrl);
+
+  if (url.protocol !== 'stun:') {
+    throw new Error(`Not a STUN URL: ${stunUrl}`);
+  }
+
+  url.protocol = 'turn:';
+  if (protocol === 'tcp') {
+    url.searchParams.append('transport', 'tcp');
+  }
+
+  return url.toString();
+}

package/src/reconnection-manager/index.ts

@@ -14,13 +14,14 @@ import {
   _CALL_,
   _LEFT_,
   _ID_,
+  RECONNECTION_STATE,
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
-import ReconnectionError from '../common/errors/reconnection';
 import ReconnectInProgress from '../common/errors/reconnection-in-progress';
 import Metrics from '../metrics';
 import Meeting from '../meeting';
 import {MediaRequestManager} from '../multistream/mediaRequestManager';
+import ReconnectionError from '../common/errors/reconnection';
 
 /**
  * Used to indicate that the reconnect logic needs to be retried.
@@ -96,7 +97,7 @@ export default class ReconnectionManager {
 
     /**
      * @instance
-     * @type {String}
+     * @type {RECONNECTION_STATE}
      * @private
      * @memberof ReconnectionManager
      */
@@ -227,7 +228,6 @@ export default class ReconnectionManager {
    */
   public cleanUp() {
     this.reset();
-    this.meeting = null;
   }
 
   /**
@@ -265,6 +265,18 @@ export default class ReconnectionManager {
     return this.status === RECONNECTION.STATE.IN_PROGRESS;
   }
 
+  /**
+   * Sets the reconnection status
+   *
+   * @public
+   * @param {RECONNECTION_STATE} status
+   * @memberof ReconnectionManager
+   * @returns {undefined}
+   */
+  public setStatus(status: RECONNECTION_STATE) {
+    this.status = status;
+  }
+
   /**
    * @returns {Boolean}
    * @throws {ReconnectionError}
@@ -337,73 +349,66 @@ export default class ReconnectionManager {
       });
     }
 
-    return this.executeReconnection({networkDisconnect})
-      .then(() => {
-        LoggerProxy.logger.info('ReconnectionManager:index#reconnect --> Reconnection successful.');
-        LoggerProxy.logger.info(
-          'ReconnectionManager:index#reconnect --> Sending reconnect success metric.'
-        );
+    try {
+      await this.webex.meetings.startReachability();
+    } catch (err) {
+      LoggerProxy.logger.info(
+        'ReconnectionManager:index#reconnect --> Reachability failed, continuing with reconnection attempt, err: ',
+        err
+      );
+    }
 
-        // @ts-ignore
-        this.webex.internal.newMetrics.submitClientEvent({
-          name: 'client.media.recovered',
-          payload: {
-            recoveredBy: 'new',
-          },
-          options: {
-            meetingId: this.meeting.id,
-          },
-        });
-      })
-      .catch((reconnectError) => {
-        if (reconnectError instanceof NeedsRetryError) {
-          LoggerProxy.logger.info(
-            'ReconnectionManager:index#reconnect --> Reconnection not successful, retrying.'
-          );
-          // Reset our reconnect status since we are looping back to the beginning
-          this.status = RECONNECTION.STATE.DEFAULT_STATUS;
-
-          // This is a network retry, so we should not log START metrics again
-          return this.reconnect({networkDisconnect: true, networkRetry: true});
-        }
+    try {
+      const media = await this.executeReconnection({networkDisconnect});
 
-        // Reconnect has failed
-        LoggerProxy.logger.error(
-          'ReconnectionManager:index#reconnect --> Reconnection failed.',
-          reconnectError.message
-        );
+      return media;
+    } catch (reconnectError) {
+      if (reconnectError instanceof NeedsRetryError) {
         LoggerProxy.logger.info(
-          'ReconnectionManager:index#reconnect --> Sending reconnect abort metric.'
+          'ReconnectionManager:index#reconnect --> Reconnection not successful, retrying.'
         );
+        // Reset our reconnect status since we are looping back to the beginning
+        this.status = RECONNECTION.STATE.DEFAULT_STATUS;
 
-        // @ts-ignore
-        this.webex.internal.newMetrics.submitClientEvent({
-          name: 'client.call.aborted',
-          payload: {
-            errors: [
-              {
-                category: 'expected',
-                errorCode: 2008,
-                fatal: true,
-                name: 'media-engine',
-                shownToUser: false,
-              },
-            ],
-          },
-          options: {
-            meetingId: this.meeting.id,
-          },
-        });
-        if (reconnectError instanceof NeedsRejoinError) {
-          // send call aborded event with catogery as expected as we are trying to rejoin
+        // This is a network retry, so we should not log START metrics again
+        return this.reconnect({networkDisconnect: true, networkRetry: true});
+      }
 
-          if (this.autoRejoinEnabled) {
-            return this.rejoinMeeting(reconnectError.wasSharing);
-          }
-        }
+      // Reconnect has failed
+      LoggerProxy.logger.error(
+        'ReconnectionManager:index#reconnect --> Reconnection failed.',
+        reconnectError.message
+      );
+      LoggerProxy.logger.info(
+        'ReconnectionManager:index#reconnect --> Sending reconnect abort metric.'
+      );
 
-        throw reconnectError;
+      // send call aborted event with catogery as expected as we are trying to rejoin
+      // @ts-ignore
+      this.webex.internal.newMetrics.submitClientEvent({
+        name: 'client.call.aborted',
+        payload: {
+          errors: [
+            {
+              category: 'expected',
+              errorCode: 2008,
+              fatal: true,
+              name: 'media-engine',
+              shownToUser: false,
+            },
+          ],
+        },
+        options: {
+          meetingId: this.meeting.id,
+        },
       });
+
+      if (reconnectError instanceof NeedsRejoinError && this.autoRejoinEnabled) {
+        return this.rejoinMeeting(reconnectError.wasSharing);
+      }
+
+      throw reconnectError;
+    }
   }
 
   /**
@@ -443,19 +448,17 @@ export default class ReconnectionManager {
       }
     }
 
-    if (!this.webex.credentials.isUnverifiedGuest) {
-      try {
-        LoggerProxy.logger.info(
-          'ReconnectionManager:index#executeReconnection --> Updating meeting data from server.'
-        );
-        await this.webex.meetings.syncMeetings();
-      } catch (syncError) {
-        LoggerProxy.logger.info(
-          'ReconnectionManager:index#executeReconnection --> Unable to sync meetings, reconnecting.',
-          syncError
-        );
-        throw new NeedsRetryError(syncError);
-      }
+    try {
+      LoggerProxy.logger.info(
+        'ReconnectionManager:index#executeReconnection --> Updating meeting data from server.'
+      );
+      await this.webex.meetings.syncMeetings({keepOnlyLocusMeetings: false});
+    } catch (syncError) {
+      LoggerProxy.logger.info(
+        'ReconnectionManager:index#executeReconnection --> Unable to sync meetings, reconnecting.',
+        syncError
+      );
+      throw new NeedsRetryError(syncError);
     }
 
     // TODO: try to improve this logic as the reconnection manager saves the instance of deleted meeting object
@@ -485,14 +488,13 @@ export default class ReconnectionManager {
       const media = await this.reconnectMedia();
 
       LoggerProxy.logger.log(
-        'ReconnectionManager:index#executeReconnection --> Media reestablished'
+        'ReconnectionManager:index#executeReconnection --> webRTC media connection renewed and local sdp offer sent'
       );
-      this.status = RECONNECTION.STATE.COMPLETE;
 
       return media;
     } catch (error) {
       LoggerProxy.logger.error(
-        'ReconnectionManager:index#executeReconnection --> Media reestablishment failed'
+        'ReconnectionManager:index#executeReconnection --> failed to renew webRTC media connection or initiate offer'
       );
       this.status = RECONNECTION.STATE.FAILURE;
 
@@ -559,12 +561,10 @@ export default class ReconnectionManager {
    * @memberof ReconnectionManager
    */
   async reconnectMedia() {
-    LoggerProxy.logger.log(
-      'ReconnectionManager:index#reconnectMedia --> Begin reestablishment of media'
-    );
+    LoggerProxy.logger.log('ReconnectionManager:index#reconnectMedia --> do turn discovery');
 
-    // 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 = [];
 
@@ -576,6 +576,10 @@ export default class ReconnectionManager {
       });
     }
 
+    LoggerProxy.logger.log(
+      'ReconnectionManager:index#reconnectMedia --> renew webRTC media connection and send local sdp offer'
+    );
+
     await this.meeting.mediaProperties.webrtcMediaConnection.reconnect(iceServers);
 
     // resend media requests

package/src/roap/index.ts

@@ -8,6 +8,8 @@ import RoapRequest from './request';
 import TurnDiscovery from './turnDiscovery';
 import Meeting from '../meeting';
 import MeetingUtil from '../meeting/util';
+import Metrics from '../metrics';
+import BEHAVIORAL_METRICS from '../metrics/constants';
 
 /**
  * Roap options
@@ -179,39 +181,72 @@ export default class Roap extends StatelessWebexPlugin {
    * @memberof Roap
    */
   sendRoapMediaRequest(options: any) {
-    const {meeting, seq, sdp, reconnect, tieBreaker} = options;
+    const {meeting, seq, sdp, tieBreaker} = options;
     const roapMessage = {
       messageType: ROAP.ROAP_TYPES.OFFER,
       sdps: [sdp],
       version: ROAP.ROAP_VERSION,
       seq,
       tieBreaker,
+      headers: ['includeAnswerInHttpResponse', 'noOkInTransaction'],
     };
 
-    // When reconnecting, it's important that the first roap message being sent out has empty media id.
-    // Normally this is the roap offer, but when TURN discovery is enabled,
-    // then this is the TURN discovery request message
-    return this.turnDiscovery.isSkipped(meeting).then((isTurnDiscoverySkipped) => {
-      const sendEmptyMediaId = reconnect && isTurnDiscoverySkipped;
+    // The only time we want to send an empty media id is when we are reconnecting, because this way we tell Locus
+    // that it needs to create a new confluence, but when reconnecting we always send TURN_DISCOVERY_REQUEST first,
+    // so we don't need to ever send an empty media id here
+    const sendEmptyMediaId = false;
 
-      return this.roapRequest
-        .sendRoap({
-          roapMessage,
-          locusSelfUrl: meeting.selfUrl,
-          mediaId: sendEmptyMediaId ? '' : meeting.mediaId,
-          meetingId: meeting.id,
-          preferTranscoding: !meeting.isMultistream,
-          locusMediaRequest: meeting.locusMediaRequest,
-          ipVersion: MeetingUtil.getIpVersion(meeting.webex),
-        })
-        .then(({locus, mediaConnections}) => {
-          if (mediaConnections) {
-            meeting.updateMediaConnections(mediaConnections);
+    return this.roapRequest
+      .sendRoap({
+        roapMessage,
+        locusSelfUrl: meeting.selfUrl,
+        mediaId: sendEmptyMediaId ? '' : meeting.mediaId,
+        meetingId: meeting.id,
+        preferTranscoding: !meeting.isMultistream,
+        locusMediaRequest: meeting.locusMediaRequest,
+        ipVersion: MeetingUtil.getIpVersion(meeting.webex),
+      })
+      .then(({locus, mediaConnections}) => {
+        if (mediaConnections) {
+          meeting.updateMediaConnections(mediaConnections);
+        }
+
+        let roapAnswer;
+
+        if (mediaConnections?.[0]?.remoteSdp) {
+          const remoteSdp = JSON.parse(mediaConnections[0].remoteSdp);
+
+          if (remoteSdp.roapMessage) {
+            const {
+              seq: answerSeq,
+              messageType,
+              sdps,
+              errorType,
+              errorCause,
+              headers,
+            } = remoteSdp.roapMessage;
+
+            roapAnswer = {
+              seq: answerSeq,
+              messageType,
+              sdp: sdps[0],
+              errorType,
+              errorCause,
+              headers,
+            };
           }
+        }
 
-          return locus;
-        });
-    });
+        if (!roapAnswer) {
+          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ROAP_HTTP_RESPONSE_MISSING, {
+            correlationId: meeting.correlationId,
+            messageType: 'ANSWER',
+            isMultistream: meeting.isMultistream,
+          });
+        }
+
+        return {locus, roapAnswer};
+      });
   }
 
   /**
@@ -222,9 +257,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/request.ts

@@ -18,23 +18,10 @@ export default class RoapRequest extends StatelessWebexPlugin {
     let joinCookie;
 
     // @ts-ignore
-    const reachabilityData = await this.webex.boundedStorage
-      .get(REACHABILITY.namespace, REACHABILITY.localStorageResult)
-      .catch(() => {});
-
-    if (reachabilityData) {
-      try {
-        const reachabilityResult = JSON.parse(reachabilityData);
+    const reachabilityResult = await this.webex.meetings.reachability.getReachabilityResults();
 
-        /* istanbul ignore else */
-        if (reachabilityResult && Object.keys(reachabilityResult).length) {
-          localSdp.reachability = reachabilityResult;
-        }
-      } catch (e) {
-        LoggerProxy.logger.error(
-          `Roap:request#attachReachabilityData --> Error in parsing reachability data: ${e}`
-        );
-      }
+    if (reachabilityResult && Object.keys(reachabilityResult).length) {
+      localSdp.reachability = reachabilityResult;
     }
 
     // @ts-ignore
@@ -136,7 +123,7 @@ export default class RoapRequest extends StatelessWebexPlugin {
         );
         const {locus} = res.body;
 
-        locus.roapSeq = options.roapMessage.seq;
+        locus.roapSeq = roapMessage.seq;
 
         return {
           locus,