@webex/plugin-meetings 3.0.0-beta.340 → 3.0.0-beta.342

package/dist/breakouts/breakout.js

@@ -209,7 +209,7 @@ var Breakout = _webexCore.WebexPlugin.extend({
       sessionId: this.sessionId
     });
   },
-  version: "3.0.0-beta.340"
+  version: "3.0.0-beta.342"
 });
 var _default = Breakout;
 exports.default = _default;

package/dist/breakouts/index.js

@@ -1041,7 +1041,7 @@ var Breakouts = _webexCore.WebexPlugin.extend({
       this.trigger(_constants.BREAKOUTS.EVENTS.ASK_RETURN_TO_MAIN);
     }
   },
-  version: "3.0.0-beta.340"
+  version: "3.0.0-beta.342"
 });
 var _default = Breakouts;
 exports.default = _default;

package/dist/index.js

@@ -128,6 +128,7 @@ _Object$defineProperty(exports, "getDevices", {
 var _webexCore = require("@webex/webex-core");
 var _meetings = _interopRequireDefault(require("./meetings"));
 var _config = _interopRequireDefault(require("./config"));
+var _interceptors = require("./interceptors");
 var _mediaHelpers = require("@webex/media-helpers");
 var _CONSTANTS = _interopRequireWildcard(require("./constants"));
 exports.CONSTANTS = _CONSTANTS;
@@ -140,7 +141,10 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 /* eslint-env browser */
 
 (0, _webexCore.registerPlugin)('meetings', _meetings.default, {
-  config: _config.default
+  config: _config.default,
+  interceptors: {
+    LocusRetryStatusInterceptor: _interceptors.LocusRetryStatusInterceptor.create
+  }
 });
 var _default = _meetings.default;
 exports.default = _default;

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["registerPlugin","Meetings","config"],"sources":["index.ts"],"sourcesContent":["/* eslint-env browser */\nimport {registerPlugin} from '@webex/webex-core';\n\nimport Meetings from './meetings';\nimport config from './config';\n\nregisterPlugin('meetings', Meetings, {\n  config,\n});\n\nexport {\n  getDevices,\n  LocalStream,\n  LocalDisplayStream,\n  LocalSystemAudioStream,\n  LocalStreamEventNames,\n  StreamEventNames,\n  type ServerMuteReason,\n  LocalMicrophoneStreamEventNames,\n  LocalCameraStreamEventNames,\n  LocalMicrophoneStream,\n  LocalCameraStream,\n  createMicrophoneStream,\n  createCameraStream,\n  createDisplayStream,\n  createDisplayStreamWithAudio,\n  FacingMode,\n  DisplaySurface,\n  PresetCameraConstraints,\n  type VideoContentHint,\n} from '@webex/media-helpers';\n\nexport default Meetings;\n\nexport * as CONSTANTS from './constants';\nexport * as REACTIONS from './reactions/reactions';\n\nexport {RemoteMedia} from './multistream/remoteMedia';\n\nexport {default as TriggerProxy} from './common/events/trigger-proxy';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA;AAEA;AACA;AAMA;AAoB8B;AAAA;AAAA;AAAA;AAO9B;AAEA;AAAsE;AAAA;AAvCtE;;AAMA,IAAAA,yBAAc,EAAC,UAAU,EAAEC,iBAAQ,EAAE;EACnCC,MAAM,EAANA;AACF,CAAC,CAAC;AAAC,eAwBYD,iBAAQ;AAAA"}
+{"version":3,"names":["registerPlugin","Meetings","config","interceptors","LocusRetryStatusInterceptor","create"],"sources":["index.ts"],"sourcesContent":["/* eslint-env browser */\nimport {registerPlugin} from '@webex/webex-core';\n\nimport Meetings from './meetings';\nimport config from './config';\nimport {LocusRetryStatusInterceptor} from './interceptors';\n\nregisterPlugin('meetings', Meetings, {\n  config,\n  interceptors: {\n    LocusRetryStatusInterceptor: LocusRetryStatusInterceptor.create,\n  },\n});\n\nexport {\n  getDevices,\n  LocalStream,\n  LocalDisplayStream,\n  LocalSystemAudioStream,\n  LocalStreamEventNames,\n  StreamEventNames,\n  type ServerMuteReason,\n  LocalMicrophoneStreamEventNames,\n  LocalCameraStreamEventNames,\n  LocalMicrophoneStream,\n  LocalCameraStream,\n  createMicrophoneStream,\n  createCameraStream,\n  createDisplayStream,\n  createDisplayStreamWithAudio,\n  FacingMode,\n  DisplaySurface,\n  PresetCameraConstraints,\n  type VideoContentHint,\n} from '@webex/media-helpers';\n\nexport default Meetings;\n\nexport * as CONSTANTS from './constants';\nexport * as REACTIONS from './reactions/reactions';\n\nexport {RemoteMedia} from './multistream/remoteMedia';\n\nexport {default as TriggerProxy} from './common/events/trigger-proxy';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA;AAEA;AACA;AACA;AASA;AAoB8B;AAAA;AAAA;AAAA;AAO9B;AAEA;AAAsE;AAAA;AA3CtE;;AAOA,IAAAA,yBAAc,EAAC,UAAU,EAAEC,iBAAQ,EAAE;EACnCC,MAAM,EAANA,eAAM;EACNC,YAAY,EAAE;IACZC,2BAA2B,EAAEA,yCAA2B,CAACC;EAC3D;AACF,CAAC,CAAC;AAAC,eAwBYJ,iBAAQ;AAAA"}

package/dist/interceptors/index.js

@@ -0,0 +1,15 @@
+"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
+});
+_Object$defineProperty(exports, "LocusRetryStatusInterceptor", {
+  enumerable: true,
+  get: function get() {
+    return _locusRetry.default;
+  }
+});
+var _locusRetry = _interopRequireDefault(require("./locusRetry"));
+//# sourceMappingURL=index.js.map

package/dist/interceptors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["import LocusRetryStatusInterceptor from './locusRetry';\n\nexport {LocusRetryStatusInterceptor};\n"],"mappings":";;;;;;;;;;;;;AAAA"}

