matrix-js-sdk 37.2.0 → 37.3.0-rc.0

package/lib/matrixrtc/NewMembershipManager.js

@@ -23,63 +23,63 @@ import { ConnectionError, HTTPError, MatrixError } from "../http-api/errors.js";
 import { logger as rootLogger } from "../logger.js";
 import { defer } from "../utils.js";
 import { DEFAULT_EXPIRE_DURATION } from "./CallMembership.js";
+import { MembershipManagerEvent, Status } from "./types.js";
 import { isLivekitFocusActive } from "./LivekitFocus.js";
 import { ActionScheduler } from "./NewMembershipManagerActionScheduler.js";
+import { TypedEventEmitter } from "../models/typed-event-emitter.js";
 var logger = rootLogger.getChild("MatrixRTCSession");
 
-/**
- * This interface defines what a MembershipManager uses and exposes.
- * This interface is what we use to write tests and allows changing the actual implementation
- * without breaking tests because of some internal method renaming.
- *
- * @internal
- */
-
 /* MembershipActionTypes:
-                           ▼
-                 ┌─────────────────────┐
-                 │SendFirstDelayedEvent│
-                 └─────────────────────┘
-                           │
-                           ▼
-                    ┌─────────────┐
-       ┌────────────│SendJoinEvent│────────────┐
-       │            └─────────────┘            │
-       │  ┌─────┐                  ┌──────┐    │    ┌──────┐
-       ▼  ▼     │                  │      ▼    ▼    ▼      │
+                           
+On Join:  ───────────────┐   ┌───────────────(1)───────────┐
+                         ▼   ▼                             │
+                   ┌────────────────┐                      │
+                   │SendDelayedEvent│ ──────(2)───┐        │
+                   └────────────────┘             │        │ 
+                           │(3)                   │        │
+                           ▼                      │        │
+                    ┌─────────────┐               │        │
+       ┌──────(4)───│SendJoinEvent│────(4)─────┐  │        │
+       │            └─────────────┘            │  │        │
+       │  ┌─────┐                  ┌──────┐    │  │        │
+       ▼  ▼     │                  │      ▼    ▼  ▼        │
 ┌────────────┐  │                  │ ┌───────────────────┐ │
-│UpdateExpiry│  │                  │ │RestartDelayedEvent│ │
+│UpdateExpiry│ (s)                (s)|RestartDelayedEvent│ │
 └────────────┘  │                  │ └───────────────────┘ │
-          │     │                  │      │    │           │
-          └─────┘                  └──────┘    │           │
-                                               │           │
-                 ┌────────────────────┐        │           │
-                 │SendMainDelayedEvent│◄───────┘           │
-                 └───────────────────┬┘                    │
-                                     │                     │
-                                     └─────────────────────┘
-                     STOP ALL ABOVE
+          │     │                  │      │        │       │       
+          └─────┘                  └──────┘        └───────┘ 
+     
+On Leave: ─────────  STOP ALL ABOVE
                            ▼
-            ┌───────────────────────────────┐
-            │ SendScheduledDelayedLeaveEvent│
-            └───────────────────────────────┘
-                           │
+            ┌────────────────────────────────┐
+            │ SendScheduledDelayedLeaveEvent │
+            └────────────────────────────────┘
+                           │(5)
                            ▼
                     ┌──────────────┐
                     │SendLeaveEvent│
                     └──────────────┘
-
+(1) [Not found error] results in resending the delayed event
+(2) [hasMemberEvent = true] Sending the delayed event if we
+    already have a call member event results jumping to the
+    RestartDelayedEvent loop directly
+(3) [hasMemberEvent = false] if there is not call member event
+    sending it is the next step
+(4) Both (UpdateExpiry and RestartDelayedEvent) actions are
+    scheduled when successfully sending the state event
+(5) Only if delayed event sending failed (fallback)
+(s) Successful restart/resend
 */
