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

package/dist/roap/turnDiscovery.js

@@ -1,47 +1,44 @@
 "use strict";
 
 var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
-
 var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
-
 _Object$defineProperty(exports, "__esModule", {
   value: true
 });
-
 exports.default = void 0;
-
+var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
 var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
-
 var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
-
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
-
 var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
-
 var _common = require("@webex/common");
-
 var _metrics = _interopRequireDefault(require("../metrics"));
-
 var _constants = _interopRequireDefault(require("../metrics/constants"));
-
 var _loggerProxy = _interopRequireDefault(require("../common/logs/logger-proxy"));
-
 var _constants2 = require("../constants");
+var _util = _interopRequireDefault(require("../meeting/util"));
+// @ts-ignore - Types not available for @webex/common
 
 var TURN_DISCOVERY_TIMEOUT = 10; // in seconds
+
 // Roap spec says that seq should start from 1, but TURN discovery works fine with seq=0
 // and this is handy for us, because TURN discovery is always done before the first SDP exchange,
 // so we can do it with seq=0 or not do it at all and then we create the RoapMediaConnection
 // and do the SDP offer with seq=1
-
 var TURN_DISCOVERY_SEQ = 0;
+var TurnDiscoverySkipReason = {
+  missingHttpResponse: 'missing http response',
+  // when we asked for the TURN discovery response to be in the http response, but it wasn't there
+  reachability: 'reachability',
+  // when udp reachability to public clusters is ok, so we don't need TURN (this doens't apply when joinWithMedia() is used)
+  alreadyInProgress: 'already in progress' // when we try to start TURN discovery while it's already in progress
+};
 /**
  * Handles the process of finding out TURN server information from Linus.
  * This is achieved by sending a TURN_DISCOVERY_REQUEST.
  */
-
 var TurnDiscovery = /*#__PURE__*/function () {
   // used for waiting for the response
 
@@ -63,6 +60,7 @@ var TurnDiscovery = /*#__PURE__*/function () {
       password: ''
     };
   }
