@webex/plugin-meetings 2.60.0 → 2.60.1-next.10

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

@@ -1,119 +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/roap/collection.ts

@@ -1,62 +0,0 @@
-import RoapStateMachine from './state';
-
-/* eslint-disable */
-const RoapCollection = {
-  sessions: {},
-
-  getSession(id) {
-    if (!this.sessions[id]) {
-      this.sessions[id] = {
-        activeSequences: 0,
-      };
-    }
-    return this.sessions[id];
-  },
-
-  deleteSession(id) {
-    if (this.getSession(id)) {
-      delete this.sessions[id];
-    }
-  },
-
-  getSessionSequence(id, seqId) {
-    const session = this.getSession(id);
-    if (!session[seqId]) {
-      session[seqId] = {
-        state: RoapStateMachine.createState(),
-        finished: false,
-      };
-      session.activeSequences += 1;
-    }
-    return session[seqId];
-  },
-
-  deleteSessionSequence(id, seqId) {
-    const seq = this.getSessionSequence(id, seqId);
-    if (seq) {
-      if (!seq.finished) {
-        // @ts-ignore
-        session.activeSequences -= 1;
-      }
-      delete this.sessions[id][seqId];
-    }
-  },
-
-  isBusy(id) {
-    const session = this.getSession(id);
-    if (!session) return false;
-
-    return session.activeSequences > 0;
-  },
-
-  onSessionSequenceFinish(id, seqId) {
-    const session = this.getSession(id);
-    const seq = session[seqId];
-    if (seq && !seq.finished) {
-      seq.finished = true;
-      session.activeSequences -= 1;
-    }
-  },
-};
-
-export default RoapCollection;

package/src/roap/handler.ts

