@webex/plugin-meetings 3.0.0-beta.4 → 3.0.0-beta.400

package/src/peer-connection-manager/util.ts

@@ -1,117 +0,0 @@
-import { parse } from '@webex/ts-sdp';
-
-interface IPeerConnectionUtils {
-  convertCLineToIpv4: (sdp: string) => string;
-  adjustH264Profile: (sdp: string, maxFsValue: number) => string;
-}
-
-const PeerConnectionUtils = {} as IPeerConnectionUtils;
-
-// max-fs values for all H264 profile levels
-const maxFsForProfileLevel = {
-  10: 99,
-  11: 396,
-  12: 396,
-  13: 396,
-  20: 396,
-  21: 792,
-  22: 1620,
-  30: 1620,
-  31: 3600,
-  32: 5120,
-  40: 8192,
-  41: 8192,
-  42: 8704,
-  50: 22080,
-  51: 36864,
-  52: 36864,
-  60: 139264,
-  61: 139264,
-  62: 139264,
-};
-
-const framesPerSecond = 30;
-
-/**
- * Convert C line to IPv4
- * @param {string} sdp
- * @returns {string}
- */
-PeerConnectionUtils.convertCLineToIpv4 = (sdp: string) => {
-  let replaceSdp = sdp;
-
-  // TODO: remove this once linus supports Ipv6 c line.currently linus rejects SDP with c line having ipv6 candidates we are
-  // mocking ipv6 to ipv4 candidates
-  // https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-299232
-  replaceSdp = replaceSdp.replace(/c=IN IP6 .*/gi, 'c=IN IP4 0.0.0.0');
-
-  return replaceSdp;
-};
-
-/**
- * estimate profile levels for max-fs & max-mbps values
- * @param {string} sdp
- * @param {number} maxFsValue
- * @returns {string}
- */
-PeerConnectionUtils.adjustH264Profile = (sdp: string, maxFsValue: number) => {
-  // converting with ts-sdp parser, no munging
-  const parsedSdp = parse(sdp);
-
-  parsedSdp.avMedia.forEach((media) => {
-    if (media.type === 'video') {
-      media.codecs.forEach((codec) => {
-        if (codec.name?.toUpperCase() === 'H264') {
-          // there should really be just 1 fmtp line, but just in case, we process all of them
-          codec.fmtParams = codec.fmtParams.map((fmtp) => {
-            const parsedRegex = fmtp.match(/(.*)profile-level-id=(\w{4})(\w{2})(.*)/);
-
-            if (parsedRegex && parsedRegex.length === 5) {
-              const stuffBeforeProfileLevelId = parsedRegex[1];
-              const profile = parsedRegex[2].toLowerCase();
-              const levelId = parseInt(parsedRegex[3], 16);
-              const stuffAfterProfileLevelId = parsedRegex[4];
-
-              if (!maxFsForProfileLevel[levelId]) {
-                throw new Error(
-                  `found unsupported h264 profile level id value in the SDP: ${levelId}`
-                );
-              }
-
-              if (maxFsForProfileLevel[levelId] === maxFsValue) {
-                // profile level already matches our desired max-fs value, so we don't need to do anything
-                return fmtp;
-              }
-              if (maxFsForProfileLevel[levelId] < maxFsValue) {
-                // profile level has too low max-fs, so we need to override it (this is upgrading)
-                return `${fmtp};max-fs=${maxFsValue};max-mbps=${maxFsValue * framesPerSecond}`;
-              }
-
-              // profile level has too high max-fs value, so we need to use a lower level
-
-              // find highest level that has the matching maxFs
-              const newLevelId = Object.keys(maxFsForProfileLevel)
-                .reverse()
-                .find((key) => maxFsForProfileLevel[key] === maxFsValue);
-
-              if (newLevelId) {
-                // Object.keys returns keys as strings, so we need to parse it to an int again and then convert to hex
-                const newLevelIdHex = parseInt(newLevelId, 10).toString(16);
-
-                return `${stuffBeforeProfileLevelId}profile-level-id=${profile}${newLevelIdHex};max-mbps=${maxFsValue * framesPerSecond}${stuffAfterProfileLevelId}`;
-              }
-
-              throw new Error(`unsupported maxFsValue: ${maxFsValue}`);
-            }
-
-            return fmtp;
-          });
-        }
-      });
-    }
-  });
-
-  return parsedSdp.toString();
-};
-
-export default PeerConnectionUtils;

package/src/reachability/index.js