package/dist/interceptors/locusRetry.js

@@ -0,0 +1,93 @@
+"use strict";
+
+var _Reflect$construct = require("@babel/runtime-corejs2/core-js/reflect/construct");
+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 _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/getPrototypeOf"));
+var _weakMap = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/weak-map"));
+var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
+var _httpCore = require("@webex/http-core");
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = _Reflect$construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !_Reflect$construct) return false; if (_Reflect$construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+var rateLimitExpiryTime = new _weakMap.default();
+/**
+ * @class
+ */
+var LocusRetryStatusInterceptor = /*#__PURE__*/function (_Interceptor) {
+  (0, _inherits2.default)(LocusRetryStatusInterceptor, _Interceptor);
+  var _super = _createSuper(LocusRetryStatusInterceptor);
+  function LocusRetryStatusInterceptor() {
+    (0, _classCallCheck2.default)(this, LocusRetryStatusInterceptor);
+    return _super.apply(this, arguments);
+  }
+  (0, _createClass2.default)(LocusRetryStatusInterceptor, [{
+    key: "onResponseError",
+    value:
+    /**
+     * Handle response errors
+     * @param {Object} options
+     * @param {WebexHttpError} reason
+     * @returns {Promise<WebexHttpError>}
+     */
+    function onResponseError(options, reason) {
+      if ((reason.statusCode === 503 || reason.statusCode === 429) && options.uri.includes('locus')) {
+        var hasRetriedLocusRequest = rateLimitExpiryTime.get(this);
+        var retryAfterTime = options.headers['retry-after'] || 2000;
+        if (hasRetriedLocusRequest) {
+          rateLimitExpiryTime.set(this, false);
+          return _promise.default.reject(options);
+        }
+        rateLimitExpiryTime.set(this, true);
+        return this.handleRetryRequestLocusServiceError(options, retryAfterTime);
+      }
+      return _promise.default.reject(reason);
+    }
+
+    /**
+     * Handle retries for locus service unavailable errors
+     * @param {Object} options associated with the request
+     * @param {number} retryAfterTime retry after time in milliseconds
+     * @returns {Promise}
+     */
+  }, {
+    key: "handleRetryRequestLocusServiceError",
+    value: function handleRetryRequestLocusServiceError(options, retryAfterTime) {
+      var _this = this;
+      return new _promise.default(function (resolve, reject) {
+        var timeout = setTimeout(function () {
+          clearTimeout(timeout);
+
+          // @ts-ignore
+          _this.webex.request({
+            method: options.method,
+            uri: options.uri,
+            body: options.body
+          }).then(resolve).catch(reject);
+        }, retryAfterTime);
+      });
+    }
+  }], [{
+    key: "create",
+    value:
+    /**
+     * @returns {LocusRetryStatusInterceptor}
+     */
+    function create() {
+      // @ts-ignore
+      return new LocusRetryStatusInterceptor({
+        webex: this
+      });
+    }
+  }]);
+  return LocusRetryStatusInterceptor;
+}(_httpCore.Interceptor);
+exports.default = LocusRetryStatusInterceptor;
+//# sourceMappingURL=locusRetry.js.map

package/dist/interceptors/locusRetry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["rateLimitExpiryTime","LocusRetryStatusInterceptor","options","reason","statusCode","uri","includes","hasRetriedLocusRequest","get","retryAfterTime","headers","set","reject","handleRetryRequestLocusServiceError","resolve","timeout","setTimeout","clearTimeout","webex","request","method","body","then","catch","Interceptor"],"sources":["locusRetry.ts"],"sourcesContent":["/*!\n * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.\n */\n\nimport {Interceptor} from '@webex/http-core';\n\nconst rateLimitExpiryTime = new WeakMap();\n/**\n * @class\n */\nexport default class LocusRetryStatusInterceptor extends Interceptor {\n  /**\n   * @returns {LocusRetryStatusInterceptor}\n   */\n  static create() {\n    // @ts-ignore\n    return new LocusRetryStatusInterceptor({webex: this});\n  }\n\n  /**\n   * Handle response errors\n   * @param {Object} options\n   * @param {WebexHttpError} reason\n   * @returns {Promise<WebexHttpError>}\n   */\n  onResponseError(options, reason) {\n    if ((reason.statusCode === 503 || reason.statusCode === 429) && options.uri.includes('locus')) {\n      const hasRetriedLocusRequest = rateLimitExpiryTime.get(this);\n      const retryAfterTime = options.headers['retry-after'] || 2000;\n\n      if (hasRetriedLocusRequest) {\n        rateLimitExpiryTime.set(this, false);\n\n        return Promise.reject(options);\n      }\n      rateLimitExpiryTime.set(this, true);\n\n      return this.handleRetryRequestLocusServiceError(options, retryAfterTime);\n    }\n\n    return Promise.reject(reason);\n  }\n\n  /**\n   * Handle retries for locus service unavailable errors\n   * @param {Object} options associated with the request\n   * @param {number} retryAfterTime retry after time in milliseconds\n   * @returns {Promise}\n   */\n  handleRetryRequestLocusServiceError(options, retryAfterTime) {\n    return new Promise((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        clearTimeout(timeout);\n\n        // @ts-ignore\n        this.webex\n          .request({\n            method: options.method,\n            uri: options.uri,\n            body: options.body,\n          })\n          .then(resolve)\n          .catch(reject);\n      }, retryAfterTime);\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAIA;AAA6C;AAAA;AAE7C,IAAMA,mBAAmB,GAAG,sBAAa;AACzC;AACA;AACA;AAFA,IAGqBC,2BAA2B;EAAA;EAAA;EAAA;IAAA;IAAA;EAAA;EAAA;IAAA;IAAA;IAS9C;AACF;AACA;AACA;AACA;AACA;IACE,yBAAgBC,OAAO,EAAEC,MAAM,EAAE;MAC/B,IAAI,CAACA,MAAM,CAACC,UAAU,KAAK,GAAG,IAAID,MAAM,CAACC,UAAU,KAAK,GAAG,KAAKF,OAAO,CAACG,GAAG,CAACC,QAAQ,CAAC,OAAO,CAAC,EAAE;QAC7F,IAAMC,sBAAsB,GAAGP,mBAAmB,CAACQ,GAAG,CAAC,IAAI,CAAC;QAC5D,IAAMC,cAAc,GAAGP,OAAO,CAACQ,OAAO,CAAC,aAAa,CAAC,IAAI,IAAI;QAE7D,IAAIH,sBAAsB,EAAE;UAC1BP,mBAAmB,CAACW,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC;UAEpC,OAAO,iBAAQC,MAAM,CAACV,OAAO,CAAC;QAChC;QACAF,mBAAmB,CAACW,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC;QAEnC,OAAO,IAAI,CAACE,mCAAmC,CAACX,OAAO,EAAEO,cAAc,CAAC;MAC1E;MAEA,OAAO,iBAAQG,MAAM,CAACT,MAAM,CAAC;IAC/B;;IAEA;AACF;AACA;AACA;AACA;AACA;EALE;IAAA;IAAA,OAMA,6CAAoCD,OAAO,EAAEO,cAAc,EAAE;MAAA;MAC3D,OAAO,qBAAY,UAACK,OAAO,EAAEF,MAAM,EAAK;QACtC,IAAMG,OAAO,GAAGC,UAAU,CAAC,YAAM;UAC/BC,YAAY,CAACF,OAAO,CAAC;;UAErB;UACA,KAAI,CAACG,KAAK,CACPC,OAAO,CAAC;YACPC,MAAM,EAAElB,OAAO,CAACkB,MAAM;YACtBf,GAAG,EAAEH,OAAO,CAACG,GAAG;YAChBgB,IAAI,EAAEnB,OAAO,CAACmB;UAChB,CAAC,CAAC,CACDC,IAAI,CAACR,OAAO,CAAC,CACbS,KAAK,CAACX,MAAM,CAAC;QAClB,CAAC,EAAEH,cAAc,CAAC;MACpB,CAAC,CAAC;IACJ;EAAC;IAAA;IAAA;IAtDD;AACF;AACA;IACE,kBAAgB;MACd;MACA,OAAO,IAAIR,2BAA2B,CAAC;QAACiB,KAAK,EAAE;MAAI,CAAC,CAAC;IACvD;EAAC;EAAA;AAAA,EAPsDM,qBAAW;AAAA"}

package/dist/interpretation/index.js

@@ -359,7 +359,7 @@ var SimultaneousInterpretation = _webexCore.WebexPlugin.extend({
       throw error;
     });
   },
