@webex/calling 3.12.0-next.92 → 3.12.0-next.94

package/dist/CallingClient/registration/register.js

@@ -37,6 +37,7 @@ var _SDKConnector = _interopRequireDefault(require("../../SDKConnector"));
 var _types3 = require("../../common/types");
 var _constants2 = require("../constants");
 var _types4 = require("../line/types");
+var _types5 = require("../../Errors/types");
 var _request = require("../utils/request");
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof _Symbol && r[_Symbol$iterator] || r["@@iterator"]; if (!t) { if (_Array$isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? _Array$from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
@@ -76,6 +77,13 @@ var Registration = exports.Registration = /*#__PURE__*/function () {
     (0, _defineProperty2.default)(this, "retryAfter", void 0);
     (0, _defineProperty2.default)(this, "scheduled429Retry", false);
     (0, _defineProperty2.default)(this, "webWorker", void 0);
+    /**
+     * Set once Mobius reports this session as superseded by another registration for the
+     * same user. It survives cleanup so that no automatic recovery path re-registers this
+     * device, which would restart the registration ping-pong between the two sessions.
+     * Only an explicit `triggerRegistration()` from the consumer clears it.
+     */
+    (0, _defineProperty2.default)(this, "sessionSuperseded", false);
     (0, _defineProperty2.default)(this, "apiRequest", void 0);
     this.jwe = jwe;
     this.sdkConnector = _SDKConnector.default;
@@ -490,6 +498,13 @@ var Registration = exports.Registration = /*#__PURE__*/function () {
                 file: _constants2.REGISTRATION_FILE,
                 method: _constants2.METHODS.HANDLE_409_KEEPALIVE_FAILURE
               };
+              /*
+               * Latch the terminal state before anything that can yield. Cleanup runs under the
+               * shared mutex, so it can be queued behind a recovery that is already registering;
+               * latching here means every registration path that has not started yet sees the
+               * superseded state rather than racing this cleanup.
+               */
+              this.sessionSuperseded = true;
               _Logger.default.warn("Stopping keepalive without re-registration, session superseded by another device for this user - keepaliveRetryCount: ".concat(keepaliveRetryCount), loggerContext);
 
               /* Stop the keepalive worker up front so no further keepalive is sent while cleanup waits on the mutex. */
@@ -1339,6 +1354,10 @@ var Registration = exports.Registration = /*#__PURE__*/function () {
                 method: _constants2.METHODS.TRIGGER_REGISTRATION
               };
               _Logger.default.info(_constants.METHOD_START_MESSAGE, loggerContext);
+
+              /* An explicit registration from the consumer is the only way out of a superseded
+               * session, so the terminal state is lifted here. */
+              this.sessionSuperseded = false;
               _context22.next = 1;
               return this.resumeFailover();
             case 1:
@@ -1412,21 +1431,40 @@ var Registration = exports.Registration = /*#__PURE__*/function () {
                 file: _constants2.REGISTRATION_FILE,
                 method: _constants2.REGISTER_UTIL
               };
+              /*
+               * Single choke point for every registration attempt - initial registration, restore,
+               * restart, the scheduled failover retries and failback all reach Mobius through here.
+               * Guarding it once means a superseded session cannot be re-registered by any
+               * automatic path, including one whose timer was already scheduled when the 409
+               * arrived. `true` is returned so callers treat it as a final error and schedule no
+               * further retries. `triggerRegistration()` clears the latch before calling in, so an
+               * explicit registration by the consumer is unaffected.
+               */
+              if (!this.sessionSuperseded) {
+                _context24.next = 1;
+                break;
+              }
+              _Logger.default.warn("Session superseded, skipping registration attempt - caller: ".concat(caller), {
+                file: _constants2.REGISTRATION_FILE,
+                method: caller
+              });
+              return _context24.abrupt("return", true);
+            case 1:
               abort = false;
               this.retryAfter = undefined;
               if (!this.failoverImmediately) {
-                _context24.next = 1;
+                _context24.next = 2;
                 break;
               }
               return _context24.abrupt("return", abort);
-            case 1:
+            case 2:
               if (!this.isDeviceRegistered()) {
-                _context24.next = 2;
+                _context24.next = 3;
                 break;
               }
               _Logger.default.info("[".concat(caller, "] : Device already registered with : ").concat(this.activeMobiusUrl), loggerContext);
               return _context24.abrupt("return", abort);
-            case 2:
+            case 3:
               /*
                * Align the active transport with this server group. When the Mobius socket is enabled
                * but a group has no WSS URL, CallingClient hands us its HTTP URIs instead; routing those
@@ -1438,7 +1476,7 @@ var Registration = exports.Registration = /*#__PURE__*/function () {
                 this.apiRequest.setSocketEnabled(servers[0].startsWith('wss://'));
               }
               _iterator2 = _createForOfIteratorHelper(servers);
-              _context24.prev = 3;
+              _context24.prev = 4;
               _loop = /*#__PURE__*/_regenerator.default.mark(function _loop() {
                 var url, serverType, _this8$deviceInfo$dev, _resp$headers, _resp$headers$trackin, _resp$headers2, _this8$deviceInfo$dev2, wssNormalizedUrl, resp, body, _yield$handleRegistra, finalError, shouldDisconnect, _t5;
                 return _regenerator.default.wrap(function (_context23) {
@@ -1549,40 +1587,40 @@ var Registration = exports.Registration = /*#__PURE__*/function () {
                 }, _loop, null, [[1, 5]]);
               });
               _iterator2.s();
-            case 4:
+            case 5:
               if ((_step2 = _iterator2.n()).done) {
-                _context24.next = 7;
+                _context24.next = 8;
                 break;
               }
-              return _context24.delegateYield(_loop(), "t0", 5);
-            case 5:
+              return _context24.delegateYield(_loop(), "t0", 6);
+            case 6:
               _ret = _context24.t0;
               if (!(_ret === 0)) {
-                _context24.next = 6;
+                _context24.next = 7;
                 break;
               }
-              return _context24.abrupt("continue", 7);
-            case 6:
-              _context24.next = 4;
-              break;
+              return _context24.abrupt("continue", 8);
             case 7:
-              _context24.next = 9;
+              _context24.next = 5;
               break;
             case 8:
-              _context24.prev = 8;
-              _t6 = _context24["catch"](3);
-              _iterator2.e(_t6);
+              _context24.next = 10;
+              break;
             case 9:
               _context24.prev = 9;
-              _iterator2.f();
-              return _context24.finish(9);
+              _t6 = _context24["catch"](4);
+              _iterator2.e(_t6);
             case 10:
-              return _context24.abrupt("return", abort);
+              _context24.prev = 10;
+              _iterator2.f();
+              return _context24.finish(10);
             case 11:
+              return _context24.abrupt("return", abort);
+            case 12:
             case "end":
               return _context24.stop();
           }
-        }, _callee23, this, [[3, 8, 9, 10]]);
+        }, _callee23, this, [[4, 9, 10, 11]]);
       }));
       function attemptRegistrationWithServers(_x17) {
         return _attemptRegistrationWithServers.apply(this, arguments);
@@ -1607,7 +1645,7 @@ var Registration = exports.Registration = /*#__PURE__*/function () {
               RETRY_COUNT_THRESHOLD = this.isCCFlow ? 4 : 5;
               _context27.next = 1;
               return this.mutex.runExclusive(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee25() {
-                var blob, blobUrl;
+                var blob, blobUrl, worker, isCurrentWorker;
                 return _regenerator.default.wrap(function (_context26) {
                   while (1) switch (_context26.prev = _context26.next) {
                     case 0:
@@ -1617,16 +1655,28 @@ var Registration = exports.Registration = /*#__PURE__*/function () {
                             type: 'application/javascript'
                           });
                           blobUrl = URL.createObjectURL(blob);
-                          _this9.webWorker = new Worker(blobUrl);
+                          worker = new Worker(blobUrl);
+                          _this9.webWorker = worker;
                           URL.revokeObjectURL(blobUrl);
-                          _this9.webWorker.postMessage({
+                          worker.postMessage({
                             type: _types3.WorkerMessageType.START_KEEPALIVE,
                             interval: interval,
                             retryCountThreshold: RETRY_COUNT_THRESHOLD
                           });
-                          _this9.webWorker.onmessage = /*#__PURE__*/function () {
+
+                          /*
+                           * A keepalive is in flight across an `await`, so this worker can be replaced
+                           * meanwhile - on failback, connection restoration or any re-registration. Its
+                           * result then belongs to a device that is no longer the registered one and must
+                           * not reach the current worker, whose retry count and failure handling (including
+                           * the 409 hard stop) would otherwise act on a stale registration.
+                           */
+                          isCurrentWorker = function isCurrentWorker() {
+                            return _this9.webWorker === worker;
+                          };
+                          worker.onmessage = /*#__PURE__*/function () {
                             var _ref11 = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee24(event) {
-                              var logContext, _this9$webWorker, res, _err$headers, _this9$webWorker2, error, _error, _yield$handleRegistra2, abort, handledByCallback, _t7;
+                              var logContext, res, _err$headers, error, _error, _yield$handleRegistra2, abort, _t7;
                               return _regenerator.default.wrap(function (_context25) {
                                 while (1) switch (_context25.prev = _context25.next) {
                                   case 0:
@@ -1634,24 +1684,38 @@ var Registration = exports.Registration = /*#__PURE__*/function () {
                                       file: _constants2.REGISTRATION_FILE,
                                       method: _constants2.KEEPALIVE_UTIL
                                     };
+                                    if (isCurrentWorker()) {
+                                      _context25.next = 1;
+                                      break;
+                                    }
+                                    _Logger.default.info('Ignoring message from a replaced keepalive worker', logContext);
+                                    return _context25.abrupt("return");
+                                  case 1:
                                     if (!(event.data.type === _types3.WorkerMessageType.SEND_KEEPALIVE)) {
-                                      _context25.next = 4;
+                                      _context25.next = 7;
                                       break;
                                     }
-                                    _context25.prev = 1;
-                                    _context25.next = 2;
+                                    _context25.prev = 2;
+                                    _context25.next = 3;
                                     return _this9.postKeepAlive(String(_this9.webex.internal.device.url), url);
-                                  case 2:
+                                  case 3:
                                     res = _context25.sent;
-                                    (_this9$webWorker = _this9.webWorker) === null || _this9$webWorker === void 0 ? void 0 : _this9$webWorker.postMessage({
+                                    if (isCurrentWorker()) {
+                                      _context25.next = 4;
+                                      break;
+                                    }
+                                    _Logger.default.info('Discarding keepalive result of a replaced worker', logContext);
+                                    return _context25.abrupt("return");
+                                  case 4:
+                                    worker.postMessage({
                                       type: _types3.WorkerMessageType.KEEPALIVE_RESULT,
                                       statusCode: res.statusCode
                                     });
-                                    _context25.next = 4;
+                                    _context25.next = 7;
                                     break;
-                                  case 3:
-                                    _context25.prev = 3;
-                                    _t7 = _context25["catch"](1);
+                                  case 5:
+                                    _context25.prev = 5;
+                                    _t7 = _context25["catch"](2);
                                     error = {
                                       headers: {
                                         trackingid: (_err$headers = _t7.headers) === null || _err$headers === void 0 ? void 0 : _err$headers.trackingid,
@@ -1661,22 +1725,29 @@ var Registration = exports.Registration = /*#__PURE__*/function () {
                                       statusText: _t7.statusText,
                                       type: _t7.type
                                     };
-                                    (_this9$webWorker2 = _this9.webWorker) === null || _this9$webWorker2 === void 0 ? void 0 : _this9$webWorker2.postMessage({
+                                    if (isCurrentWorker()) {
+                                      _context25.next = 6;
+                                      break;
+                                    }
+                                    _Logger.default.info("Discarding keepalive failure of a replaced worker, status -> ".concat(error.statusCode), logContext);
+                                    return _context25.abrupt("return");
+                                  case 6:
+                                    worker.postMessage({
                                       type: _types3.WorkerMessageType.KEEPALIVE_RESULT,
                                       err: error
                                     });
-                                  case 4:
+                                  case 7:
                                     if (event.data.type === _types3.WorkerMessageType.KEEPALIVE_SUCCESS) {
                                       _Logger.default.info("Sent Keepalive, status: ".concat(event.data.statusCode), logContext);
                                       _this9.lineEmitter(_types4.LINE_EVENTS.RECONNECTED);
                                     }
                                     if (!(event.data.type === _types3.WorkerMessageType.KEEPALIVE_FAILURE)) {
-                                      _context25.next = 12;
+                                      _context25.next = 15;
                                       break;
                                     }
                                     _error = event.data.err;
                                     _Logger.default.warn("Keep-alive missed ".concat(event.data.keepAliveRetryCount, " times. Status -> ").concat(_error.statusCode, " "), logContext);
-                                    _context25.next = 5;
+                                    _context25.next = 8;
                                     return (0, _common.handleRegistrationErrors)(_error, function (clientError, finalError) {
                                       var _error$headers$tracki2, _error$headers2;
                                       if (finalError) {
@@ -1694,18 +1765,17 @@ var Registration = exports.Registration = /*#__PURE__*/function () {
                                         return _this9.handle409KeepaliveFailure(clientError, _error, serverType, event.data.keepAliveRetryCount);
                                       }
                                     });
-                                  case 5:
+                                  case 8:
                                     _yield$handleRegistra2 = _context25.sent;
                                     abort = _yield$handleRegistra2.finalError;
-                                    handledByCallback = _yield$handleRegistra2.handledByCallback;
-                                    if (!handledByCallback) {
-                                      _context25.next = 6;
+                                    if (!(abort && Number(_error.statusCode) === _types5.ERROR_CODE.CONFLICT)) {
+                                      _context25.next = 9;
                                       break;
                                     }
                                     return _context25.abrupt("return");
-                                  case 6:
+                                  case 9:
                                     if (!(abort || event.data.keepAliveRetryCount >= RETRY_COUNT_THRESHOLD)) {
-                                      _context25.next = 11;
+                                      _context25.next = 14;
                                       break;
                                     }
                                     _this9.failoverImmediately = _this9.isCCFlow;
@@ -1713,32 +1783,32 @@ var Registration = exports.Registration = /*#__PURE__*/function () {
                                     _this9.clearKeepaliveTimer();
                                     _this9.clearFailbackTimer();
                                     _this9.lineEmitter(_types4.LINE_EVENTS.UNREGISTERED);
-                                    _context25.next = 7;
+                                    _context25.next = 10;
                                     return (0, _common.uploadLogs)();
-                                  case 7:
+                                  case 10:
                                     if (abort) {
-                                      _context25.next = 9;
+                                      _context25.next = 12;
                                       break;
                                     }
-                                    _context25.next = 8;
+                                    _context25.next = 11;
                                     return _this9.reconnectOnFailure(_constants2.RECONNECT_ON_FAILURE_UTIL);
-                                  case 8:
-                                    _context25.next = 10;
+                                  case 11:
+                                    _context25.next = 13;
                                     break;
-                                  case 9:
+                                  case 12:
                                     if (_error.statusCode === 404) {
                                       _this9.handle404KeepaliveFailure(_constants2.KEEPALIVE_UTIL);
                                     }
-                                  case 10:
-                                    _context25.next = 12;
+                                  case 13:
+                                    _context25.next = 15;
                                     break;
-                                  case 11:
+                                  case 14:
                                     _this9.lineEmitter(_types4.LINE_EVENTS.RECONNECTING);
-                                  case 12:
+                                  case 15:
                                   case "end":
                                     return _context25.stop();
                                 }
-                              }, _callee24, null, [[1, 3]]);
+                              }, _callee24, null, [[2, 5]]);
                             }));
                             return function (_x21) {
                               return _ref11.apply(this, arguments);