+
   /**
    * waits for TURN_DISCOVERY_RESPONSE message to arrive
    *
@@ -70,50 +68,44 @@ var TurnDiscovery = /*#__PURE__*/function () {
    * @private
    * @memberof Roap
    */
-
-
   (0, _createClass2.default)(TurnDiscovery, [{
     key: "waitForTurnDiscoveryResponse",
     value: function waitForTurnDiscoveryResponse() {
       if (!this.defer) {
         _loggerProxy.default.logger.warn('Roap:turnDiscovery#waitForTurnDiscoveryResponse --> TURN discovery is not in progress');
-
         return _promise.default.reject(new Error('waitForTurnDiscoveryResponse() called before sendRoapTurnDiscoveryRequest()'));
       }
-
       var defer = this.defer;
       this.responseTimer = setTimeout(function () {
         _loggerProxy.default.logger.warn("Roap:turnDiscovery#waitForTurnDiscoveryResponse --> timeout! no response arrived within ".concat(TURN_DISCOVERY_TIMEOUT, " seconds"));
-
         defer.reject(new Error('Timed out waiting for TURN_DISCOVERY_RESPONSE'));
       }, TURN_DISCOVERY_TIMEOUT * 1000);
-
       _loggerProxy.default.logger.info('Roap:turnDiscovery#waitForTurnDiscoveryResponse --> waiting for TURN_DISCOVERY_RESPONSE...');
-
       return defer.promise;
     }
+
     /**
-     * handles TURN_DISCOVERY_RESPONSE roap message
+     * Handles TURN_DISCOVERY_RESPONSE roap message. Use it if the roap message comes over the websocket,
+     * otherwise use handleTurnDiscoveryHttpResponse() if it comes in the http response.
      *
      * @param {Object} roapMessage
+     * @param {string} from string to indicate how we got the response (used just for logging)
      * @returns {void}
      * @public
      * @memberof Roap
      */
-
   }, {
     key: "handleTurnDiscoveryResponse",
-    value: function handleTurnDiscoveryResponse(roapMessage) {
+    value: function handleTurnDiscoveryResponse(roapMessage, from) {
       var _this = this;
-
       var headers = roapMessage.headers;
-
       if (!this.defer) {
-        _loggerProxy.default.logger.warn('Roap:turnDiscovery#handleTurnDiscoveryResponse --> unexpected TURN discovery response');
-
+        _loggerProxy.default.logger.warn("Roap:turnDiscovery#handleTurnDiscoveryResponse --> unexpected TURN discovery response ".concat(from));
         return;
       }
-
+      if (roapMessage.messageType !== _constants2.ROAP.ROAP_TYPES.TURN_DISCOVERY_RESPONSE) {
+        this.defer.reject(new Error("TURN_DISCOVERY_RESPONSE ".concat(from, " has unexpected messageType: ").concat((0, _stringify.default)(roapMessage))));
+      }
       var expectedHeaders = [{
         headerName: 'x-cisco-turn-url',
         field: 'url'
@@ -136,17 +128,245 @@ var TurnDiscovery = /*#__PURE__*/function () {
       });
       clearTimeout(this.responseTimer);
       this.responseTimer = undefined;
-
       if (foundHeaders !== expectedHeaders.length) {
-        _loggerProxy.default.logger.warn("Roap:turnDiscovery#handleTurnDiscoveryResponse --> missing some headers, received: ".concat((0, _stringify.default)(headers)));
-
-        this.defer.reject(new Error("TURN_DISCOVERY_RESPONSE missing some headers: ".concat((0, _stringify.default)(headers))));
+        _loggerProxy.default.logger.warn("Roap:turnDiscovery#handleTurnDiscoveryResponse --> missing some headers, received ".concat(from, ": ").concat((0, _stringify.default)(headers)));
+        this.defer.reject(new Error("TURN_DISCOVERY_RESPONSE ".concat(from, " missing some headers: ").concat((0, _stringify.default)(headers))));
       } else {
-        _loggerProxy.default.logger.info("Roap:turnDiscovery#handleTurnDiscoveryResponse --> received a valid response, url=".concat(this.turnInfo.url));
+        _loggerProxy.default.logger.info("Roap:turnDiscovery#handleTurnDiscoveryResponse --> received a valid response ".concat(from, ", url=").concat(this.turnInfo.url));
+        this.defer.resolve({
+          isOkRequired: !(headers !== null && headers !== void 0 && headers.includes('noOkInTransaction'))
+        });
+      }
+    }
+
+    /**
+     * Generates TURN_DISCOVERY_REQUEST roap message. When this method returns a roapMessage, it means that a TURN discovery process has started.
+     * It needs be ended by calling handleTurnDiscoveryHttpResponse() once you get a response from the backend. If you don't get any response
+     * or want to abort, you need to call abort().
+     *
+     * @param {Meeting} meeting
+     * @param {boolean} isForced
+     * @returns {Object}
+     */
+  }, {
+    key: "generateTurnDiscoveryRequestMessage",
+    value: function () {
+      var _generateTurnDiscoveryRequestMessage = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(meeting, isForced) {
+        var turnDiscoverySkippedReason, roapMessage;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (!this.defer) {
+                _context.next = 3;
+                break;
+              }
+              _loggerProxy.default.logger.warn('Roap:turnDiscovery#generateTurnDiscoveryRequestMessage --> TURN discovery already in progress');
+              return _context.abrupt("return", {
+                roapMessage: undefined,
+                turnDiscoverySkippedReason: TurnDiscoverySkipReason.alreadyInProgress
+              });
+            case 3:
+              if (isForced) {
+                _context.next = 7;
+                break;
+              }
+              _context.next = 6;
+              return this.getSkipReason(meeting);
+            case 6:
+              turnDiscoverySkippedReason = _context.sent;
+            case 7:
+              if (!turnDiscoverySkippedReason) {
+                _context.next = 9;
+                break;
+              }
+              return _context.abrupt("return", {
+                roapMessage: undefined,
+                turnDiscoverySkippedReason: turnDiscoverySkippedReason
+              });
+            case 9:
+              this.defer = new _common.Defer();
+              roapMessage = {
+                messageType: _constants2.ROAP.ROAP_TYPES.TURN_DISCOVERY_REQUEST,
+                version: _constants2.ROAP.ROAP_VERSION,
+                seq: TURN_DISCOVERY_SEQ,
+                headers: ['includeAnswerInHttpResponse', 'noOkInTransaction']
+              };
+              _loggerProxy.default.logger.info('Roap:turnDiscovery#generateTurnDiscoveryRequestMessage --> generated TURN_DISCOVERY_REQUEST message');
+              return _context.abrupt("return", {
+                roapMessage: roapMessage,
+                turnDiscoverySkippedReason: undefined
+              });
+            case 13:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function generateTurnDiscoveryRequestMessage(_x, _x2) {
+        return _generateTurnDiscoveryRequestMessage.apply(this, arguments);
+      }
+      return generateTurnDiscoveryRequestMessage;
+    }()
+    /**
+     * Handles any errors that occur during TURN discovery without re-throwing them.
+     *
+     * @param {Meeting} meeting
+     * @param {Error} error
+     * @returns {TurnDiscoveryResult}
+     */
+  }, {
+    key: "handleTurnDiscoveryFailure",
+    value: function handleTurnDiscoveryFailure(meeting, error) {
+      // we catch any errors and resolve with no turn information so that the normal call join flow can continue without TURN
+      _loggerProxy.default.logger.info("Roap:turnDiscovery#doTurnDiscovery --> TURN discovery failed, continuing without TURN: ".concat(error));
+      _metrics.default.sendBehavioralMetric(_constants.default.TURN_DISCOVERY_FAILURE, {
+        correlation_id: meeting.correlationId,
+        locus_id: meeting.locusUrl.split('/').pop(),
+        reason: error.message,
+        stack: error.stack
+      });
+      return {
+        turnServerInfo: undefined,
+        turnDiscoverySkippedReason: "failure: ".concat(error.message)
+      };
+    }
 
-        this.defer.resolve();
+    /**
+     * Handles TURN_DISCOVERY_RESPONSE roap message that came in http response. If the response is not valid,
+     * it returns an object with turnServerInfo set to undefined. In that case you need to call abort()
+     * to end the TURN discovery process.
+     *
+     * @param {Meeting} meeting
+     * @param {Object|undefined} httpResponse can be undefined to indicate that we didn't get the response
+     * @returns {Promise<TurnDiscoveryResult>}
+     * @memberof Roap
+     */
+  }, {
+    key: "handleTurnDiscoveryHttpResponse",
+    value: function () {
+      var _handleTurnDiscoveryHttpResponse = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(meeting, httpResponse) {
+        var roapMessage, _yield$this$defer$pro, isOkRequired;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              if (this.defer) {
+                _context2.next = 3;
+                break;
+              }
+              _loggerProxy.default.logger.warn('Roap:turnDiscovery#handleTurnDiscoveryHttpResponse --> unexpected http response, TURN discovery is not in progress');
+              throw new Error('handleTurnDiscoveryHttpResponse() called before generateTurnDiscoveryRequestMessage()');
+            case 3:
+              if (!(httpResponse === undefined)) {
+                _context2.next = 5;
+                break;
+              }
+              return _context2.abrupt("return", {
+                turnServerInfo: undefined,
+                turnDiscoverySkippedReason: TurnDiscoverySkipReason.missingHttpResponse
+              });
+            case 5:
+              _context2.prev = 5;
+              roapMessage = this.parseHttpTurnDiscoveryResponse(meeting, httpResponse);
+              if (roapMessage) {
+                _context2.next = 9;
+                break;
+              }
+              return _context2.abrupt("return", {
+                turnServerInfo: undefined,
+                turnDiscoverySkippedReason: TurnDiscoverySkipReason.missingHttpResponse
+              });
+            case 9:
+              this.handleTurnDiscoveryResponse(roapMessage, 'in http response');
+              _context2.next = 12;
+              return this.defer.promise;
+            case 12:
+              _yield$this$defer$pro = _context2.sent;
+              isOkRequired = _yield$this$defer$pro.isOkRequired;
+              if (!isOkRequired) {
+                _context2.next = 17;
+                break;
+              }
+              _context2.next = 17;
+              return this.sendRoapOK(meeting);
+            case 17:
+              this.defer = undefined;
+              _loggerProxy.default.logger.info('Roap:turnDiscovery#doTurnDiscovery --> TURN discovery completed');
+              return _context2.abrupt("return", {
+                turnServerInfo: this.turnInfo,
+                turnDiscoverySkippedReason: undefined
+              });
+            case 22:
+              _context2.prev = 22;
+              _context2.t0 = _context2["catch"](5);
+              this.abort();
+              return _context2.abrupt("return", this.handleTurnDiscoveryFailure(meeting, _context2.t0));
+            case 26:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[5, 22]]);
+      }));
+      function handleTurnDiscoveryHttpResponse(_x3, _x4) {
+        return _handleTurnDiscoveryHttpResponse.apply(this, arguments);
+      }
+      return handleTurnDiscoveryHttpResponse;
+    }()
+    /**
+     * Aborts current TURN discovery. This method needs to be called if you called generateTurnDiscoveryRequestMessage(),
+     * but then never got any response from the server.
+     * @returns {void}
+     */
+  }, {
+    key: "abort",
+    value: function abort() {
+      if (this.defer) {
+        this.defer.reject(new Error('TURN discovery aborted'));
+        this.defer = undefined;
       }
     }
+
+    /**
+     * Parses the TURN_DISCOVERY_RESPONSE roap message out of the http response
+     * and returns it.
+     *
+     * @param {Meeting} meeting
+     * @param {any} httpResponse
+     * @returns {any}
+     */
+  }, {
+    key: "parseHttpTurnDiscoveryResponse",
+    value: function parseHttpTurnDiscoveryResponse(meeting, httpResponse) {
+      var _httpResponse$mediaCo, _httpResponse$mediaCo2;
+      var turnDiscoveryResponse;
+      if ((_httpResponse$mediaCo = httpResponse.mediaConnections) !== null && _httpResponse$mediaCo !== void 0 && (_httpResponse$mediaCo2 = _httpResponse$mediaCo[0]) !== null && _httpResponse$mediaCo2 !== void 0 && _httpResponse$mediaCo2.remoteSdp) {
+        var remoteSdp = JSON.parse(httpResponse.mediaConnections[0].remoteSdp);
+        if (remoteSdp.roapMessage) {
+          // yes, it's misleading that remoteSdp actually contains a TURN discovery response, but that's how the backend works...
+          var _remoteSdp$roapMessag = remoteSdp.roapMessage,
+            seq = _remoteSdp$roapMessag.seq,
+            messageType = _remoteSdp$roapMessag.messageType,
+            errorType = _remoteSdp$roapMessag.errorType,
+            errorCause = _remoteSdp$roapMessag.errorCause,
+            headers = _remoteSdp$roapMessag.headers;
+          turnDiscoveryResponse = {
+            seq: seq,
+            messageType: messageType,
+            errorType: errorType,
+            errorCause: errorCause,
+            headers: headers
+          };
+        }
+      }
+      if (!turnDiscoveryResponse) {
+        _metrics.default.sendBehavioralMetric(_constants.default.ROAP_HTTP_RESPONSE_MISSING, {
+          correlationId: meeting.correlationId,
+          messageType: 'TURN_DISCOVERY_RESPONSE',
+          isMultistream: meeting.isMultistream
+        });
+      }
+      return turnDiscoveryResponse;
+    }
+
     /**
      * sends the TURN_DISCOVERY_REQUEST roap request
      *
@@ -156,41 +376,58 @@ var TurnDiscovery = /*#__PURE__*/function () {
      * @private
      * @memberof Roap
      */
-
   }, {
     key: "sendRoapTurnDiscoveryRequest",
     value: function sendRoapTurnDiscoveryRequest(meeting, isReconnecting) {
+      var _this2 = this;
       if (this.defer) {
         _loggerProxy.default.logger.warn('Roap:turnDiscovery#sendRoapTurnDiscoveryRequest --> already in progress');
-
-        return _promise.default.resolve();
+        return _promise.default.resolve({
+          turnServerInfo: undefined,
+          turnDiscoverySkippedReason: TurnDiscoverySkipReason.alreadyInProgress
+        });
       }
-
       this.defer = new _common.Defer();
       var roapMessage = {
         messageType: _constants2.ROAP.ROAP_TYPES.TURN_DISCOVERY_REQUEST,
         version: _constants2.ROAP.ROAP_VERSION,
-        seq: TURN_DISCOVERY_SEQ
+        seq: TURN_DISCOVERY_SEQ,
+        headers: ['includeAnswerInHttpResponse', 'noOkInTransaction']
       };
-
       _loggerProxy.default.logger.info('Roap:turnDiscovery#sendRoapTurnDiscoveryRequest --> sending TURN_DISCOVERY_REQUEST');
-
       return this.roapRequest.sendRoap({
         roapMessage: roapMessage,
-        correlationId: meeting.correlationId,
+        // @ts-ignore - Fix missing type
         locusSelfUrl: meeting.selfUrl,
+        // @ts-ignore - Fix missing type
         mediaId: isReconnecting ? '' : meeting.mediaId,
-        audioMuted: meeting.isAudioMuted(),
-        videoMuted: meeting.isVideoMuted(),
-        meetingId: meeting.id
-      }).then(function (_ref) {
-        var mediaConnections = _ref.mediaConnections;
-
-        if (mediaConnections) {
-          meeting.updateMediaConnections(mediaConnections);
-        }
-      });
+        meetingId: meeting.id,
+        locusMediaRequest: meeting.locusMediaRequest,
+        // @ts-ignore - because of meeting.webex
+        ipVersion: _util.default.getIpVersion(meeting.webex)
+      }).then( /*#__PURE__*/function () {
+        var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(response) {
+          var mediaConnections;
+          return _regenerator.default.wrap(function _callee3$(_context3) {
+            while (1) switch (_context3.prev = _context3.next) {
+              case 0:
+                mediaConnections = response.mediaConnections;
+                if (mediaConnections) {
+                  meeting.updateMediaConnections(mediaConnections);
+                }
+                return _context3.abrupt("return", _this2.handleTurnDiscoveryHttpResponse(meeting, response));
+              case 3:
+              case "end":
+                return _context3.stop();
+            }
+          }, _callee3);
+        }));
+        return function (_x5) {
+          return _ref.apply(this, arguments);
+        };
+      }());
     }