@@ -1,294 +0,0 @@
-/* no-param-reassign */
-// @ts-ignore
-import {StatelessWebexPlugin} from '@webex/webex-core';
-
-import LoggerProxy from '../common/logs/logger-proxy';
-import {ROAP, _OFFER_} from '../constants';
-import Metrics from '../metrics';
-import BEHAVIORAL_METRICS from '../metrics/constants';
-
-import RoapUtil from './util';
-import RoapCollection from './collection';
-import Meeting from '../meeting';
-
-const checkForAndHandleErrors = (action, meeting, correlationId) => {
-  if (action && action.type) {
-    if (action.msg && action.msg.messageType && action.msg.errorType) {
-      if (RoapUtil.findError(action.msg.messageType, action.msg.errorType, action.type)) {
-        RoapUtil.handleError(meeting.mediaProperties.peerConnection)
-          .then((res) => {
-            if (res) {
-              RoapCollection.deleteSessionSequence(correlationId, action.msg.seq);
-            }
-          })
-          .catch((err) => {
-            LoggerProxy.logger.warn(
-              `Roap:handler#checkForAndHandleErrors --> Cannot reset the peer connection with error: ${err}`
-            );
-          });
-
-        return true;
-      }
-    }
-    if (!RoapUtil.ensureMeeting(meeting, action.type)) {
-      return true;
-    }
-  }
-
-  return false;
-};
-
-const compareWithLastRoapMessage = (lastRoapMessage, currentRoapMessage) =>
-  lastRoapMessage?.msg?.seq === currentRoapMessage.msg.seq &&
-  lastRoapMessage?.msg?.messageType === currentRoapMessage.msg.messageType;
-
-const handleSessionStep = ({roap, session, locusUrl, correlationId}) => {
-  const {seq: sequenceId, messageType} = roap.msg;
-
-  if (session.OFFER && messageType === _OFFER_) {
-    session.GLARE_OFFER = roap.msg;
-    session.GLARE_OFFER.remote = !!roap.remote;
-    const metricName = BEHAVIORAL_METRICS.ROAP_GLARE_CONDITION;
-    const data = {
-      correlation_id: correlationId,
-      locus_id: locusUrl.split('/').pop(),
-      sequence: sequenceId,
-    };
-
-    Metrics.sendBehavioralMetric(metricName, data);
-
-    LoggerProxy.logger.warn(
-      `Roap:handler#handleSessionStep --> Glare condition occurred with new mercury event, sequenceId: ${sequenceId}`
-    );
-  } else {
-    LoggerProxy.logger.info(
-      `Roap:handler#handleSessionStep --> Save OFFER/ANSWER seq:${sequenceId} new mercury event ${messageType}local state: ${JSON.stringify(
-        session.state.state,
-        null,
-        2
-      )}`
-    );
-    session[messageType] = roap.msg;
-    session[messageType].remote = !!roap.remote;
-  }
-};
-
-/**
- * @class RoapHandler
- */
-export default class RoapHandler extends StatelessWebexPlugin {
-  attrs: any;
-  lastRoapMessage: any;
-  options: any;
-  roapAnswer: any;
-  roapFinished: any;
-  roapOk: any;
-
-  constructor(attrs, options, roapOk, roapAnswer, roapFinished) {
-    super({}, options);
-    this.attrs = attrs;
-    this.options = options;
-    this.roapOk = roapOk;
-    this.roapFinished = roapFinished;
-    this.roapAnswer = roapAnswer;
-    this.lastRoapMessage = null;
-  }
-
-  /**
-   *
-   * @param {Object} session
-   * @param {Meeting} meeting
-   * @param {Object} action
-   * @returns {null}
-   */
-  perform(session: any, meeting: any, action: any) {
-    switch (session.state.state) {
-      case ROAP.ROAP_STATE.INIT:
-        this.roapFinished(meeting.correlationId, action.msg.seq);
-        break;
-
-      // TODO:  (important )handle roap state for sending offers as well
-      // case ROAP.ROAP_STATE.WAIT_RX_OFFER:
-      // case ROAP.ROAP_STATE.WAIT_RX_ANSWER:
-      // case ROAP.ROAP_STATE.WAIT_RX_OK:
-      case ROAP.ROAP_STATE.WAIT_TX_ANSWER:
-        // eslint-disable-next-line no-warning-comments
-        // TODO: sometime the you get an answer while you are creating an offer so SKIP
-        // Server will send the mercury event comes back
-        if (RoapUtil.shouldHandleMedia(meeting)) {
-          RoapUtil.updatePeerConnection(meeting, session)
-            .then((answerSdps) => {
-              this.roapAnswer({
-                mediaId: meeting.mediaId,
-                sdps: answerSdps,
-                seq: session.OFFER.seq,
-                correlationId: meeting.correlationId,
-                audioMuted: meeting.isAudioMuted(),
-                videoMuted: meeting.isVideoMuted(),
-              });
-            })
-            .catch((error) => {
-              const metricName = BEHAVIORAL_METRICS.ROAP_ANSWER_FAILURE;
-              const data = {
-                correlation_id: meeting.correlationId,
-                locus_id: meeting.locusUrl.split('/').pop(),
-                reason: error.message,
-                stack: error.stack,
-              };
-              const metadata = {
-                type: error.name,
-              };
-
-              Metrics.sendBehavioralMetric(metricName, data, metadata);
-              LoggerProxy.logger.error(
-                `Roap:handler#perform --> Error occured during wait receive answer, continuing, ${error}`
-              );
-            });
-        }
-        break;
-      case ROAP.ROAP_STATE.WAIT_TX_OK:
-        if (!RoapUtil.shouldHandleMedia(meeting)) {
-          RoapUtil.setRemoteDescription(meeting, session).then((res) => {
-            this.roapOk(res);
-          });
-        }
-        break;
-      // case ROAP.ROAP_STATE.IDLE_LOCAL_OFFER:
-      case ROAP.ROAP_STATE.ERROR:
-        LoggerProxy.logger.error(
-          `Roap:handler#perform --> Roap State ERROR for session: ${session}`
-        );
-        break;
-      case ROAP.ROAP_STATE.GLARE:
-        session.GLARE_OFFER.tieBreaker = session.GLARE_OFFER.tieBreaker || 0;
-        session.OFFER.tieBreaker = session.OFFER.tieBreaker || 0;
-        LoggerProxy.logger.warn(
-          'Roap:handler#perform --> Roap State resolved the GLARE condition.'
-        );
-        if (session.GLARE_OFFER.tieBreaker < session.OFFER.tieBreaker) {
-          // 2
-          LoggerProxy.logger.log(
-            'Roap:handler#perform --> Roap State local offer won after GLARE.'
-          );
-        } else {
-          LoggerProxy.logger.log(
-            'Roap:handler#perform --> Roap State remote offer won after GLARE.'
-          );
-        }
-        session.state.step(ROAP.ROAP_SIGNAL.GLARE_RESOLVED, meeting, action);
-        // @ts-ignore
-        this.perform(session, meeting);
-        break;
-      default:
-        break;
-    }
-  }
-
-  /**
-   *
-   * @param {String} signal
-   * @param {Object} session
-   * @param {Object} action
-   * @param {Meeting} meeting
-   * @param {String} prefix
-   * @returns {null}
-   */
-  execute(signal: string, session: any, action: any, meeting: Meeting, prefix: string) {
-    if (session && session.state) {
-      handleSessionStep({
-        roap: action,
-        locusUrl: meeting.locusUrl,
-        correlationId: meeting.correlationId,
-        session,
-      });
-      signal = ROAP.ROAP_SIGNAL[`${prefix}${action.msg.messageType}`];
-      session.state.step(signal, meeting, action);
-      this.perform(session, meeting, action);
-    }
-  }
-
-  /**
-   *
-   * @param {Object} session
-   * @param {Object} action
-   * @param {Meeting} meeting
-   * @param {String} correlationId
-   * @returns {Boolean}
-   */
-  handleAction(session: object, action: any, meeting: Meeting, correlationId: string) {
-    let signal;
-
-    switch (action.type) {
-      case ROAP.RECEIVE_ROAP_MSG:
-        LoggerProxy.logger.log(
-          `Roap:handler#handleAction --> RECEIVE_ROAP_MSG event captured, reciving a roap message : ${JSON.stringify(
-            action
-          )}`
-        );
-        if (compareWithLastRoapMessage(this.lastRoapMessage, action)) {
-          LoggerProxy.logger.warn(
-            `Roap:handler#handleAction --> duplicate roap offer from server: ${action.msg.seq}`
-          );
-        } else {
-          this.lastRoapMessage = action;
-          action.remote = true;
-          this.execute(signal, session, action, meeting, ROAP.RX_);
-        }
-        break;
-      case ROAP.SEND_ROAP_MSG:
-        LoggerProxy.logger.log(
-          `Roap:handler#handleAction --> SEND_ROAP_MSG event captured, sending roap message ${JSON.stringify(
-            action
-          )}`
-        );
-
-        action.local = true;
-        this.execute(signal, session, action, meeting, ROAP.TX_);
-        break;
-      case ROAP.SEND_ROAP_MSG_SUCCESS:
-        // NOTE: When server send back an answer via mercury the
-        // remote SDP is already saved sent and ok message is sent back
-        // We dont have to indicate the roapHandler about the RX_ANSWER via SEND_ROAP_MSG_SUCCESS
-        break;
-      case ROAP.RECEIVE_CALL_LEAVE:
-        RoapCollection.deleteSession(correlationId);
-        LoggerProxy.logger.log(
-          `Roap:handler#handleAction --> RECEIVE_CALL_LEAVE event captured, cleaning up the RoapHandler for correlationId: ${correlationId}`
-        );
-        break;
-      case ROAP.RESET_ROAP_STATE:
-        RoapCollection.deleteSessionSequence(correlationId, action.msg.seq);
-        LoggerProxy.logger.log(
-          `Roap:handler#handleAction --> RESET_ROAP_STATE event captured, resetting the RoapHandler state based on sequenceId: ${action.msg.seq}`
-        );
-        break;
-      default:
-        return true;
-    }
-
-    return true;
-  }
-
-  /**
-   *
-   * @param {Object} action
-   * @returns {Boolean}
-   */
-  submit(action: any) {
-    const {correlationId} = action;
-    let {seq} = action;
-
-    if (!seq && action.msg) {
-      seq = action.msg.seq;
-    }
-    const session = RoapCollection.getSessionSequence(correlationId, seq);
-    // @ts-ignore
-    const meeting = this.webex.meetings.meetingCollection.getByKey('correlationId', correlationId);
-
-    if (checkForAndHandleErrors(action, meeting, correlationId)) {
-      return true;
-    }
-
-    return this.handleAction(session, action, meeting, correlationId);
-  }
-}