+
 /**
  * The different types of actions the MembershipManager can take.
  * @internal
  */
 export var MembershipActionType = /*#__PURE__*/function (MembershipActionType) {
-  MembershipActionType["SendFirstDelayedEvent"] = "SendFirstDelayedEvent";
+  MembershipActionType["SendDelayedEvent"] = "SendDelayedEvent";
   MembershipActionType["SendJoinEvent"] = "SendJoinEvent";
   MembershipActionType["RestartDelayedEvent"] = "RestartDelayedEvent";
   MembershipActionType["UpdateExpiry"] = "UpdateExpiry";
-  MembershipActionType["SendMainDelayedEvent"] = "SendMainDelayedEvent";
   MembershipActionType["SendScheduledDelayedLeaveEvent"] = "SendScheduledDelayedLeaveEvent";
   MembershipActionType["SendLeaveEvent"] = "SendLeaveEvent";
   return MembershipActionType;
@@ -88,17 +88,7 @@ export var MembershipActionType = /*#__PURE__*/function (MembershipActionType) {
 /**
  * @internal
  */
-var Status = /*#__PURE__*/function (Status) {
-  Status["Disconnected"] = "Disconnected";
-  Status["Connecting"] = "Connecting";
-  Status["ConnectingFailed"] = "ConnectingFailed";
-  Status["Connected"] = "Connected";
-  Status["Reconnecting"] = "Reconnecting";
-  Status["Disconnecting"] = "Disconnecting";
-  Status["Stuck"] = "Stuck";
-  Status["Unknown"] = "Unknown";
-  return Status;
-}(Status || {});
+
 /**
  * This class is responsible for sending all events relating to the own membership of a matrixRTC call.
  * It has the following tasks:
@@ -112,10 +102,14 @@ var Status = /*#__PURE__*/function (Status) {
  *   - Stop the timer for the delay refresh
  *   - Stop the timer for updating the state event
  */
-export class MembershipManager {
-  isJoined() {
+export class MembershipManager extends TypedEventEmitter {
+  isActivated() {
     return this.activated;
   }
+  // DEPRECATED use isActivated
+  isJoined() {
+    return this.isActivated();
+  }
 
   /**
    * Puts the MembershipManager in a state where it tries to be joined.
@@ -134,19 +128,24 @@ export class MembershipManager {
     this.focusActive = focusActive;
     this.leavePromiseDefer = undefined;
     this.activated = true;
+    this.oldStatus = this.status;
     this.state = MembershipManager.defaultState;
-    this.scheduler.startWithJoin().then(() => {
+    this.scheduler.startWithJoin().catch(e => {
+      logger.error("MembershipManager stopped because: ", e);
+      onError === null || onError === void 0 || onError(e);
+    }).finally(() => {
+      // Should already be set to false when calling `leave` in non error cases.
+      this.activated = false;
+      // Here the scheduler is not running anymore so we the `membershipLoopHandler` is not called to emit.
+      if (this.oldStatus && this.oldStatus !== this.status) {
+        this.emit(MembershipManagerEvent.StatusChanged, this.oldStatus, this.status);
+      }
       if (!this.scheduler.running) {
         var _this$leavePromiseDef;
         (_this$leavePromiseDef = this.leavePromiseDefer) === null || _this$leavePromiseDef === void 0 || _this$leavePromiseDef.resolve(true);
         this.leavePromiseDefer = undefined;
       }
-    }).catch(e => {
-      logger.error("MembershipManager stopped because: ", e);
-      onError === null || onError === void 0 || onError(e);
-    })
-    // Should already be set to false when calling `leave` in non error cases.
-    .finally(() => this.activated = false);
+    });
   }
 
   /**
@@ -181,7 +180,7 @@ export class MembershipManager {
       if (_this.isJoined() && !memberships.some(isMyMembership)) {
         // If one of these actions are scheduled or are getting inserted in the next iteration, we should already
         // take care of our missing membership.
-        var sendingMembershipActions = [MembershipActionType.SendFirstDelayedEvent, MembershipActionType.SendJoinEvent];
+        var sendingMembershipActions = [MembershipActionType.SendDelayedEvent, MembershipActionType.SendJoinEvent];
         logger.warn("Missing own membership: force re-join");
         if (_this.scheduler.actions.find(a => sendingMembershipActions.includes(a.type))) {
           logger.error("NewMembershipManger tried adding another `SendFirstDelayedEvent` actions even though we already have one in the Queue\nActionQueueOnMemberUpdate:", _this.scheduler.actions);
@@ -221,6 +220,7 @@ export class MembershipManager {
    * @param getOldestMembership
    */
   constructor(joinConfig, room, client, getOldestMembership) {
+    super();
     this.joinConfig = joinConfig;
     this.room = room;
     this.client = client;
@@ -240,9 +240,13 @@ export class MembershipManager {
     _defineProperty(this, "oldStatus", void 0);
     _defineProperty(this, "scheduler", new ActionScheduler(type => {
       if (this.oldStatus) {
-        //  we put this at the beginning of the actions scheduler loop handle callback since it is a loop this
+        // we put this at the beginning of the actions scheduler loop handle callback since it is a loop this
         // is equivalent to running it at the end of the loop. (just after applying the status/action list changes)
+        // This order is required because this method needs to return the action updates.
         logger.debug("MembershipManager applied action changes. Status: ".concat(this.oldStatus, " -> ").concat(this.status));
+        if (this.oldStatus !== this.status) {
+          this.emit(MembershipManagerEvent.StatusChanged, this.oldStatus, this.status);
+        }
       }
       this.oldStatus = this.status;
       logger.debug("MembershipManager before processing action. status=".concat(this.oldStatus));
@@ -300,18 +304,17 @@ export class MembershipManager {
   membershipLoopHandler(type) {
     var _this2 = this;
     return _asyncToGenerator(function* () {
-      _this2.oldStatus = _this2.status;
       switch (type) {
-        case MembershipActionType.SendFirstDelayedEvent:
+        case MembershipActionType.SendDelayedEvent:
           {
             // Before we start we check if we come from a state where we have a delay id.
             if (!_this2.state.delayId) {
-              return _this2.sendFirstDelayedLeaveEvent(); // Normal case without any previous delayed id.
+              return _this2.sendOrResendDelayedLeaveEvent(); // Normal case without any previous delayed id.
             } else {
               // This can happen if someone else (or another client) removes our own membership event.
               // It will trigger `onRTCSessionMemberUpdate` queue `MembershipActionType.SendFirstDelayedEvent`.
               // We might still have our delayed event from the previous participation and dependent on the server this might not
-              // get automatically removed if the state changes. Hence It would remove our membership unexpectedly shortly after the rejoin.
+              // get removed automatically if the state changes. Hence, it would remove our membership unexpectedly shortly after the rejoin.
               //
               // In this block we will try to cancel this delayed event before setting up a new one.
 
@@ -322,14 +325,10 @@ export class MembershipManager {
           {
             if (!_this2.state.delayId) {
               // Delay id got reset. This action was used to check if the hs canceled the delayed event when the join state got sent.
-              return createInsertActionUpdate(_this2.state.hasMemberStateEvent ? MembershipActionType.SendMainDelayedEvent : MembershipActionType.SendFirstDelayedEvent);
+              return createInsertActionUpdate(MembershipActionType.SendDelayedEvent);
             }
             return _this2.restartDelayedEvent(_this2.state.delayId);
           }
-        case MembershipActionType.SendMainDelayedEvent:
-          {
-            return _this2.sendMainDelayedEvent();
-          }
         case MembershipActionType.SendScheduledDelayedLeaveEvent:
           {
             // We are already good
@@ -369,35 +368,54 @@ export class MembershipManager {
   }
 
   // HANDLERS (used in the membershipLoopHandler)
-  sendFirstDelayedLeaveEvent() {
+  sendOrResendDelayedLeaveEvent() {
     var _this3 = this;
     return _asyncToGenerator(function* () {
+      // We can reach this at the start of a call (where we do not yet have a membership: state.hasMemberStateEvent=false)
+      // or during a call if the state event canceled our delayed event or caused by an unexpected error that removed our delayed event.
+      // (Another client could have canceled it, the homeserver might have removed/lost it due to a restart, ...)
+      // In the `then` and `catch` block we treat both cases differently. "if (this.state.hasMemberStateEvent) {} else {}"
       return yield _this3.client._unstable_sendDelayedStateEvent(_this3.room.roomId, {
         delay: _this3.membershipServerSideExpiryTimeout
       }, EventType.GroupCallMemberPrefix, {},
       // leave event
       _this3.stateKey).then(response => {
         // On success we reset retries and set delayId.
-        _this3.state.rateLimitRetries.set(MembershipActionType.SendFirstDelayedEvent, 0);
-        _this3.state.networkErrorRetries.set(MembershipActionType.SendFirstDelayedEvent, 0);
+        _this3.resetRateLimitCounter(MembershipActionType.SendDelayedEvent);
         _this3.state.delayId = response.delay_id;
-        return createInsertActionUpdate(MembershipActionType.SendJoinEvent);
+        if (_this3.state.hasMemberStateEvent) {
+          // This action was scheduled because the previous delayed event was cancelled
+          // due to lack of https://github.com/element-hq/synapse/pull/17810
+          return createInsertActionUpdate(MembershipActionType.RestartDelayedEvent, _this3.membershipKeepAlivePeriod);
+        } else {
+          // This action was scheduled because we are in the process of joining
+          return createInsertActionUpdate(MembershipActionType.SendJoinEvent);
+        }
       }).catch(e => {
-        var repeatActionType = MembershipActionType.SendFirstDelayedEvent;
+        var repeatActionType = MembershipActionType.SendDelayedEvent;
         if (_this3.manageMaxDelayExceededSituation(e)) {
           return createInsertActionUpdate(repeatActionType);
         }
         var update = _this3.actionUpdateFromErrors(e, repeatActionType, "sendDelayedStateEvent");
         if (update) return update;
+        if (_this3.state.hasMemberStateEvent) {
+          // This action was scheduled because the previous delayed event was cancelled
+          // due to lack of https://github.com/element-hq/synapse/pull/17810
 
-        // log and fall through
-        if (_this3.isUnsupportedDelayedEndpoint(e)) {
-          logger.info("Not using delayed event because the endpoint is not supported");
+          // Don't do any other delayed event work if its not supported.
+          if (_this3.isUnsupportedDelayedEndpoint(e)) return {};
+          throw Error("Could not send delayed event, even though delayed events are supported. " + e);
         } else {
-          logger.info("Not using delayed event because: " + e);
+          // This action was scheduled because we are in the process of joining
+          // log and fall through
+          if (_this3.isUnsupportedDelayedEndpoint(e)) {
+            logger.info("Not using delayed event because the endpoint is not supported");
+          } else {
+            logger.info("Not using delayed event because: " + e);
+          }
+          // On any other error we fall back to not using delayed events and send the join state event immediately
+          return createInsertActionUpdate(MembershipActionType.SendJoinEvent);
         }
-        // On any other error we fall back to not using delayed events and send the join state event immediately
-        return createInsertActionUpdate(MembershipActionType.SendJoinEvent);
       });
     })();
   }
@@ -407,10 +425,10 @@ export class MembershipManager {
       // Remove all running updates and restarts
       return yield _this4.client._unstable_updateDelayedEvent(delayId, UpdateDelayedEventAction.Cancel).then(() => {
         _this4.state.delayId = undefined;
-        _this4.resetRateLimitCounter(MembershipActionType.SendFirstDelayedEvent);
-        return createReplaceActionUpdate(MembershipActionType.SendFirstDelayedEvent);
+        _this4.resetRateLimitCounter(MembershipActionType.SendDelayedEvent);
+        return createReplaceActionUpdate(MembershipActionType.SendDelayedEvent);
       }).catch(e => {
-        var repeatActionType = MembershipActionType.SendFirstDelayedEvent;
+        var repeatActionType = MembershipActionType.SendDelayedEvent;
         var update = _this4.actionUpdateFromErrors(e, repeatActionType, "updateDelayedEvent");
         if (update) return update;
         if (_this4.isNotFoundError(e)) {
@@ -442,7 +460,7 @@ export class MembershipManager {
         var repeatActionType = MembershipActionType.RestartDelayedEvent;
         if (_this5.isNotFoundError(e)) {
           _this5.state.delayId = undefined;
-          return createInsertActionUpdate(MembershipActionType.SendMainDelayedEvent);
+          return createInsertActionUpdate(MembershipActionType.SendDelayedEvent);
         }
         // If the HS does not support delayed events we wont reschedule.
         if (_this5.isUnsupportedDelayedEndpoint(e)) return {};
@@ -456,47 +474,23 @@ export class MembershipManager {
       });
     })();
   }
-  sendMainDelayedEvent() {
-    var _this6 = this;
-    return _asyncToGenerator(function* () {
-      return yield _this6.client._unstable_sendDelayedStateEvent(_this6.room.roomId, {
-        delay: _this6.membershipServerSideExpiryTimeout
-      }, EventType.GroupCallMemberPrefix, {},
-      // leave event
-      _this6.stateKey).then(response => {
-        _this6.state.delayId = response.delay_id;
-        _this6.resetRateLimitCounter(MembershipActionType.SendMainDelayedEvent);
-        return createInsertActionUpdate(MembershipActionType.RestartDelayedEvent, _this6.membershipKeepAlivePeriod);
-      }).catch(e => {
-        var repeatActionType = MembershipActionType.SendMainDelayedEvent;
-        // Don't do any other delayed event work if its not supported.
-        if (_this6.isUnsupportedDelayedEndpoint(e)) return {};
-        if (_this6.manageMaxDelayExceededSituation(e)) {
-          return createInsertActionUpdate(repeatActionType);
-        }
-        var update = _this6.actionUpdateFromErrors(e, repeatActionType, "updateDelayedEvent");
-        if (update) return update;
-        throw Error("Could not send delayed event, even though delayed events are supported. " + e);
-      });
-    })();
-  }
   sendScheduledDelayedLeaveEventOrFallbackToSendLeaveEvent(delayId) {
-    var _this7 = this;
+    var _this6 = this;
     return _asyncToGenerator(function* () {
-      return yield _this7.client._unstable_updateDelayedEvent(delayId, UpdateDelayedEventAction.Send).then(() => {
-        _this7.state.hasMemberStateEvent = false;
-        _this7.resetRateLimitCounter(MembershipActionType.SendScheduledDelayedLeaveEvent);
+      return yield _this6.client._unstable_updateDelayedEvent(delayId, UpdateDelayedEventAction.Send).then(() => {
+        _this6.state.hasMemberStateEvent = false;
+        _this6.resetRateLimitCounter(MembershipActionType.SendScheduledDelayedLeaveEvent);
         return {
           replace: []
         };
       }).catch(e => {
         var repeatActionType = MembershipActionType.SendLeaveEvent;
-        if (_this7.isUnsupportedDelayedEndpoint(e)) return {};
-        if (_this7.isNotFoundError(e)) {
-          _this7.state.delayId = undefined;
+        if (_this6.isUnsupportedDelayedEndpoint(e)) return {};
+        if (_this6.isNotFoundError(e)) {
+          _this6.state.delayId = undefined;
           return createInsertActionUpdate(repeatActionType);
         }
-        var update = _this7.actionUpdateFromErrors(e, repeatActionType, "updateDelayedEvent");
+        var update = _this6.actionUpdateFromErrors(e, repeatActionType, "updateDelayedEvent");
         if (update) return update;
 
         // On any other error we fall back to SendLeaveEvent (this includes hard errors from rate limiting)
@@ -506,62 +500,62 @@ export class MembershipManager {
     })();
   }
   sendJoinEvent() {
-    var _this8 = this;
+    var _this7 = this;
     return _asyncToGenerator(function* () {
-      return yield _this8.client.sendStateEvent(_this8.room.roomId, EventType.GroupCallMemberPrefix, _this8.makeMyMembership(_this8.membershipEventExpiryTimeout), _this8.stateKey).then(() => {
-        _this8.state.startTime = Date.now();
+      return yield _this7.client.sendStateEvent(_this7.room.roomId, EventType.GroupCallMemberPrefix, _this7.makeMyMembership(_this7.membershipEventExpiryTimeout), _this7.stateKey).then(() => {
+        _this7.state.startTime = Date.now();
         // The next update should already use twice the membershipEventExpiryTimeout
-        _this8.state.expireUpdateIterations = 1;
-        _this8.state.hasMemberStateEvent = true;
-        _this8.resetRateLimitCounter(MembershipActionType.SendJoinEvent);
+        _this7.state.expireUpdateIterations = 1;
+        _this7.state.hasMemberStateEvent = true;
+        _this7.resetRateLimitCounter(MembershipActionType.SendJoinEvent);
         return {
           insert: [{
             ts: Date.now(),
             type: MembershipActionType.RestartDelayedEvent
           }, {
-            ts: _this8.computeNextExpiryActionTs(_this8.state.expireUpdateIterations),
+            ts: _this7.computeNextExpiryActionTs(_this7.state.expireUpdateIterations),
             type: MembershipActionType.UpdateExpiry
           }]
         };
       }).catch(e => {
-        var update = _this8.actionUpdateFromErrors(e, MembershipActionType.SendJoinEvent, "sendStateEvent");
+        var update = _this7.actionUpdateFromErrors(e, MembershipActionType.SendJoinEvent, "sendStateEvent");
         if (update) return update;
         throw e;
       });
     })();
   }
   updateExpiryOnJoinedEvent() {
-    var _this9 = this;
+    var _this8 = this;
     return _asyncToGenerator(function* () {
-      var nextExpireUpdateIteration = _this9.state.expireUpdateIterations + 1;
-      return yield _this9.client.sendStateEvent(_this9.room.roomId, EventType.GroupCallMemberPrefix, _this9.makeMyMembership(_this9.membershipEventExpiryTimeout * nextExpireUpdateIteration), _this9.stateKey).then(() => {
+      var nextExpireUpdateIteration = _this8.state.expireUpdateIterations + 1;
+      return yield _this8.client.sendStateEvent(_this8.room.roomId, EventType.GroupCallMemberPrefix, _this8.makeMyMembership(_this8.membershipEventExpiryTimeout * nextExpireUpdateIteration), _this8.stateKey).then(() => {
         // Success, we reset retries and schedule update.
-        _this9.resetRateLimitCounter(MembershipActionType.UpdateExpiry);
-        _this9.state.expireUpdateIterations = nextExpireUpdateIteration;
+        _this8.resetRateLimitCounter(MembershipActionType.UpdateExpiry);
+        _this8.state.expireUpdateIterations = nextExpireUpdateIteration;
         return {
           insert: [{
-            ts: _this9.computeNextExpiryActionTs(nextExpireUpdateIteration),
+            ts: _this8.computeNextExpiryActionTs(nextExpireUpdateIteration),
             type: MembershipActionType.UpdateExpiry
           }]
         };
       }).catch(e => {
-        var update = _this9.actionUpdateFromErrors(e, MembershipActionType.UpdateExpiry, "sendStateEvent");
+        var update = _this8.actionUpdateFromErrors(e, MembershipActionType.UpdateExpiry, "sendStateEvent");
         if (update) return update;
         throw e;
       });
     })();
   }
   sendFallbackLeaveEvent() {
-    var _this10 = this;
+    var _this9 = this;
     return _asyncToGenerator(function* () {
-      return yield _this10.client.sendStateEvent(_this10.room.roomId, EventType.GroupCallMemberPrefix, {}, _this10.stateKey).then(() => {
-        _this10.resetRateLimitCounter(MembershipActionType.SendLeaveEvent);
-        _this10.state.hasMemberStateEvent = false;
+      return yield _this9.client.sendStateEvent(_this9.room.roomId, EventType.GroupCallMemberPrefix, {}, _this9.stateKey).then(() => {
+        _this9.resetRateLimitCounter(MembershipActionType.SendLeaveEvent);
+        _this9.state.hasMemberStateEvent = false;
         return {
           replace: []
         };
       }).catch(e => {
-        var update = _this10.actionUpdateFromErrors(e, MembershipActionType.SendLeaveEvent, "sendStateEvent");
+        var update = _this9.actionUpdateFromErrors(e, MembershipActionType.SendLeaveEvent, "sendStateEvent");
         if (update) return update;
         throw e;
       });
@@ -731,9 +725,8 @@ export class MembershipManager {
         type
       } = actions[0];
       switch (type) {
-        case MembershipActionType.SendFirstDelayedEvent:
+        case MembershipActionType.SendDelayedEvent:
         case MembershipActionType.SendJoinEvent:
-        case MembershipActionType.SendMainDelayedEvent:
           return Status.Connecting;
         case MembershipActionType.UpdateExpiry:
           // where no delayed events
@@ -747,7 +740,7 @@ export class MembershipManager {
     } else if (actions.length === 2) {
       var types = actions.map(a => a.type);
       // normal state for connected with delayed events
-      if ((types.includes(MembershipActionType.RestartDelayedEvent) || types.includes(MembershipActionType.SendMainDelayedEvent)) && types.includes(MembershipActionType.UpdateExpiry)) {
+      if ((types.includes(MembershipActionType.RestartDelayedEvent) || types.includes(MembershipActionType.SendDelayedEvent) && this.state.hasMemberStateEvent) && types.includes(MembershipActionType.UpdateExpiry)) {
         return Status.Connected;
       }
     } else if (actions.length === 3) {