@@ -1,464 +0,0 @@
-/*!
- * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
- */
-
-/* eslint-disable class-methods-use-this */
-/* globals window */
-import _ from 'lodash';
-
-import LoggerProxy from '../common/logs/logger-proxy';
-import {
-  ICE_GATHERING_STATE,
-  CONNECTION_STATE,
-  REACHABILITY
-} from '../constants';
-
-import ReachabilityRequest from './request';
-
-const DEFAULT_TIMEOUT = 3000;
-const VIDEO_MESH_TIMEOUT = 1000;
-
-/**
- * @class Reachability
- * @export
- */
-export default class Reachability {
-  /**
-   * Creates an instance of Reachability.
-   * @param {object} webex
-   * @memberof Reachability
-   */
-  constructor(webex) {
-    this.webex = webex;
-
-    /**
-     * internal request object for the server
-     * @instance
-     * @type {Array}
-     * @private
-     * @memberof Reachability
-     */
-    this.reachabilityRequest = new ReachabilityRequest(this.webex);
-
-    /**
-     * internal object of clusters latency results
-     * @instance
-     * @type {object}
-     * @private
-     * @memberof Reachability
-     */
-    this.clusterLatencyResults = {};
-  }
-
-
-  /**
-   * fetches reachability data
-   * @returns {Object} reachability data
-   * @public
-   * @async
-   * @memberof Reachability
-   */
-  async gatherReachability() {
-    this.setup();
-
-    // Remove stored reachability results to ensure no stale data
-    if (window?.localStorage?.removeItem) {
-      window.localStorage.removeItem(REACHABILITY.localStorage);
-    }
-    else {
-      LoggerProxy.logger.error('Reachability:index#gatherReachability --> Error in accessing LocalStorage.');
-
-      return {};
-    }
-
-    // Fetch clusters and measure latency
-    try {
-      const clusters = await this.reachabilityRequest.getClusters();
-
-      // Perform Reachability Check
-      const results = await this.performReachabilityCheck(clusters);
-
-      window.localStorage.setItem(REACHABILITY.localStorage, JSON.stringify(results));
-
-      LoggerProxy.logger.log('Reachability:index#gatherReachability --> Reachability checks completed');
-
-      return results;
-    }
-    catch (getClusterError) {
-      LoggerProxy.logger.error(`Reachability:index#gatherReachability --> Error in calling getClusters(): ${getClusterError}`);
-
-      return {};
-    }
-  }
-
-  /**
-   * fetches reachability data and checks for cluster reachability
-   * @returns {boolean}
-   * @public
-   * @memberof Reachability
-   */
-  isAnyClusterReachable() {
-    let reachable = false;
-    const reachabilityData = window.localStorage.getItem(REACHABILITY.localStorage);
-
-    if (reachabilityData) {
-      try {
-        const reachabilityResults = JSON.parse(reachabilityData);
-
-        reachable = Object.values(reachabilityResults).some((result) => result.udp?.reachable === 'true' || result.tcp?.reachable === 'true');
-      }
-      catch (e) {
-        LoggerProxy.logger.error(`Roap:request#attachReachabilityData --> Error in parsing reachability data: ${e}`);
-      }
-    }
-
-    return reachable;
-  }
-
-
-  /**
-   * Generate peerConnection config settings
-   * @param {object} cluster
-   * @returns {object} peerConnectionConfig
-   * @private
-   * @memberof Reachability
-   */
-  buildPeerConnectionConfig(cluster) {
-    const iceServers = _.uniq([
-      ...cluster.udp,
-      ...cluster.tcp
-    ]).map((url) => ({
-      username: '',
-      credential: '',
-      urls: [url]
-    }));
-
-    return {
-      iceServers: [
-        ...iceServers
-      ],
-      iceCandidatePoolSize: '0',
-      iceTransportPolicy: 'all'
-    };
-  }
-
-
-  /**
-   * Creates an RTCPeerConnection
-   * @param {object} cluster
-   * @returns {RTCPeerConnection} peerConnection
-   * @private
-   * @memberof Reachability
-   */
-  createPeerConnection(cluster) {
-    const {key, config} = cluster;
-
-    try {
-      const peerConnection = new window.RTCPeerConnection(config);
-
-      peerConnection.key = key;
-
-      return peerConnection;
-    }
-    catch (peerConnectionError) {
-      LoggerProxy.logger.log(`Reachability:index#createPeerConnection --> Error creating peerConnection: ${peerConnectionError}`);
-
-      return null;
-    }
-  }
-
-
-  /**
-   * Gets total elapsed time
-   * @param {RTCPeerConnection} peerConnection
-   * @returns {Number} Milliseconds
-   * @private
-   * @memberof Reachability
-   */
-  getElapsedTime(peerConnection) {
-    const startTime = peerConnection.begin;
-
-    delete peerConnection.begin;
-
-    return Date.now() - startTime;
-  }
-
-
-  /**
-   * creates offer and generates localSDP
-   * @param {object} clusterList cluster List
-   * @returns {Promise} Reachability latency results
-   * @private
-   * @memberof Reachability
-   */
-  getLocalSDPForClusters(clusterList) {
-    let clusters = [...Object.keys(clusterList)];
-
-    clusters = clusters.map(async (key) => {
-      const cluster = clusterList[key];
-      const config = this.buildPeerConnectionConfig(cluster);
-      const peerConnection = this.createPeerConnection({key, config});
-      const description = await peerConnection.createOffer({offerToReceiveAudio: true});
-
-      peerConnection.begin = Date.now();
-      peerConnection.setLocalDescription(description);
-
-      return this.iceGatheringState(peerConnection, cluster.isVideoMesh ? VIDEO_MESH_TIMEOUT : DEFAULT_TIMEOUT)
-        .catch((iceGatheringStateError) => {
-          LoggerProxy.logger.log(`Reachability:index#getLocalSDPForClusters --> Error in getLocalSDP : ${iceGatheringStateError}`);
-        });
-    });
-
-    return Promise.all(clusters)
-      .then(this.parseIceResultsToReachabilityResults)
-      .then((reachabilityLatencyResults) => {
-        this.logUnreachableClusters();
-
-        // return results
-        return reachabilityLatencyResults;
-      });
-  }
-
-
-  /**
-   * Get list of all unreachable clusters
-   * @returns {array} Unreachable clusters
-   * @private
-   * @memberof Reachability
-   */
-  getUnreachablClusters() {
-    const unreachableList = [];
-    const clusters = this.clusterLatencyResults;
-
-    Object.keys(clusters).forEach((key) => {
-      const cluster = clusters[key];
-
-      if (cluster.unreachable && !cluster.reachable) {
-        unreachableList.push(key);
-      }
-    });
-
-    return unreachableList;
-  }
-
-
-  /**
-   * Attach an event handler for the icegatheringstatechange
-   * event and measure latency.
-   * @param {RTCPeerConnection} peerConnection
-   * @returns {undefined}
-   * @private
-   * @memberof Reachability
-   */
-  handleIceGatheringStateChange(peerConnection) {
-    peerConnection.onicegatheringstatechange = () => {
-      const {COMPLETE} = ICE_GATHERING_STATE;
-
-      if (peerConnection.iceConnectionState === COMPLETE) {
-        const elapsed = this.getElapsedTime(peerConnection);
-
-        LoggerProxy.logger.log(`Reachability:index#onIceGatheringStateChange --> Successfully pinged ${peerConnection.key}:`, elapsed);
-        this.setLatencyAndClose(peerConnection, elapsed);
-      }
-    };
-  }
-
-
-  /**
-   * Attach an event handler for the icecandidate
-   * event and measure latency.
-   * @param {RTCPeerConnection} peerConnection
-   * @returns {undefined}
-   * @private
-   * @memberof Reachability
-   */
-  handleOnIceCandidate(peerConnection) {
-    peerConnection.onicecandidate = (e) => {
-      const SERVER_REFLEXIVE = 'srflx';
-
-      if (e.candidate && String(e.candidate.type).toLowerCase() === SERVER_REFLEXIVE) {
-        const elapsed = this.getElapsedTime(peerConnection);
-
-        LoggerProxy.logger.log(`Reachability:index#onIceCandidate --> Successfully pinged ${peerConnection.key}:`, elapsed);
-        this.setLatencyAndClose(peerConnection, elapsed);
-      }
-    };
-  }
-
-  /**
-   * An event handler on an RTCPeerConnection when the state of the ICE
-   * candidate gathering process changes. Used to measure connection
-   * speed.
-   * @private
-   * @param {RTCPeerConnection} peerConnection
-   * @param {number} timeout
-   * @returns {Promise}
-   */
-  iceGatheringState(peerConnection, timeout) {
-    const ELAPSED = 'elapsed';
-
-    return new Promise((resolve) => {
-      const peerConnectionProxy = new window.Proxy(peerConnection, {
-        get(target, property) {
-          const targetMember = target[property];
-
-          if (typeof (targetMember) === 'function') {
-            return targetMember.bind(target);
-          }
-
-          return targetMember;
-        },
-        set: (target, property, value) => {
-          // only intercept elapsed property
-          if (property === ELAPSED) {
-            resolve({clusterId: peerConnection.key, elapsed: value});
-
-            return true;
-          }
-
-          // pass thru
-          return window.Reflect.set(target, property, value);
-        }
-      });
-
-      // Using peerConnection proxy so handle functions below
-      // won't be coupled to our promise implementation
-      this.handleIceGatheringStateChange(peerConnectionProxy);
-      this.handleOnIceCandidate(peerConnectionProxy);
-
-      // Set maximum timeout
-      window.setTimeout(() => {
-        const {CLOSED} = CONNECTION_STATE;
-
-        // Close any open peerConnections
-        if (peerConnectionProxy.connectionState !== CLOSED) {
-          this.setLatencyAndClose(peerConnectionProxy, null);
-        }
-      }, timeout);
-    });
-  }
-
-
-  /**
-   * Make a log of unreachable clusters.
-   * @returns {undefined}
-   * @private
-   * @memberof Reachability
-   */
-  logUnreachableClusters() {
-    const list = this.getUnreachablClusters();
-
-    list.forEach((cluster) => {
-      LoggerProxy.logger.log(`Reachability:index#logUnreachableClusters --> No ice candidate for ${cluster}.`);
-    });
-  }
-
-
-  /**
-   * Calculates time to establish connection
-   * @param {array} iceResults iceResults
-   * @returns {object} reachabilityMap
-   * @private
-   * @memberof Reachability
-   */
-  parseIceResultsToReachabilityResults(iceResults) {
-    const reachabilityMap = {};
-
-    iceResults.forEach(({clusterId, elapsed}) => {
-      let latencyResult;
-
-      if (elapsed === null) {
-        latencyResult = {reachable: 'false'};
-      }
-      else {
-        latencyResult = {
-          reachable: 'true',
-          latencyInMilliseconds: (elapsed).toString()
-        };
-      }
-
-      reachabilityMap[clusterId] = {
-        udp: latencyResult,
-        tcp: latencyResult
-      };
-    });
-
-    return reachabilityMap;
-  }
-
-
-  /**
-   * fetches reachability data
-   * @param {object} clusterList
-   * @returns {Promise<localSDPData>} reachability check results
-   * @private
-   * @memberof Reachability
-   */
-  performReachabilityCheck(clusterList) {
-    if (!clusterList || !Object.keys(clusterList).length) {
-      return Promise.resolve({});
-    }
-
-    return new Promise((resolve) => {
-      this.getLocalSDPForClusters(clusterList)
-        .then((localSDPData) => {
-          if (!localSDPData || !Object.keys(localSDPData).length) {
-            // TODO: handle the error condition properly and try retry
-            LoggerProxy.logger.log('Reachability:index#performReachabilityCheck --> Local SDP is empty or has missing elements..returning');
-            resolve({});
-          }
-          else {
-            resolve(localSDPData);
-          }
-        })
-        .catch((error) => {
-          LoggerProxy.logger.error(`Reachability:index#performReachabilityCheck --> Error in getLocalSDPForClusters: ${error}`);
-          resolve({});
-        });
-    });
-  }
-
-
-  /**
-   * Records latency and closes the peerConnection
-   * @param {RTCPeerConnection} peerConnection
-   * @param {number} elapsed Latency in milliseconds
-   * @returns {undefined}
-   * @private
-   * @memberof Reachability
-   */
-  setLatencyAndClose(peerConnection, elapsed) {
-    const REACHABLE = 'reachable';
-    const UNREACHABLE = 'unreachable';
-    const {CLOSED} = CONNECTION_STATE;
-    const {key} = peerConnection;
-    const resultKey = elapsed === null ? UNREACHABLE : REACHABLE;
-    const intialState = {[REACHABLE]: 0, [UNREACHABLE]: 0};
-
-    if (peerConnection.connectionState === CLOSED) {
-      LoggerProxy.logger.log(`Reachability:index#setLatencyAndClose --> Attempting to set latency of ${elapsed} on closed peerConnection.`);
-
-      return;
-    }
-
-    this.clusterLatencyResults[key] = this.clusterLatencyResults[key] || intialState;
-    this.clusterLatencyResults[key][resultKey] += 1;
-
-    // Set to null in case this fired from
-    // an event other than onIceCandidate
-    peerConnection.onicecandidate = null;
-    peerConnection.close();
-    peerConnection.elapsed = elapsed;
-  }
-
-
-  /**
-   * utility function
-   * @returns {undefined}
-   * @private
-   * @memberof Reachability
-   */
-  setup() {
-    this.clusterLatencyResults = {};
-  }
-}