-  version: "3.0.0-beta.340"
+  version: "3.0.0-beta.342"
 });
 var _default = SimultaneousInterpretation;
 exports.default = _default;

package/dist/interpretation/siLanguage.js

@@ -18,7 +18,7 @@ var SILanguage = _webexCore.WebexPlugin.extend({
     languageCode: 'number',
     languageName: 'string'
   },
-  version: "3.0.0-beta.340"
+  version: "3.0.0-beta.342"
 });
 var _default = SILanguage;
 exports.default = _default;

package/dist/types/interceptors/index.d.ts

@@ -0,0 +1,2 @@
+import LocusRetryStatusInterceptor from './locusRetry';
+export { LocusRetryStatusInterceptor };

package/dist/types/interceptors/locusRetry.d.ts

@@ -0,0 +1,27 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+import { Interceptor } from '@webex/http-core';
+/**
+ * @class
+ */
+export default class LocusRetryStatusInterceptor extends Interceptor {
+    /**
+     * @returns {LocusRetryStatusInterceptor}
+     */
+    static create(): LocusRetryStatusInterceptor;
+    /**
+     * Handle response errors
+     * @param {Object} options
+     * @param {WebexHttpError} reason
+     * @returns {Promise<WebexHttpError>}
+     */
+    onResponseError(options: any, reason: any): Promise<unknown>;
+    /**
+     * Handle retries for locus service unavailable errors
+     * @param {Object} options associated with the request
+     * @param {number} retryAfterTime retry after time in milliseconds
+     * @returns {Promise}
+     */
+    handleRetryRequestLocusServiceError(options: any, retryAfterTime: any): Promise<unknown>;
+}