package/src/roap/state.ts

@@ -1,156 +0,0 @@
-import StateMachine from 'javascript-state-machine';
-
-import LoggerProxy from '../common/logs/logger-proxy';
-import {ROAP, _OFFER_, _ANSWER_, _REQUESTED_} from '../constants';
-import Meeting from '../meeting';
-
-const shouldStep = (roap, meeting) => {
-  const {messageType} = roap.msg;
-
-  if (meeting) {
-    if (messageType === _OFFER_ && roap.remote && meeting.shareStatus === _REQUESTED_) {
-      // The peer-connection is waiting for answer but got an offer Reset. Try to
-      // send the offer later after you accept the answer
-      return false;
-    }
-    // Assuming the mercury event has come first before the response for the event
-    // we have to wait for the response and trigger the ROAP request later on
-    if (!meeting.mediaProperties.peerConnection && messageType === _ANSWER_) {
-      return false;
-    }
-  }
-  LoggerProxy.logger.log(
-    'Roap:state#shouldStep --> RoapStateMachine: PeerConnectionState, ',
-    meeting.mediaProperties.peerConnection.signalingState
-  );
-  LoggerProxy.logger.log(
-    'Roap:state#shouldStep --> RoapStateMachine: success save proceeding with transition, ',
-    roap.msg
-  );
-
-  return true;
-};
-
-const handleTransition = (value, signal, meeting) => {
-  LoggerProxy.logger.log(`Roap:state#handleTransition --> current ${value} to ${signal}`);
-
-  switch (value) {
-    case ROAP.ROAP_STATE.INIT:
-      if (signal === ROAP.ROAP_SIGNAL.RX_OFFER) {
-        return ROAP.ROAP_STATE.WAIT_TX_ANSWER;
-      }
-      if (signal === ROAP.ROAP_SIGNAL.TX_OFFER) {
-        return ROAP.ROAP_STATE.WAIT_RX_ANSWER;
-      }
-
-      return value;
-
-    case ROAP.ROAP_STATE.WAIT_RX_OFFER:
-      return value;
-
-    case ROAP.ROAP_STATE.WAIT_RX_ANSWER:
-      if (signal === ROAP.ROAP_SIGNAL.RX_ANSWER) {
-        // There is a race condition where the /call response comes after mercury event from the server
-        // As mercury sends roap event if it didnt get back a response. We can send the roap ok after that
-        if (meeting.mediaId) {
-          return ROAP.ROAP_STATE.WAIT_TX_OK;
-        }
-        LoggerProxy.logger.error(
-          'Roap:state#handleTransition --> Race Condition no mediaId, continuing.'
-        );
-
-        return value;
-      }
-
-      if (signal === ROAP.ROAP_SIGNAL.RX_OFFER) {
-        return ROAP.ROAP_STATE.GLARE;
-      }
-
-      return value;
-
-    case ROAP.ROAP_STATE.WAIT_TX_OFFER:
-      return value;
-
-    case ROAP.ROAP_STATE.WAIT_TX_ANSWER:
-      if (signal === ROAP.ROAP_SIGNAL.TX_ANSWER) {
-        return ROAP.ROAP_STATE.WAIT_RX_OK;
-      }
-
-      return value;
-
-    case ROAP.ROAP_STATE.WAIT_TX_OK:
-      if (signal === ROAP.ROAP_SIGNAL.TX_OK) {
-        return ROAP.ROAP_STATE.INIT;
-      }
-
-      return value;
-
-    case ROAP.ROAP_STATE.WAIT_RX_OK:
-      if (signal === ROAP.ROAP_SIGNAL.RX_OK) {
-        return ROAP.ROAP_STATE.INIT;
-      }
-
-      return value;
-
-    case ROAP.ROAP_STATE.ERROR:
-      // eslint-disable-next-line no-warning-comments
-      // TODO: resolve error state. Add a signal constant and handle the cleanup
-      return ROAP.ROAP_STATE.INIT;
-
-    case ROAP.ROAP_STATE.GLARE:
-      return ROAP.ROAP_STATE.WAIT_RX_ANSWER;
-    default:
-      return value;
-  }
-};
-
-const RoapStateMachine = {
-  /**
-   * @param {Roap} roapRef
-   * initializes the state machine
-   * @returns {StateMachine} an instance of a state machine
-   */
-  createState() {
-    const RoapState = StateMachine.factory({
-      init: ROAP.ROAP_STATE.INIT,
-      transitions: [
-        {
-          name: ROAP.ROAP_TRANSITIONS.STEP,
-          from: '*',
-          /**
-           * Method to handle the transitions between states
-           * @param {String} signal
-           * @param {Meeting} meeting instance of a Meeting
-           * @param {Object} roap
-           * @returns {String} new state value
-           */
-          to(signal: string, meeting: Meeting, roap: object) {
-            const value = this.state;
-
-            if (!shouldStep(roap, meeting)) {
-              return value;
-            }
-
-            return handleTransition(value, signal, meeting);
-          },
-        },
-      ],
-      methods: {
-        /**
-         * Event that fires after we've transitioned to a new state
-         * @param {Object} transition
-         * @returns {null}
-         */
-        onAfterStep(transition: any) {
-          LoggerProxy.logger.log(
-            `Roap:state#onAfterStep --> RoapStateMachine->onAfterStep#fired! State changed from '${transition.from}' to '${transition.to}' with transition '${transition.transition}''.`
-          );
-        },
-      },
-    });
-
-    return new RoapState();
-  },
-};
-
-export default RoapStateMachine;