+
     /**
      * Sends the OK message that server expects to receive
      * after it sends us TURN_DISCOVERY_RESPONSE
@@ -198,26 +435,96 @@ var TurnDiscovery = /*#__PURE__*/function () {
      * @param {Meeting} meeting
      * @returns {Promise}
      */
-
   }, {
     key: "sendRoapOK",
     value: function sendRoapOK(meeting) {
-      _loggerProxy.default.logger.info('Roap:turnDiscovery#sendRoapOK --> sending OK');
-
+      _loggerProxy.default.logger.info('Roap:turnDiscovery#sendRoapOK --> TURN discovery response requires OK, sending it...');
+      _metrics.default.sendBehavioralMetric(_constants.default.TURN_DISCOVERY_REQUIRES_OK, {
+        correlation_id: meeting.correlationId,
+        locus_id: meeting.locusUrl.split('/').pop()
+      });
       return this.roapRequest.sendRoap({
         roapMessage: {
           messageType: _constants2.ROAP.ROAP_TYPES.OK,
           version: _constants2.ROAP.ROAP_VERSION,
           seq: TURN_DISCOVERY_SEQ
         },
+        // @ts-ignore - fix type
         locusSelfUrl: meeting.selfUrl,
+        // @ts-ignore - fix type
         mediaId: meeting.mediaId,
-        correlationId: meeting.correlationId,
-        audioMuted: meeting.isAudioMuted(),
-        videoMuted: meeting.isVideoMuted(),
-        meetingId: meeting.id
+        meetingId: meeting.id,
+        locusMediaRequest: meeting.locusMediaRequest
       });
     }
+
+    /**
+     * Gets the reason why reachability is skipped.
+     *
+     * @param {Meeting} meeting
+     * @returns {Promise<string>} Promise with empty string if reachability is not skipped or a reason if it is skipped
+     */
+  }, {
+    key: "getSkipReason",
+    value: function () {
+      var _getSkipReason = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(meeting) {
+        var isAnyPublicClusterReachable;
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return meeting.webex.meetings.reachability.isAnyPublicClusterReachable();
+            case 2:
+              isAnyPublicClusterReachable = _context4.sent;
+              if (!isAnyPublicClusterReachable) {
+                _context4.next = 6;
+                break;
+              }
+              _loggerProxy.default.logger.info('Roap:turnDiscovery#getSkipReason --> reachability has not failed, skipping TURN discovery');
+              return _context4.abrupt("return", TurnDiscoverySkipReason.reachability);
+            case 6:
+              return _context4.abrupt("return", undefined);
+            case 7:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4);
+      }));
+      function getSkipReason(_x6) {
+        return _getSkipReason.apply(this, arguments);
+      }
+      return getSkipReason;
+    }()
+    /**
+     * Checks if TURN discovery is skipped.
+     *
+     * @param {Meeting} meeting
+     * @returns {Boolean} true if TURN discovery is being skipped, false if it is being done
+     */
+  }, {
+    key: "isSkipped",
+    value: function () {
+      var _isSkipped = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(meeting) {
+        var skipReason;
+        return _regenerator.default.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.next = 2;
+              return this.getSkipReason(meeting);
+            case 2:
+              skipReason = _context5.sent;
+              return _context5.abrupt("return", !!skipReason);
+            case 4:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function isSkipped(_x7) {
+        return _isSkipped.apply(this, arguments);
+      }
+      return isSkipped;
+    }()
     /**
      * Retrieves TURN server information from the backend by doing
      * a roap message exchange:
@@ -231,69 +538,83 @@ var TurnDiscovery = /*#__PURE__*/function () {
      * 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}
      */
-
   }, {
     key: "doTurnDiscovery",
-    value: function doTurnDiscovery(meeting, isReconnecting) {
-      var _this2 = this;
-
-      var isAnyClusterReachable = meeting.webex.meetings.reachability.isAnyClusterReachable();
-
-      if (isAnyClusterReachable) {
-        _loggerProxy.default.logger.info('Roap:turnDiscovery#doTurnDiscovery --> reachability has not failed, skipping TURN discovery');
-
-        return _promise.default.resolve({
-          turnServerInfo: undefined,
-          turnDiscoverySkippedReason: 'reachability'
-        });
-      }
-
-      if (!meeting.config.experimental.enableTurnDiscovery) {
-        _loggerProxy.default.logger.info('Roap:turnDiscovery#doTurnDiscovery --> TURN discovery disabled in config, skipping it');
-
-        return _promise.default.resolve({
-          turnServerInfo: undefined,
-          turnDiscoverySkippedReason: 'config'
-        });
+    value: function () {
+      var _doTurnDiscovery = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(meeting, isReconnecting, isForced) {
+        var turnDiscoverySkippedReason, turnDiscoveryResult, _yield$this$waitForTu, isOkRequired;
+        return _regenerator.default.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              if (isForced) {
+                _context6.next = 4;
+                break;
+              }
+              _context6.next = 3;
+              return this.getSkipReason(meeting);
+            case 3:
+              turnDiscoverySkippedReason = _context6.sent;
+            case 4:
+              if (!turnDiscoverySkippedReason) {
+                _context6.next = 6;
+                break;
+              }
+              return _context6.abrupt("return", {
+                turnServerInfo: undefined,
+                turnDiscoverySkippedReason: turnDiscoverySkippedReason
+              });
+            case 6:
+              _context6.prev = 6;
+              _context6.next = 9;
+              return this.sendRoapTurnDiscoveryRequest(meeting, isReconnecting);
+            case 9:
+              turnDiscoveryResult = _context6.sent;
+              if (!(turnDiscoveryResult.turnDiscoverySkippedReason !== TurnDiscoverySkipReason.missingHttpResponse)) {
+                _context6.next = 12;
+                break;
+              }
+              return _context6.abrupt("return", turnDiscoveryResult);
+            case 12:
+              _context6.next = 14;
+              return this.waitForTurnDiscoveryResponse();
+            case 14:
+              _yield$this$waitForTu = _context6.sent;
+              isOkRequired = _yield$this$waitForTu.isOkRequired;
+              if (!isOkRequired) {
+                _context6.next = 19;
+                break;
+              }
+              _context6.next = 19;
+              return this.sendRoapOK(meeting);
+            case 19:
+              this.defer = undefined;
+              _loggerProxy.default.logger.info('Roap:turnDiscovery#doTurnDiscovery --> TURN discovery completed');
+              return _context6.abrupt("return", {
+                turnServerInfo: this.turnInfo,
+                turnDiscoverySkippedReason: undefined
+              });
+            case 24:
+              _context6.prev = 24;
+              _context6.t0 = _context6["catch"](6);
+              return _context6.abrupt("return", this.handleTurnDiscoveryFailure(meeting, _context6.t0));
+            case 27:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this, [[6, 24]]);
+      }));
+      function doTurnDiscovery(_x8, _x9, _x10) {
+        return _doTurnDiscovery.apply(this, arguments);
       }
-
-      return this.sendRoapTurnDiscoveryRequest(meeting, isReconnecting).then(function () {
-        return _this2.waitForTurnDiscoveryResponse();
-      }).then(function () {
-        return _this2.sendRoapOK(meeting);
-      }).then(function () {
-        _this2.defer = undefined;
-
-        _loggerProxy.default.logger.info('Roap:turnDiscovery#doTurnDiscovery --> TURN discovery completed');
-
-        return {
-          turnServerInfo: _this2.turnInfo,
-          turnDiscoverySkippedReason: undefined
-        };
-      }).catch(function (e) {
-        // we catch any errors and resolve with no turn information so that the normal call join flow can continue without TURN
-        _loggerProxy.default.logger.info("Roap:turnDiscovery#doTurnDiscovery --> TURN discovery failed, continuing without TURN: ".concat(e));
-
-        _metrics.default.sendBehavioralMetric(_constants.default.TURN_DISCOVERY_FAILURE, {
-          correlation_id: meeting.correlationId,
-          locus_id: meeting.locusUrl.split('/').pop(),
-          reason: e.message,
-          stack: e.stack
-        });
-
-        return _promise.default.resolve({
-          turnServerInfo: undefined,
-          turnDiscoverySkippedReason: undefined
-        });
-      });
-    }
+      return doTurnDiscovery;
+    }()
   }]);
   return TurnDiscovery;
 }();
-
 exports.default = TurnDiscovery;
 //# sourceMappingURL=turnDiscovery.js.map