@webex/plugin-meetings 3.0.0-beta.0 → 3.0.0-beta.2

package/src/roap/collection.js

@@ -1,63 +0,0 @@
-import RoapStateMachine from '../roap/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) {
-        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.js

@@ -1,252 +0,0 @@
-/* no-param-reassign */
-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';
-
-
-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 {
-  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, meeting, action) {
-    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);
-        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, session, action, meeting, prefix) {
-    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, action, meeting, correlationId) {
-    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) {
-    const {correlationId} = action;
-    let {seq} = action;
-
-    if (!seq && action.msg) {
-      seq = action.msg.seq;
-    }
-    const session = RoapCollection.getSessionSequence(correlationId, seq);
-    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.js

@@ -1,149 +0,0 @@
-import StateMachine from 'javascript-state-machine';
-
-import LoggerProxy from '../common/logs/logger-proxy';
-import {ROAP, _OFFER_, _ANSWER_, _REQUESTED_} from '../constants';
-
-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, meeting, roap) {
-            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) {
-          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;

package/src/roap/util.js

@@ -1,93 +0,0 @@
-
-import PeerConnectionManager from '../peer-connection-manager';
-import {
-  _ANSWER_,
-  _ERROR_,
-  _CONFLICT_,
-  ROAP,
-  SDP
-} from '../constants';
-import LoggerProxy from '../common/logs/logger-proxy';
-import ParameterError from '../common/errors/parameter';
-
-const RoapUtil = {};
-const ROAP_ANSWER = _ANSWER_.toLowerCase();
-
-RoapUtil.shouldHandleMedia = (meeting) => {
-  const offer =
-    meeting.mediaProperties.peerConnection &&
-    meeting.mediaProperties.peerConnection.signalingState === SDP.HAVE_LOCAL_OFFER;
-
-  if (offer) {
-    return false;
-  }
-
-  return true;
-};
-
-RoapUtil.handleError = (pc) =>
-  PeerConnectionManager.rollBackLocalDescription({peerConnection: pc})
-    .then(() => Promise.resolve(true))
-    .catch((err) => {
-      LoggerProxy.logger.error(`Roap:util#handleError --> ${err}`);
-
-      return Promise.reject(err);
-    });
-
-RoapUtil.findError = (messageType, errorType, type) =>
-  (type === ROAP.RECEIVE_ROAP_MSG || type === ROAP.SEND_ROAP_MSG) && messageType === _ERROR_ && errorType === _CONFLICT_;
-
-RoapUtil.ensureMeeting = (meeting, type) => {
-  if (type === ROAP.RECEIVE_ROAP_MSG || type === ROAP.SEND_ROAP_MSG || type === ROAP.SEND_ROAP_MSG_SUCCESS) {
-    if (!meeting) {
-      return false;
-    }
-  }
-
-  return true;
-};
-
-RoapUtil.updatePeerConnection = (meeting, session) => PeerConnectionManager.updatePeerConnection({
-  offerSdp: session.OFFER.sdps,
-  peerConnection: meeting.mediaProperties.peerConnection
-},
-{
-  meetingId: meeting.id,
-  remoteQualityLevel: meeting.mediaProperties.remoteQualityLevel
-})
-  .then((res) => {
-    meeting.roap.lastRoapOffer = session.OFFER.sdps;
-
-    return res;
-  });
-
-
-RoapUtil.setRemoteDescription = (meeting, session) => {
-  LoggerProxy.logger.info(`Roap:util#setRemoteDescription --> Transmit WAIT_TX_OK, correlationId: ${meeting.correlationId}`);
-  if (!(meeting && (meeting.mediaProperties.peerConnection))) {
-    LoggerProxy.logger.error(`Roap:util#setRemoteDescription --> DANGER no media or screen peer connection, correlationId: ${meeting.correlationId}`);
-
-    return Promise.reject(new ParameterError('Must provide a media or screen peer connection'));
-  }
-
-  return PeerConnectionManager.setRemoteSessionDetails(
-    meeting.mediaProperties.peerConnection,
-    ROAP_ANSWER,
-    session.ANSWER.sdps[0],
-    meeting.id
-  ).then(() => {
-    LoggerProxy.logger.info(`Roap:util#setRemoteDescription --> Success for correlationId: ${meeting.correlationId}`);
-
-    return {
-      seq: session.ANSWER.seq,
-      mediaId: meeting.mediaId,
-      correlationId: meeting.correlationId
-    };
-  })
-    .catch((err) => {
-      LoggerProxy.logger.error(`Roap:util#setRemoteDescription --> ${err}`);
-      throw err;
-    });
-};
-
-export default RoapUtil;