package/dist/webinar/index.js

@@ -62,7 +62,7 @@ var Webinar = _webexCore.WebexPlugin.extend({
   updateCanManageWebcast: function updateCanManageWebcast(canManageWebcast) {
     this.set('canManageWebcast', canManageWebcast);
   },
-  version: "3.0.0-beta.340"
+  version: "3.0.0-beta.342"
 });
 var _default = Webinar;
 exports.default = _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/plugin-meetings",
-  "version": "3.0.0-beta.340",
+  "version": "3.0.0-beta.342",
   "description": "",
   "license": "Cisco EULA (https://www.cisco.com/c/en/us/products/end-user-license-agreement.html)",
   "contributors": [
@@ -33,12 +33,12 @@
   },
   "devDependencies": {
     "@peculiar/webcrypto": "^1.4.3",
-    "@webex/plugin-meetings": "3.0.0-beta.340",
-    "@webex/test-helper-chai": "3.0.0-beta.340",
-    "@webex/test-helper-mocha": "3.0.0-beta.340",
-    "@webex/test-helper-mock-webex": "3.0.0-beta.340",
-    "@webex/test-helper-retry": "3.0.0-beta.340",
-    "@webex/test-helper-test-users": "3.0.0-beta.340",
+    "@webex/plugin-meetings": "3.0.0-beta.342",
+    "@webex/test-helper-chai": "3.0.0-beta.342",
+    "@webex/test-helper-mocha": "3.0.0-beta.342",
+    "@webex/test-helper-mock-webex": "3.0.0-beta.342",
+    "@webex/test-helper-retry": "3.0.0-beta.342",
+    "@webex/test-helper-test-users": "3.0.0-beta.342",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "jsdom-global": "3.0.2",
@@ -47,19 +47,19 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@webex/common": "3.0.0-beta.340",
+    "@webex/common": "3.0.0-beta.342",
     "@webex/internal-media-core": "2.2.4",
-    "@webex/internal-plugin-conversation": "3.0.0-beta.340",
-    "@webex/internal-plugin-device": "3.0.0-beta.340",
-    "@webex/internal-plugin-llm": "3.0.0-beta.340",
-    "@webex/internal-plugin-mercury": "3.0.0-beta.340",
-    "@webex/internal-plugin-metrics": "3.0.0-beta.340",
-    "@webex/internal-plugin-support": "3.0.0-beta.340",
-    "@webex/internal-plugin-user": "3.0.0-beta.340",
-    "@webex/media-helpers": "3.0.0-beta.340",
-    "@webex/plugin-people": "3.0.0-beta.340",
-    "@webex/plugin-rooms": "3.0.0-beta.340",
-    "@webex/webex-core": "3.0.0-beta.340",
+    "@webex/internal-plugin-conversation": "3.0.0-beta.342",
+    "@webex/internal-plugin-device": "3.0.0-beta.342",
+    "@webex/internal-plugin-llm": "3.0.0-beta.342",
+    "@webex/internal-plugin-mercury": "3.0.0-beta.342",
+    "@webex/internal-plugin-metrics": "3.0.0-beta.342",
+    "@webex/internal-plugin-support": "3.0.0-beta.342",
+    "@webex/internal-plugin-user": "3.0.0-beta.342",
+    "@webex/media-helpers": "3.0.0-beta.342",
+    "@webex/plugin-people": "3.0.0-beta.342",
+    "@webex/plugin-rooms": "3.0.0-beta.342",
+    "@webex/webex-core": "3.0.0-beta.342",
     "ampersand-collection": "^2.0.2",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",

package/src/index.ts

@@ -3,9 +3,13 @@ import {registerPlugin} from '@webex/webex-core';
 
 import Meetings from './meetings';
 import config from './config';
+import {LocusRetryStatusInterceptor} from './interceptors';
 
 registerPlugin('meetings', Meetings, {
   config,
+  interceptors: {
+    LocusRetryStatusInterceptor: LocusRetryStatusInterceptor.create,
+  },
 });
 
 export {

package/src/interceptors/index.ts

@@ -0,0 +1,3 @@
+import LocusRetryStatusInterceptor from './locusRetry';
+
+export {LocusRetryStatusInterceptor};

package/src/interceptors/locusRetry.ts

@@ -0,0 +1,67 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {Interceptor} from '@webex/http-core';
+
+const rateLimitExpiryTime = new WeakMap();
+/**
+ * @class
+ */
+export default class LocusRetryStatusInterceptor extends Interceptor {
+  /**
+   * @returns {LocusRetryStatusInterceptor}
+   */
+  static create() {
+    // @ts-ignore
+    return new LocusRetryStatusInterceptor({webex: this});
+  }
+
+  /**
+   * Handle response errors
+   * @param {Object} options
+   * @param {WebexHttpError} reason
+   * @returns {Promise<WebexHttpError>}
+   */
+  onResponseError(options, reason) {
+    if ((reason.statusCode === 503 || reason.statusCode === 429) && options.uri.includes('locus')) {
+      const hasRetriedLocusRequest = rateLimitExpiryTime.get(this);
+      const retryAfterTime = options.headers['retry-after'] || 2000;
+
+      if (hasRetriedLocusRequest) {
+        rateLimitExpiryTime.set(this, false);
+
+        return Promise.reject(options);
+      }
+      rateLimitExpiryTime.set(this, true);
+
+      return this.handleRetryRequestLocusServiceError(options, retryAfterTime);
+    }
+
+    return Promise.reject(reason);
+  }
+
+  /**
+   * Handle retries for locus service unavailable errors
+   * @param {Object} options associated with the request
+   * @param {number} retryAfterTime retry after time in milliseconds
+   * @returns {Promise}
+   */
+  handleRetryRequestLocusServiceError(options, retryAfterTime) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        clearTimeout(timeout);
+
+        // @ts-ignore
+        this.webex
+          .request({
+            method: options.method,
+            uri: options.uri,
+            body: options.body,
+          })
+          .then(resolve)
+          .catch(reject);
+      }, retryAfterTime);
+    });
+  }
+}

package/test/unit/spec/interceptors/locusRetry.ts

@@ -0,0 +1,131 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+/* eslint-disable camelcase */
+import {assert} from '@webex/test-helper-chai';
+import { expect } from "@webex/test-helper-chai";
+import MockWebex from '@webex/test-helper-mock-webex';
+import {LocusRetryStatusInterceptor} from "@webex/plugin-meetings/src/interceptors";
+import {WebexHttpError} from '@webex/webex-core';
+import Meetings from '@webex/plugin-meetings';
+import sinon from 'sinon';
+
+describe('plugin-meetings', () => {
+    describe('Interceptors', () => {
+      describe('LocusRetryStatusInterceptor', () => { 
+        let interceptor, webex;
+        beforeEach(() => {
+            webex = new MockWebex({
+                children: {
+                    meeting: Meetings,
+                  },
+            });
+            interceptor = Reflect.apply(LocusRetryStatusInterceptor.create, {
+                sessionId: 'mock-webex_uuid',
+              }, []);
+          });  
+        describe('#onResponseError', () => {
+            const options = {
+                method: 'POST',
+                headers: {
+                    trackingid: 'test',
+                    'retry-after': 1000,
+                },
+                uri: `https://locus-test.webex.com/locus/api/v1/loci/call`,
+                body: 'foo'
+                };
+            const reason1 = new WebexHttpError.MethodNotAllowed({
+                statusCode: 403,
+                options: {
+                    headers: {
+                        trackingid: 'test',
+                        'retry-after': 1000,
+                    },    
+                    uri: `https://locus-test.webex.com/locus/api/v1/loci/call`,
+                    },
+                body: {
+                    error: 'POST not allwed',
+                },
+                });
+            const reason2 = new WebexHttpError.MethodNotAllowed({
+                statusCode: 503,
+                options: {
+                    headers: {
+                        trackingid: 'test',
+                        'retry-after': 1000,
+                    },    
+                    uri: `https://locus-test.webex.com/locus/api/v1/loci/call`,
+                    },
+                body: {
+                    error: 'Service Unavailable',
+                    },
+                });
+
+            it('rejects when not locus service unavailable error', () => {
+                return assert.isRejected(interceptor.onResponseError(options, reason1));
+            });
+
+            it('calls handleRetryRequestLocusServiceError with correct retry time when locus service unavailable error', () => {
+                interceptor.webex.request = sinon.stub().returns(Promise.resolve());
+                const handleRetryStub = sinon.stub(interceptor, 'handleRetryRequestLocusServiceError');
+                handleRetryStub.returns(Promise.resolve());
+
+                return interceptor.onResponseError(options, reason2).then(() => {
+                    expect(handleRetryStub.calledWith(options, 1000)).to.be.true;
+                    
+                });
+            });
+        });
+
+        describe('#handleRetryRequestLocusServiceError', () => {
+            const options = {
+                method: 'POST',
+                headers: {
+                    trackingid: 'test',
+                },
+                uri: `https://locus-test.webex.com/locus/api/v1/loci/call`,
+                body: 'foo'
+                };
+            const retryAfterTime = 2000;
+
+            it('returns the correct resolved value when the request is successful', () => {
+                const mockResponse = 'mock response'
+                interceptor.webex.request = sinon.stub().returns(Promise.resolve(mockResponse));
+          
+                return interceptor.handleRetryRequestLocusServiceError(options, retryAfterTime)
+                  .then((response) => {
+                    expect(response).to.equal(mockResponse);
+                  });
+              });
+
+            it('rejects the promise when the request is unsuccessful', () => {
+              const rejectionReason = 'Service Unavaialble after retry';
+    
+              interceptor.webex.request = sinon.stub().returns(Promise.reject(rejectionReason));
+        
+              return interceptor.handleRetryRequestLocusServiceError(options, retryAfterTime)
+                .catch((error) => {
+                  expect(error).to.equal(rejectionReason);
+                });
+            });
+
+            it('retries the request after the specified time', () => {
+                let clock;
+                clock = sinon.useFakeTimers();
+                const mockResponse = 'mock response'
+      
+                interceptor.webex.request = sinon.stub().returns(Promise.resolve(mockResponse));
+                const promise = interceptor.handleRetryRequestLocusServiceError(options, retryAfterTime);
+      
+                clock.tick(retryAfterTime);
+
+                return promise.then(() => {
+                    expect(interceptor.webex.request.calledOnce).to.be.true;
+                    });
+            });
+        });
+    });
+    });
+});
+