@fluidframework/container-loader 1.2.7 → 2.0.0-dev.1.3.0.96595

package/lib/connectionStateHandler.js

@@ -3,60 +3,157 @@
  * Licensed under the MIT License.
  */
 import { assert, Timer } from "@fluidframework/common-utils";
-import { PerformanceEvent } from "@fluidframework/telemetry-utils";
+import { PerformanceEvent, loggerToMonitoringContext } from "@fluidframework/telemetry-utils";
 import { ConnectionState } from "./connectionState";
+import { CatchUpMonitor } from "./catchUpMonitor";
 const JoinOpTimeoutMs = 45000;
+export function createConnectionStateHandler(inputs, deltaManager, clientId) {
+    const mc = loggerToMonitoringContext(inputs.logger);
+    return createConnectionStateHandlerCore(mc.config.getBoolean("Fluid.Container.CatchUpBeforeDeclaringConnected") === true, inputs, deltaManager, clientId);
+}
+export function createConnectionStateHandlerCore(wait, inputs, deltaManager, clientId) {
+    if (!wait) {
+        return new ConnectionStateHandler(inputs, clientId);
+    }
+    return new ConnectionStateCatchup(inputs, (handler) => new ConnectionStateHandler(handler, clientId), deltaManager);
+}
+/**
+ * Class that can be used as a base class for building IConnectionStateHandler adapters / pipeline.
+ * It implements both ends of communication interfaces and passes data back and forward
+ */
+class ConnectionStateHandlerPassThrough {
+    constructor(inputs, pimplFactory) {
+        this.inputs = inputs;
+        this.pimpl = pimplFactory(this);
+    }
+    /**
+     * IConnectionStateHandler
+     */
+    get connectionState() { return this.pimpl.connectionState; }
+    get pendingClientId() { return this.pimpl.pendingClientId; }
+    containerSaved() { return this.pimpl.containerSaved(); }
+    dispose() { return this.pimpl.dispose(); }
+    initProtocol(protocol) { return this.pimpl.initProtocol(protocol); }
+    receivedDisconnectEvent(reason) { return this.pimpl.receivedDisconnectEvent(reason); }
+    receivedConnectEvent(connectionMode, details) {
+        return this.pimpl.receivedConnectEvent(connectionMode, details);
+    }
+    /**
+     * IConnectionStateHandlerInputs
+     */
+    get logger() { return this.inputs.logger; }
+    connectionStateChanged(value, oldState, reason) {
+        return this.inputs.connectionStateChanged(value, oldState, reason);
+    }
+    shouldClientJoinWrite() { return this.inputs.shouldClientJoinWrite(); }
+    get maxClientLeaveWaitTime() { return this.inputs.maxClientLeaveWaitTime; }
+    logConnectionIssue(eventName, details) {
+        return this.inputs.logConnectionIssue(eventName, details);
+    }
+}
+/**
+ * Implementation of IConnectionStateHandler pass-through adapter that waits for specific sequence number
+ * before raising connected event
+ */
+class ConnectionStateCatchup extends ConnectionStateHandlerPassThrough {
+    constructor(inputs, pimplFactory, deltaManager) {
+        super(inputs, pimplFactory);
+        this.deltaManager = deltaManager;
+        this.transitionToConnectedState = () => {
+            // Defensive measure, we should always be in Connecting state when this is called.
+            const state = this.pimpl.connectionState;
+            assert(state === ConnectionState.Connected, 0x3e5 /* invariant broken */);
+            assert(this._connectionState === ConnectionState.CatchingUp, 0x3e6 /* invariant broken */);
+            this._connectionState = ConnectionState.Connected;
+            this.inputs.connectionStateChanged(ConnectionState.Connected, ConnectionState.CatchingUp, "caught up");
+        };
+        this._connectionState = this.pimpl.connectionState;
+    }
+    get connectionState() {
+        return this._connectionState;
+    }
+    connectionStateChanged(value, oldState, reason) {
+        var _a;
+        switch (value) {
+            case ConnectionState.Connected:
+                assert(this._connectionState === ConnectionState.CatchingUp, 0x3e1 /* connectivity transitions */);
+                // Create catch-up monitor here (not earlier), as we might get more exact info by now about how far
+                // client is behind through join signal. This is only true if base layer uses signals (i.e. audience,
+                // not quorum, including for "rea" connections) to make decisions about moving to "connected" state.
+                // In addition to that, in its current form, doing this in ConnectionState.CatchingUp is dangerous as
+                // we might get callback right away, and it will screw up state transition (as code outside of switch
+                // statement will overwrite current state).
+                assert(this.catchUpMonitor === undefined, 0x3eb /* catchUpMonitor should be gone */);
+                this.catchUpMonitor = new CatchUpMonitor(this.deltaManager, this.transitionToConnectedState);
+                return;
+            case ConnectionState.Disconnected:
+                (_a = this.catchUpMonitor) === null || _a === void 0 ? void 0 : _a.dispose();
+                this.catchUpMonitor = undefined;
+                break;
+            case ConnectionState.CatchingUp:
+                assert(this._connectionState === ConnectionState.Disconnected, 0x3e3 /* connectivity transitions */);
+                break;
+            default:
+        }
+        this._connectionState = value;
+        this.inputs.connectionStateChanged(value, oldState, reason);
+    }
+}
 /**
  * In the lifetime of a container, the connection will likely disconnect and reconnect periodically.
  * This class ensures that any ops sent by this container instance on previous connection are either
  * sequenced or blocked by the server before emitting the new "connected" event and allowing runtime to resubmit ops.
  *
  * Each connection is assigned a clientId by the service, and the connection is book-ended by a Join and a Leave op
- * generated by the service. Due to the distributed nature of the ordering service, in the case of reconnect we cannot
+ * generated by the service. Due to the distributed nature of the Relay Service, in the case of reconnect we cannot
  * make any assumptions about ordering of operations between the old and new connections - i.e. new Join op could
  * be sequenced before old Leave op (and some acks from pending ops that were in flight when we disconnected).
  *
  * The job of this class is to encapsulate the transition period during reconnect, which is identified by
  * ConnectionState.CatchingUp. Specifically, before moving to Connected state with the new clientId, it ensures that:
- * (A) We process the Leave op for the previous clientId. This allows us to properly handle any acks from in-flight ops
- *     that got sequenced with the old clientId (we'll recognize them as local ops). After the Leave op, any other
- *     pending ops can safely be submitted with the new clientId without fear of duplication in the sequenced op stream.
- * (B) We process the Join op for the new clientId (identified when the underlying connection was first established),
- *     indicating the service is ready to sequence ops sent with the new clientId.
  *
- * For (A) we give up waiting after some time (same timeout as server uses), and go ahead and transition to Connected.
- * For (B) we log telemetry if it takes too long, but still only transition to Connected when the Join op is processed
+ * a. We process the Leave op for the previous clientId. This allows us to properly handle any acks from in-flight ops
+ * that got sequenced with the old clientId (we'll recognize them as local ops). After the Leave op, any other
+ * pending ops can safely be submitted with the new clientId without fear of duplication in the sequenced op stream.
+ *
+ * b. We process the Join op for the new clientId (identified when the underlying connection was first established),
+ * indicating the service is ready to sequence ops sent with the new clientId.
+ *
+ * c. We process all ops known at the time the underlying connection was established (so we are "caught up")
+ *
+ * For (a) we give up waiting after some time (same timeout as server uses), and go ahead and transition to Connected.
+ *
+ * For (b) we log telemetry if it takes too long, but still only transition to Connected when the Join op is processed
  * and we are added to the Quorum.
+ *
+ * For (c) this is optional behavior, controlled by the parameters of receivedConnectEvent
  */
-export class ConnectionStateHandler {
-    constructor(handler, logger, _clientId) {
+class ConnectionStateHandler {
+    constructor(handler, _clientId) {
         var _a;
         this.handler = handler;
-        this.logger = logger;
         this._clientId = _clientId;
         this._connectionState = ConnectionState.Disconnected;
         this.prevClientLeftTimer = new Timer(
         // Default is 5 min for which we are going to wait for its own "leave" message. This is same as
         // the max time on server after which leave op is sent.
         (_a = this.handler.maxClientLeaveWaitTime) !== null && _a !== void 0 ? _a : 300000, () => {
-            assert(!this.connected, 0x2ac /* "Connected when timeout waiting for leave from previous session fired!" */);
+            assert(this.connectionState !== ConnectionState.Connected, 0x2ac /* "Connected when timeout waiting for leave from previous session fired!" */);
             this.applyForConnectedState("timeout");
         });
         // Based on recent data, it looks like majority of cases where we get stuck are due to really slow or
         // timing out ops fetches. So attempt recovery infrequently. Also fetch uses 30 second timeout, so
         // if retrying fixes the problem, we should not see these events.
         this.joinOpTimer = new Timer(JoinOpTimeoutMs, () => {
-            var _a;
             // I've observed timer firing within couple ms from disconnect event, looks like
             // queued timer callback is not cancelled if timer is cancelled while callback sits in the queue.
             if (this.connectionState !== ConnectionState.CatchingUp) {
                 return;
             }
-            const quorumClients = this.handler.quorumClients();
             const details = {
-                quorumInitialized: quorumClients !== undefined,
-                hasPendingClientId: this.pendingClientId !== undefined,
-                inQuorum: (quorumClients === null || quorumClients === void 0 ? void 0 : quorumClients.getMember((_a = this.pendingClientId) !== null && _a !== void 0 ? _a : "")) !== undefined,
+                protocolInitialized: this.protocol !== undefined,
+                pendingClientId: this.pendingClientId,
+                clientJoined: this.hasMember(this.pendingClientId),
                 waitingForLeaveOp: this.waitingForLeaveOp,
             };
             this.handler.logConnectionIssue("NoJoinOp", details);
@@ -65,9 +162,6 @@ export class ConnectionStateHandler {
     get connectionState() {
         return this._connectionState;
     }
-    get connected() {
-        return this.connectionState === ConnectionState.Connected;
-    }
     get clientId() {
         return this._clientId;
     }
@@ -110,7 +204,7 @@ export class ConnectionStateHandler {
             }
             // Start the event in case we are waiting for leave or timeout.
             if (this.waitingForLeaveOp) {
-                this.waitEvent = PerformanceEvent.start(this.logger, {
+                this.waitEvent = PerformanceEvent.start(this.handler.logger, {
                     eventName: "WaitBeforeClientLeave",
                     details: JSON.stringify({
                         waitOnClientId: this._clientId,
@@ -122,24 +216,21 @@ export class ConnectionStateHandler {
         }
     }
     applyForConnectedState(source) {
-        var _a, _b;
-        const quorumClients = this.handler.quorumClients();
-        assert(quorumClients !== undefined, 0x236 /* "In all cases it should be already installed" */);
-        assert(this.waitingForLeaveOp === false ||
-            (this.clientId !== undefined && quorumClients.getMember(this.clientId) !== undefined), 0x2e2 /* "Must only wait for leave message when clientId in quorum" */);
+        var _a;
+        assert(this.protocol !== undefined, 0x236 /* "In all cases it should be already installed" */);
+        assert(!this.waitingForLeaveOp || this.hasMember(this.clientId), 0x2e2 /* "Must only wait for leave message when clientId in quorum" */);
         // Move to connected state only if we are in Connecting state, we have seen our join op
         // and there is no timer running which means we are not waiting for previous client to leave
         // or timeout has occurred while doing so.
         if (this.pendingClientId !== this.clientId
-            && this.pendingClientId !== undefined
-            && quorumClients.getMember(this.pendingClientId) !== undefined
+            && this.hasMember(this.pendingClientId)
             && !this.waitingForLeaveOp) {
             (_a = this.waitEvent) === null || _a === void 0 ? void 0 : _a.end({ source });
             this.setConnectionState(ConnectionState.Connected);
         }
         else {
             // Adding this event temporarily so that we can get help debugging if something goes wrong.
-            this.logger.sendTelemetryEvent({
+            this.handler.logger.sendTelemetryEvent({
                 eventName: "connectedStateRejected",
                 category: source === "timeout" ? "error" : "generic",
                 details: JSON.stringify({
@@ -147,7 +238,7 @@ export class ConnectionStateHandler {
                     pendingClientId: this.pendingClientId,
                     clientId: this.clientId,
                     waitingForLeaveOp: this.waitingForLeaveOp,
-                    inQuorum: (quorumClients === null || quorumClients === void 0 ? void 0 : quorumClients.getMember((_b = this.pendingClientId) !== null && _b !== void 0 ? _b : "")) !== undefined,
+                    clientJoined: this.hasMember(this.pendingClientId),
                 }),
             });
         }
@@ -160,9 +251,6 @@ export class ConnectionStateHandler {
         }
     }
     receivedDisconnectEvent(reason) {
-        if (this.joinOpTimer.hasTimer) {
-            this.stopJoinOpTimer();
-        }
         this.setConnectionState(ConnectionState.Disconnected, reason);
     }
     /**
@@ -170,17 +258,20 @@ export class ConnectionStateHandler {
      * However, some additional conditions must be met before we can fully transition to
      * "Connected" state. This function handles that interim period, known as "Connecting" state.
      * @param connectionMode - Read or Write connection
-     * @param details - Connection details returned from the ordering service
+     * @param details - Connection details returned from the Relay Service
+     * @param deltaManager - DeltaManager to be used for delaying Connected transition until caught up.
+     * If it's undefined, then don't delay and transition to Connected as soon as Leave/Join op are accounted for
      */
     receivedConnectEvent(connectionMode, details) {
         const oldState = this._connectionState;
         this._connectionState = ConnectionState.CatchingUp;
         const writeConnection = connectionMode === "write";
-        assert(writeConnection || !this.handler.shouldClientJoinWrite(), 0x30a /* shouldClientJoinWrite should imply this is a writeConnection */);
-        assert(writeConnection || !this.waitingForLeaveOp, 0x2a6 /* "waitingForLeaveOp should imply writeConnection (we need to be ready to flush pending ops)" */);
-        // Note that this may be undefined since the connection is established proactively on load
-        // and the quorum may still be under initialization.
-        const quorumClients = this.handler.quorumClients();
+        // The following checks are wrong. They are only valid if user has write access to a file.
+        // If user lost such access mid-session, user will not be able to get "write" connection.
+        // assert(!this.handler.shouldClientJoinWrite() || writeConnection,
+        //    0x30a /* shouldClientJoinWrite should imply this is a writeConnection */);
+        // assert(!this.waitingForLeaveOp || writeConnection,
+        //    0x2a6 /* "waitingForLeaveOp should imply writeConnection (we need to be ready to flush pending ops)" */);
         // Stash the clientID to detect when transitioning from connecting (socket.io channel open) to connected
         // (have received the join message for the client ID)
         // This is especially important in the reconnect case. It's possible there could be outstanding
@@ -189,13 +280,13 @@ export class ConnectionStateHandler {
         // we know there can no longer be outstanding ops that we sent with the previous client id.
         this._pendingClientId = details.clientId;
         // IMPORTANT: Report telemetry after we set _pendingClientId, but before transitioning to Connected state
-        this.handler.logConnectionStateChangeTelemetry(ConnectionState.CatchingUp, oldState);
+        this.handler.connectionStateChanged(ConnectionState.CatchingUp, oldState);
         // For write connections, this pending clientId could be in the quorum already (i.e. join op already processed).
         // We are fetching ops from storage in parallel to connecting to Relay Service,
         // and given async processes, it's possible that we have already processed our own join message before
         // connection was fully established.
-        // If quorumClients itself is undefined, we expect it will process the join op after it's initialized.
-        const waitingForJoinOp = writeConnection && (quorumClients === null || quorumClients === void 0 ? void 0 : quorumClients.getMember(this._pendingClientId)) === undefined;
+        // If protocol is not initialized yet, we expect it will process the join op after it's initialized.
+        const waitingForJoinOp = writeConnection && !this.hasMember(this._pendingClientId);
         if (waitingForJoinOp) {
             // Previous client left, and we are waiting for our own join op. When it is processed we'll join the quorum
             // and attempt to transition to Connected state via receivedAddMemberEvent.
@@ -207,19 +298,20 @@ export class ConnectionStateHandler {
             // If we are waiting for Leave op still, do nothing for now, we will transition to Connected later.
             this.setConnectionState(ConnectionState.Connected);
         }
+        // else - We are waiting for Leave op still, do nothing for now, we will transition to Connected later
     }
     setConnectionState(value, reason) {
+        var _a, _b;
         if (this.connectionState === value) {
             // Already in the desired state - exit early
-            this.logger.sendErrorEvent({ eventName: "setConnectionStateSame", value });
+            this.handler.logger.sendErrorEvent({ eventName: "setConnectionStateSame", value });
             return;
         }
         const oldState = this._connectionState;
         this._connectionState = value;
-        const quorumClients = this.handler.quorumClients();
         let client;
         if (this._clientId !== undefined) {
-            client = quorumClients === null || quorumClients === void 0 ? void 0 : quorumClients.getMember(this._clientId);
+            client = (_b = (_a = this.protocol) === null || _a === void 0 ? void 0 : _a.quorum) === null || _b === void 0 ? void 0 : _b.getMember(this._clientId);
         }
         if (value === ConnectionState.Connected) {
             assert(oldState === ConnectionState.CatchingUp, 0x1d8 /* "Should only transition from Connecting state" */);
@@ -230,24 +322,27 @@ export class ConnectionStateHandler {
             this._clientId = this.pendingClientId;
         }
         else if (value === ConnectionState.Disconnected) {
-            // Important as we process our own joinSession message through delta request
+            // Clear pending state immediately to prepare for reconnect
             this._pendingClientId = undefined;
-            // Only wait for "leave" message if the connected client exists in the quorum because only the write
-            // client will exist in the quorum and only for those clients we will receive "removeMember" event and
-            // the client has some unacked ops.
-            // Also server would not accept ops from read client. Also check if the timer is not already running as
+            if (this.joinOpTimer.hasTimer) {
+                this.stopJoinOpTimer();
+            }
+            // Only wait for "leave" message if the connected client exists in the quorum and had some non-acked ops
+            // Also check if the timer is not already running as
             // we could receive "Disconnected" event multiple times without getting connected and in that case we
             // don't want to reset the timer as we still want to wait on original client which started this timer.
             if (client !== undefined
                 && this.handler.shouldClientJoinWrite()
-                && this.prevClientLeftTimer.hasTimer === false) {
+                && !this.waitingForLeaveOp // same as !this.prevClientLeftTimer.hasTimer
+            ) {
                 this.prevClientLeftTimer.restart();
             }
             else {
                 // Adding this event temporarily so that we can get help debugging if something goes wrong.
-                this.logger.sendTelemetryEvent({
+                this.handler.logger.sendTelemetryEvent({
                     eventName: "noWaitOnDisconnected",
                     details: JSON.stringify({
+                        clientId: this._clientId,
                         inQuorum: client !== undefined,
                         waitingForLeaveOp: this.waitingForLeaveOp,
                         hadOutstandingOps: this.handler.shouldClientJoinWrite(),
@@ -256,21 +351,38 @@ export class ConnectionStateHandler {
             }
         }
         // Report transition before we propagate event across layers
-        this.handler.logConnectionStateChangeTelemetry(this._connectionState, oldState, reason);
-        // Propagate event across layers
-        this.handler.connectionStateChanged();
+        this.handler.connectionStateChanged(this._connectionState, oldState, reason);
+    }
+    // Helper method to switch between quorum and audience.
+    // Old design was checking only quorum for "write" clients.
+    // Latest change checks audience for all types of connections.
+    get membership() {
+        var _a;
+        return (_a = this.protocol) === null || _a === void 0 ? void 0 : _a.quorum;
     }
     initProtocol(protocol) {
-        protocol.quorum.on("addMember", (clientId, _details) => {
+        var _a, _b;
+        this.protocol = protocol;
+        (_a = this.membership) === null || _a === void 0 ? void 0 : _a.on("addMember", (clientId) => {
             this.receivedAddMemberEvent(clientId);
         });
-        protocol.quorum.on("removeMember", (clientId) => {
+        (_b = this.membership) === null || _b === void 0 ? void 0 : _b.on("removeMember", (clientId) => {
             this.receivedRemoveMemberEvent(clientId);
         });
+        // Very unlikely race condition, but theoretically can happen - our new connection is already
+        // summarized and we are loading from such summary.
+        if (this.hasMember(this.pendingClientId)) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            this.receivedAddMemberEvent(this.pendingClientId);
+        }
         // if we have a clientId from a previous container we need to wait for its leave message
-        if (this.clientId !== undefined && protocol.quorum.getMember(this.clientId) !== undefined) {
+        if (this.clientId !== undefined && this.hasMember(this.clientId)) {
             this.prevClientLeftTimer.restart();
         }
     }
+    hasMember(clientId) {
+        var _a;
+        return ((_a = this.membership) === null || _a === void 0 ? void 0 : _a.getMember(clientId !== null && clientId !== void 0 ? clientId : "")) !== undefined;
+    }
 }
 //# sourceMappingURL=connectionStateHandler.js.map

package/lib/connectionStateHandler.js.map

@@ -1 +1 @@
-{"version":3,"file":"connectionStateHandler.js","sourceRoot":"","sources":["../src/connectionStateHandler.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { ITelemetryLogger, ITelemetryProperties } from \"@fluidframework/common-definitions\";\nimport { assert, Timer } from \"@fluidframework/common-utils\";\nimport { IConnectionDetails } from \"@fluidframework/container-definitions\";\nimport { ILocalSequencedClient, IProtocolHandler } from \"@fluidframework/protocol-base\";\nimport { ConnectionMode, IQuorumClients } from \"@fluidframework/protocol-definitions\";\nimport { PerformanceEvent } from \"@fluidframework/telemetry-utils\";\nimport { ConnectionState } from \"./connectionState\";\n\n/** Constructor parameter type for passing in dependencies needed by the ConnectionStateHandler */\nexport interface IConnectionStateHandlerInputs {\n    /** Provides access to the clients currently in the quorum */\n    quorumClients: () => IQuorumClients | undefined;\n    /** Log to telemetry any change in state, included to Connecting */\n    logConnectionStateChangeTelemetry:\n        (value: ConnectionState, oldState: ConnectionState, reason?: string | undefined) => void;\n    /** Whether to expect the client to join in write mode on next connection */\n    shouldClientJoinWrite: () => boolean;\n    /** (Optional) How long should we wait on our previous client's Leave op before transitioning to Connected again */\n    maxClientLeaveWaitTime: number | undefined;\n    /** Log an issue encountered while in the Connecting state. details will be logged as a JSON string */\n    logConnectionIssue: (eventName: string, details?: ITelemetryProperties) => void;\n    /** Callback whenever the ConnectionState changes between Disconnected and Connected */\n    connectionStateChanged: () => void;\n}\n\nconst JoinOpTimeoutMs = 45000;\n\n/**\n * In the lifetime of a container, the connection will likely disconnect and reconnect periodically.\n * This class ensures that any ops sent by this container instance on previous connection are either\n * sequenced or blocked by the server before emitting the new \"connected\" event and allowing runtime to resubmit ops.\n *\n * Each connection is assigned a clientId by the service, and the connection is book-ended by a Join and a Leave op\n * generated by the service. Due to the distributed nature of the ordering service, in the case of reconnect we cannot\n * make any assumptions about ordering of operations between the old and new connections - i.e. new Join op could\n * be sequenced before old Leave op (and some acks from pending ops that were in flight when we disconnected).\n *\n * The job of this class is to encapsulate the transition period during reconnect, which is identified by\n * ConnectionState.CatchingUp. Specifically, before moving to Connected state with the new clientId, it ensures that:\n * (A) We process the Leave op for the previous clientId. This allows us to properly handle any acks from in-flight ops\n *     that got sequenced with the old clientId (we'll recognize them as local ops). After the Leave op, any other\n *     pending ops can safely be submitted with the new clientId without fear of duplication in the sequenced op stream.\n * (B) We process the Join op for the new clientId (identified when the underlying connection was first established),\n *     indicating the service is ready to sequence ops sent with the new clientId.\n *\n * For (A) we give up waiting after some time (same timeout as server uses), and go ahead and transition to Connected.\n * For (B) we log telemetry if it takes too long, but still only transition to Connected when the Join op is processed\n * and we are added to the Quorum.\n */\nexport class ConnectionStateHandler {\n    private _connectionState = ConnectionState.Disconnected;\n    private _pendingClientId: string | undefined;\n    private readonly prevClientLeftTimer: Timer;\n    private readonly joinOpTimer: Timer;\n\n    private waitEvent: PerformanceEvent | undefined;\n\n    public get connectionState(): ConnectionState {\n        return this._connectionState;\n    }\n\n    public get connected(): boolean {\n        return this.connectionState === ConnectionState.Connected;\n    }\n\n    public get clientId(): string | undefined {\n        return this._clientId;\n    }\n\n    public get pendingClientId(): string | undefined {\n        return this._pendingClientId;\n    }\n\n    constructor(\n        private readonly handler: IConnectionStateHandlerInputs,\n        private readonly logger: ITelemetryLogger,\n        private _clientId?: string,\n    ) {\n        this.prevClientLeftTimer = new Timer(\n            // Default is 5 min for which we are going to wait for its own \"leave\" message. This is same as\n            // the max time on server after which leave op is sent.\n            this.handler.maxClientLeaveWaitTime ?? 300000,\n            () => {\n                assert(!this.connected,\n                    0x2ac /* \"Connected when timeout waiting for leave from previous session fired!\" */);\n                this.applyForConnectedState(\"timeout\");\n            },\n        );\n\n        // Based on recent data, it looks like majority of cases where we get stuck are due to really slow or\n        // timing out ops fetches. So attempt recovery infrequently. Also fetch uses 30 second timeout, so\n        // if retrying fixes the problem, we should not see these events.\n        this.joinOpTimer = new Timer(\n            JoinOpTimeoutMs,\n            () => {\n                // I've observed timer firing within couple ms from disconnect event, looks like\n                // queued timer callback is not cancelled if timer is cancelled while callback sits in the queue.\n                if (this.connectionState !== ConnectionState.CatchingUp) {\n                    return;\n                }\n                const quorumClients = this.handler.quorumClients();\n                const details = {\n                    quorumInitialized: quorumClients !== undefined,\n                    hasPendingClientId: this.pendingClientId !== undefined,\n                    inQuorum: quorumClients?.getMember(this.pendingClientId ?? \"\") !== undefined,\n                    waitingForLeaveOp: this.waitingForLeaveOp,\n                };\n                this.handler.logConnectionIssue(\"NoJoinOp\", details);\n            },\n        );\n    }\n\n    private startJoinOpTimer() {\n        assert(!this.joinOpTimer.hasTimer, 0x234 /* \"has joinOpTimer\" */);\n        this.joinOpTimer.start();\n    }\n\n    private stopJoinOpTimer() {\n        assert(this.joinOpTimer.hasTimer, 0x235 /* \"no joinOpTimer\" */);\n        this.joinOpTimer.clear();\n    }\n\n    private get waitingForLeaveOp() {\n        return this.prevClientLeftTimer.hasTimer;\n    }\n\n    public dispose() {\n        assert(!this.joinOpTimer.hasTimer, 0x2a5 /* \"join timer\" */);\n        this.prevClientLeftTimer.clear();\n    }\n\n    public containerSaved() {\n        // If we were waiting for moving to Connected state, then only apply for state change. Since the container\n        // is now saved and we don't have any ops to roundtrip, we can clear the timer and apply for connected state.\n        if (this.waitingForLeaveOp) {\n            this.prevClientLeftTimer.clear();\n            this.applyForConnectedState(\"containerSaved\");\n        }\n    }\n\n    private receivedAddMemberEvent(clientId: string) {\n        // This is the only one that requires the pending client ID\n        if (clientId === this.pendingClientId) {\n            if (this.joinOpTimer.hasTimer) {\n                this.stopJoinOpTimer();\n            } else {\n                // timer has already fired, meaning it took too long to get join on.\n                // Record how long it actually took to recover.\n                this.handler.logConnectionIssue(\"ReceivedJoinOp\");\n            }\n            // Start the event in case we are waiting for leave or timeout.\n            if (this.waitingForLeaveOp) {\n                this.waitEvent = PerformanceEvent.start(this.logger, {\n                    eventName: \"WaitBeforeClientLeave\",\n                    details: JSON.stringify({\n                        waitOnClientId: this._clientId,\n                        hadOutstandingOps: this.handler.shouldClientJoinWrite(),\n                    }),\n                });\n            }\n            this.applyForConnectedState(\"addMemberEvent\");\n        }\n    }\n\n    private applyForConnectedState(source: \"removeMemberEvent\" | \"addMemberEvent\" | \"timeout\" | \"containerSaved\") {\n        const quorumClients = this.handler.quorumClients();\n        assert(quorumClients !== undefined, 0x236 /* \"In all cases it should be already installed\" */);\n\n        assert(this.waitingForLeaveOp === false ||\n            (this.clientId !== undefined && quorumClients.getMember(this.clientId) !== undefined),\n            0x2e2 /* \"Must only wait for leave message when clientId in quorum\" */);\n\n        // Move to connected state only if we are in Connecting state, we have seen our join op\n        // and there is no timer running which means we are not waiting for previous client to leave\n        // or timeout has occurred while doing so.\n        if (this.pendingClientId !== this.clientId\n            && this.pendingClientId !== undefined\n            && quorumClients.getMember(this.pendingClientId) !== undefined\n            && !this.waitingForLeaveOp\n        ) {\n            this.waitEvent?.end({ source });\n            this.setConnectionState(ConnectionState.Connected);\n        } else {\n            // Adding this event temporarily so that we can get help debugging if something goes wrong.\n            this.logger.sendTelemetryEvent({\n                eventName: \"connectedStateRejected\",\n                category: source === \"timeout\" ? \"error\" : \"generic\",\n                details: JSON.stringify({\n                    source,\n                    pendingClientId: this.pendingClientId,\n                    clientId: this.clientId,\n                    waitingForLeaveOp: this.waitingForLeaveOp,\n                    inQuorum: quorumClients?.getMember(this.pendingClientId ?? \"\") !== undefined,\n                }),\n            });\n        }\n    }\n\n    private receivedRemoveMemberEvent(clientId: string) {\n        // If the client which has left was us, then finish the timer.\n        if (this.clientId === clientId) {\n            this.prevClientLeftTimer.clear();\n            this.applyForConnectedState(\"removeMemberEvent\");\n        }\n    }\n\n    public receivedDisconnectEvent(reason: string) {\n        if (this.joinOpTimer.hasTimer) {\n            this.stopJoinOpTimer();\n        }\n        this.setConnectionState(ConnectionState.Disconnected, reason);\n    }\n\n    /**\n     * The \"connect\" event indicates the connection to the Relay Service is live.\n     * However, some additional conditions must be met before we can fully transition to\n     * \"Connected\" state. This function handles that interim period, known as \"Connecting\" state.\n     * @param connectionMode - Read or Write connection\n     * @param details - Connection details returned from the ordering service\n     */\n    public receivedConnectEvent(\n        connectionMode: ConnectionMode,\n        details: IConnectionDetails,\n    ) {\n        const oldState = this._connectionState;\n        this._connectionState = ConnectionState.CatchingUp;\n\n        const writeConnection = connectionMode === \"write\";\n        assert(writeConnection || !this.handler.shouldClientJoinWrite(),\n            0x30a /* shouldClientJoinWrite should imply this is a writeConnection */);\n        assert(writeConnection || !this.waitingForLeaveOp,\n            0x2a6 /* \"waitingForLeaveOp should imply writeConnection (we need to be ready to flush pending ops)\" */);\n\n        // Note that this may be undefined since the connection is established proactively on load\n        // and the quorum may still be under initialization.\n        const quorumClients: IQuorumClients | undefined = this.handler.quorumClients();\n\n        // Stash the clientID to detect when transitioning from connecting (socket.io channel open) to connected\n        // (have received the join message for the client ID)\n        // This is especially important in the reconnect case. It's possible there could be outstanding\n        // ops sent by this client, so we should keep the old client id until we see our own client's\n        // join message. after we see the join message for our new connection with our new client id,\n        // we know there can no longer be outstanding ops that we sent with the previous client id.\n        this._pendingClientId = details.clientId;\n\n        // IMPORTANT: Report telemetry after we set _pendingClientId, but before transitioning to Connected state\n        this.handler.logConnectionStateChangeTelemetry(ConnectionState.CatchingUp, oldState);\n\n        // For write connections, this pending clientId could be in the quorum already (i.e. join op already processed).\n        // We are fetching ops from storage in parallel to connecting to Relay Service,\n        // and given async processes, it's possible that we have already processed our own join message before\n        // connection was fully established.\n        // If quorumClients itself is undefined, we expect it will process the join op after it's initialized.\n        const waitingForJoinOp = writeConnection && quorumClients?.getMember(this._pendingClientId) === undefined;\n\n        if (waitingForJoinOp) {\n            // Previous client left, and we are waiting for our own join op. When it is processed we'll join the quorum\n            // and attempt to transition to Connected state via receivedAddMemberEvent.\n            this.startJoinOpTimer();\n        } else if (!this.waitingForLeaveOp) {\n            // We're not waiting for Join or Leave op (if read-only connection those don't even apply),\n            // go ahead and declare the state to be Connected!\n            // If we are waiting for Leave op still, do nothing for now, we will transition to Connected later.\n            this.setConnectionState(ConnectionState.Connected);\n        }\n    }\n\n    private setConnectionState(value: ConnectionState.Disconnected, reason: string): void;\n    private setConnectionState(value: ConnectionState.Connected): void;\n    private setConnectionState(value: ConnectionState, reason?: string): void {\n        if (this.connectionState === value) {\n            // Already in the desired state - exit early\n            this.logger.sendErrorEvent({ eventName: \"setConnectionStateSame\", value });\n            return;\n        }\n\n        const oldState = this._connectionState;\n        this._connectionState = value;\n        const quorumClients = this.handler.quorumClients();\n        let client: ILocalSequencedClient | undefined;\n        if (this._clientId !== undefined) {\n            client = quorumClients?.getMember(this._clientId);\n        }\n        if (value === ConnectionState.Connected) {\n            assert(oldState === ConnectionState.CatchingUp,\n                0x1d8 /* \"Should only transition from Connecting state\" */);\n            // Mark our old client should have left in the quorum if it's still there\n            if (client !== undefined) {\n                client.shouldHaveLeft = true;\n            }\n            this._clientId = this.pendingClientId;\n        } else if (value === ConnectionState.Disconnected) {\n            // Important as we process our own joinSession message through delta request\n            this._pendingClientId = undefined;\n            // Only wait for \"leave\" message if the connected client exists in the quorum because only the write\n            // client will exist in the quorum and only for those clients we will receive \"removeMember\" event and\n            // the client has some unacked ops.\n            // Also server would not accept ops from read client. Also check if the timer is not already running as\n            // we could receive \"Disconnected\" event multiple times without getting connected and in that case we\n            // don't want to reset the timer as we still want to wait on original client which started this timer.\n            if (client !== undefined\n                && this.handler.shouldClientJoinWrite()\n                && this.prevClientLeftTimer.hasTimer === false\n            ) {\n                this.prevClientLeftTimer.restart();\n            } else {\n                // Adding this event temporarily so that we can get help debugging if something goes wrong.\n                this.logger.sendTelemetryEvent({\n                    eventName: \"noWaitOnDisconnected\",\n                    details: JSON.stringify({\n                        inQuorum: client !== undefined,\n                        waitingForLeaveOp: this.waitingForLeaveOp,\n                        hadOutstandingOps: this.handler.shouldClientJoinWrite(),\n                    }),\n                });\n            }\n        }\n\n        // Report transition before we propagate event across layers\n        this.handler.logConnectionStateChangeTelemetry(this._connectionState, oldState, reason);\n\n        // Propagate event across layers\n        this.handler.connectionStateChanged();\n    }\n\n    public initProtocol(protocol: IProtocolHandler) {\n        protocol.quorum.on(\"addMember\", (clientId, _details) => {\n            this.receivedAddMemberEvent(clientId);\n        });\n\n        protocol.quorum.on(\"removeMember\", (clientId) => {\n            this.receivedRemoveMemberEvent(clientId);\n        });\n\n        // if we have a clientId from a previous container we need to wait for its leave message\n        if (this.clientId !== undefined && protocol.quorum.getMember(this.clientId) !== undefined) {\n            this.prevClientLeftTimer.restart();\n        }\n    }\n}\n"]}
+{"version":3,"file":"connectionStateHandler.js","sourceRoot":"","sources":["../src/connectionStateHandler.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { ITelemetryLogger, ITelemetryProperties } from \"@fluidframework/common-definitions\";\nimport { assert, Timer } from \"@fluidframework/common-utils\";\nimport { IConnectionDetails, IDeltaManager } from \"@fluidframework/container-definitions\";\nimport { ILocalSequencedClient } from \"@fluidframework/protocol-base\";\nimport { ConnectionMode } from \"@fluidframework/protocol-definitions\";\nimport { PerformanceEvent, loggerToMonitoringContext } from \"@fluidframework/telemetry-utils\";\nimport { ConnectionState } from \"./connectionState\";\nimport { CatchUpMonitor, ICatchUpMonitor } from \"./catchUpMonitor\";\nimport { IProtocolHandler } from \"./protocol\";\n\nconst JoinOpTimeoutMs = 45000;\n\n/** Constructor parameter type for passing in dependencies needed by the ConnectionStateHandler */\nexport interface IConnectionStateHandlerInputs {\n    logger: ITelemetryLogger;\n    /** Log to telemetry any change in state, included to Connecting */\n    connectionStateChanged:\n        (value: ConnectionState, oldState: ConnectionState, reason?: string | undefined) => void;\n    /** Whether to expect the client to join in write mode on next connection */\n    shouldClientJoinWrite: () => boolean;\n    /** (Optional) How long should we wait on our previous client's Leave op before transitioning to Connected again */\n    maxClientLeaveWaitTime: number | undefined;\n    /** Log an issue encountered while in the Connecting state. details will be logged as a JSON string */\n    logConnectionIssue: (eventName: string, details?: ITelemetryProperties) => void;\n}\n\n/**\n * interface that connection state handler implements\n */\nexport interface IConnectionStateHandler {\n    readonly connectionState: ConnectionState;\n    readonly pendingClientId: string | undefined;\n\n    containerSaved(): void;\n    dispose(): void;\n    initProtocol(protocol: IProtocolHandler): void;\n    receivedConnectEvent(connectionMode: ConnectionMode, details: IConnectionDetails): void;\n    receivedDisconnectEvent(reason: string): void;\n}\n\nexport function createConnectionStateHandler(\n    inputs: IConnectionStateHandlerInputs,\n    deltaManager: IDeltaManager<any, any>,\n    clientId?: string,\n) {\n    const mc = loggerToMonitoringContext(inputs.logger);\n    return createConnectionStateHandlerCore(\n        mc.config.getBoolean(\"Fluid.Container.CatchUpBeforeDeclaringConnected\") === true,\n        inputs,\n        deltaManager,\n        clientId,\n    );\n}\n\nexport function createConnectionStateHandlerCore(\n    wait: boolean,\n    inputs: IConnectionStateHandlerInputs,\n    deltaManager: IDeltaManager<any, any>,\n    clientId?: string,\n) {\n    if (!wait) {\n        return new ConnectionStateHandler(inputs, clientId);\n    }\n    return new ConnectionStateCatchup(\n        inputs,\n        (handler: IConnectionStateHandlerInputs) => new ConnectionStateHandler(handler, clientId),\n        deltaManager);\n}\n\n/**\n * Class that can be used as a base class for building IConnectionStateHandler adapters / pipeline.\n * It implements both ends of communication interfaces and passes data back and forward\n */\nclass ConnectionStateHandlerPassThrough implements IConnectionStateHandler, IConnectionStateHandlerInputs {\n    protected readonly pimpl: IConnectionStateHandler;\n\n    constructor(\n        protected readonly inputs: IConnectionStateHandlerInputs,\n        pimplFactory: (handler: IConnectionStateHandlerInputs) => IConnectionStateHandler,\n    ) {\n        this.pimpl = pimplFactory(this);\n    }\n\n    /**\n     * IConnectionStateHandler\n     */\n    public get connectionState() { return this.pimpl.connectionState; }\n    public get pendingClientId() { return this.pimpl.pendingClientId; }\n\n    public containerSaved() { return this.pimpl.containerSaved(); }\n    public dispose() { return this.pimpl.dispose(); }\n    public initProtocol(protocol: IProtocolHandler) { return this.pimpl.initProtocol(protocol); }\n    public receivedDisconnectEvent(reason: string) { return this.pimpl.receivedDisconnectEvent(reason); }\n\n    public receivedConnectEvent(connectionMode: ConnectionMode, details: IConnectionDetails) {\n        return this.pimpl.receivedConnectEvent(connectionMode, details);\n    }\n\n    /**\n     * IConnectionStateHandlerInputs\n     */\n\n    public get logger() { return this.inputs.logger; }\n    public connectionStateChanged(\n        value: ConnectionState,\n        oldState: ConnectionState,\n        reason?: string | undefined,\n    ) {\n        return this.inputs.connectionStateChanged(value, oldState, reason);\n    }\n    public shouldClientJoinWrite() { return this.inputs.shouldClientJoinWrite(); }\n    public get maxClientLeaveWaitTime() { return this.inputs.maxClientLeaveWaitTime; }\n    public logConnectionIssue(eventName: string, details?: ITelemetryProperties) {\n        return this.inputs.logConnectionIssue(eventName, details);\n    }\n}\n\n/**\n * Implementation of IConnectionStateHandler pass-through adapter that waits for specific sequence number\n * before raising connected event\n */\nclass ConnectionStateCatchup extends ConnectionStateHandlerPassThrough {\n    private catchUpMonitor: ICatchUpMonitor | undefined;\n\n    constructor(\n        inputs: IConnectionStateHandlerInputs,\n        pimplFactory: (handler: IConnectionStateHandlerInputs) => IConnectionStateHandler,\n        private readonly deltaManager: IDeltaManager<any, any>,\n    ) {\n        super(inputs, pimplFactory);\n        this._connectionState = this.pimpl.connectionState;\n    }\n\n    private _connectionState: ConnectionState;\n    public get connectionState() {\n        return this._connectionState;\n    }\n\n    public connectionStateChanged(value: ConnectionState, oldState: ConnectionState, reason?: string | undefined) {\n        switch (value) {\n            case ConnectionState.Connected:\n                assert(this._connectionState === ConnectionState.CatchingUp, 0x3e1 /* connectivity transitions */);\n                // Create catch-up monitor here (not earlier), as we might get more exact info by now about how far\n                // client is behind through join signal. This is only true if base layer uses signals (i.e. audience,\n                // not quorum, including for \"rea\" connections) to make decisions about moving to \"connected\" state.\n                // In addition to that, in its current form, doing this in ConnectionState.CatchingUp is dangerous as\n                // we might get callback right away, and it will screw up state transition (as code outside of switch\n                // statement will overwrite current state).\n                assert(this.catchUpMonitor === undefined, 0x3eb /* catchUpMonitor should be gone */);\n                this.catchUpMonitor = new CatchUpMonitor(this.deltaManager, this.transitionToConnectedState);\n                return;\n            case ConnectionState.Disconnected:\n                this.catchUpMonitor?.dispose();\n                this.catchUpMonitor = undefined;\n                break;\n            case ConnectionState.CatchingUp:\n                assert(this._connectionState === ConnectionState.Disconnected, 0x3e3 /* connectivity transitions */);\n                break;\n            default:\n        }\n        this._connectionState = value;\n        this.inputs.connectionStateChanged(value, oldState, reason);\n    }\n\n    private readonly transitionToConnectedState = () => {\n        // Defensive measure, we should always be in Connecting state when this is called.\n        const state = this.pimpl.connectionState;\n        assert(state === ConnectionState.Connected, 0x3e5 /* invariant broken */);\n        assert(this._connectionState === ConnectionState.CatchingUp, 0x3e6 /* invariant broken */);\n        this._connectionState = ConnectionState.Connected;\n        this.inputs.connectionStateChanged(ConnectionState.Connected, ConnectionState.CatchingUp, \"caught up\");\n    };\n}\n\n/**\n * In the lifetime of a container, the connection will likely disconnect and reconnect periodically.\n * This class ensures that any ops sent by this container instance on previous connection are either\n * sequenced or blocked by the server before emitting the new \"connected\" event and allowing runtime to resubmit ops.\n *\n * Each connection is assigned a clientId by the service, and the connection is book-ended by a Join and a Leave op\n * generated by the service. Due to the distributed nature of the Relay Service, in the case of reconnect we cannot\n * make any assumptions about ordering of operations between the old and new connections - i.e. new Join op could\n * be sequenced before old Leave op (and some acks from pending ops that were in flight when we disconnected).\n *\n * The job of this class is to encapsulate the transition period during reconnect, which is identified by\n * ConnectionState.CatchingUp. Specifically, before moving to Connected state with the new clientId, it ensures that:\n *\n * a. We process the Leave op for the previous clientId. This allows us to properly handle any acks from in-flight ops\n * that got sequenced with the old clientId (we'll recognize them as local ops). After the Leave op, any other\n * pending ops can safely be submitted with the new clientId without fear of duplication in the sequenced op stream.\n *\n * b. We process the Join op for the new clientId (identified when the underlying connection was first established),\n * indicating the service is ready to sequence ops sent with the new clientId.\n *\n * c. We process all ops known at the time the underlying connection was established (so we are \"caught up\")\n *\n * For (a) we give up waiting after some time (same timeout as server uses), and go ahead and transition to Connected.\n *\n * For (b) we log telemetry if it takes too long, but still only transition to Connected when the Join op is processed\n * and we are added to the Quorum.\n *\n * For (c) this is optional behavior, controlled by the parameters of receivedConnectEvent\n */\nclass ConnectionStateHandler implements IConnectionStateHandler {\n    private _connectionState = ConnectionState.Disconnected;\n    private _pendingClientId: string | undefined;\n    private readonly prevClientLeftTimer: Timer;\n    private readonly joinOpTimer: Timer;\n    private protocol?: IProtocolHandler;\n\n    private waitEvent: PerformanceEvent | undefined;\n\n    public get connectionState(): ConnectionState {\n        return this._connectionState;\n    }\n\n    private get clientId(): string | undefined {\n        return this._clientId;\n    }\n\n    public get pendingClientId(): string | undefined {\n        return this._pendingClientId;\n    }\n\n    constructor(\n        private readonly handler: IConnectionStateHandlerInputs,\n        private _clientId?: string,\n    ) {\n        this.prevClientLeftTimer = new Timer(\n            // Default is 5 min for which we are going to wait for its own \"leave\" message. This is same as\n            // the max time on server after which leave op is sent.\n            this.handler.maxClientLeaveWaitTime ?? 300000,\n            () => {\n                assert(this.connectionState !== ConnectionState.Connected,\n                    0x2ac /* \"Connected when timeout waiting for leave from previous session fired!\" */);\n                this.applyForConnectedState(\"timeout\");\n            },\n        );\n\n        // Based on recent data, it looks like majority of cases where we get stuck are due to really slow or\n        // timing out ops fetches. So attempt recovery infrequently. Also fetch uses 30 second timeout, so\n        // if retrying fixes the problem, we should not see these events.\n        this.joinOpTimer = new Timer(\n            JoinOpTimeoutMs,\n            () => {\n                // I've observed timer firing within couple ms from disconnect event, looks like\n                // queued timer callback is not cancelled if timer is cancelled while callback sits in the queue.\n                if (this.connectionState !== ConnectionState.CatchingUp) {\n                    return;\n                }\n                const details = {\n                    protocolInitialized: this.protocol !== undefined,\n                    pendingClientId: this.pendingClientId,\n                    clientJoined: this.hasMember(this.pendingClientId),\n                    waitingForLeaveOp: this.waitingForLeaveOp,\n                };\n                this.handler.logConnectionIssue(\"NoJoinOp\", details);\n            },\n        );\n    }\n\n    private startJoinOpTimer() {\n        assert(!this.joinOpTimer.hasTimer, 0x234 /* \"has joinOpTimer\" */);\n        this.joinOpTimer.start();\n    }\n\n    private stopJoinOpTimer() {\n        assert(this.joinOpTimer.hasTimer, 0x235 /* \"no joinOpTimer\" */);\n        this.joinOpTimer.clear();\n    }\n\n    private get waitingForLeaveOp() {\n        return this.prevClientLeftTimer.hasTimer;\n    }\n\n    public dispose() {\n        assert(!this.joinOpTimer.hasTimer, 0x2a5 /* \"join timer\" */);\n        this.prevClientLeftTimer.clear();\n    }\n\n    public containerSaved() {\n        // If we were waiting for moving to Connected state, then only apply for state change. Since the container\n        // is now saved and we don't have any ops to roundtrip, we can clear the timer and apply for connected state.\n        if (this.waitingForLeaveOp) {\n            this.prevClientLeftTimer.clear();\n            this.applyForConnectedState(\"containerSaved\");\n        }\n    }\n\n    private receivedAddMemberEvent(clientId: string) {\n        // This is the only one that requires the pending client ID\n        if (clientId === this.pendingClientId) {\n            if (this.joinOpTimer.hasTimer) {\n                this.stopJoinOpTimer();\n            } else {\n                // timer has already fired, meaning it took too long to get join on.\n                // Record how long it actually took to recover.\n                this.handler.logConnectionIssue(\"ReceivedJoinOp\");\n            }\n            // Start the event in case we are waiting for leave or timeout.\n            if (this.waitingForLeaveOp) {\n                this.waitEvent = PerformanceEvent.start(this.handler.logger, {\n                    eventName: \"WaitBeforeClientLeave\",\n                    details: JSON.stringify({\n                        waitOnClientId: this._clientId,\n                        hadOutstandingOps: this.handler.shouldClientJoinWrite(),\n                    }),\n                });\n            }\n            this.applyForConnectedState(\"addMemberEvent\");\n        }\n    }\n\n    private applyForConnectedState(source: \"removeMemberEvent\" | \"addMemberEvent\" | \"timeout\" | \"containerSaved\") {\n        assert(this.protocol !== undefined, 0x236 /* \"In all cases it should be already installed\" */);\n\n        assert(!this.waitingForLeaveOp || this.hasMember(this.clientId),\n            0x2e2 /* \"Must only wait for leave message when clientId in quorum\" */);\n\n        // Move to connected state only if we are in Connecting state, we have seen our join op\n        // and there is no timer running which means we are not waiting for previous client to leave\n        // or timeout has occurred while doing so.\n        if (this.pendingClientId !== this.clientId\n            && this.hasMember(this.pendingClientId)\n            && !this.waitingForLeaveOp\n        ) {\n            this.waitEvent?.end({ source });\n            this.setConnectionState(ConnectionState.Connected);\n        } else {\n            // Adding this event temporarily so that we can get help debugging if something goes wrong.\n            this.handler.logger.sendTelemetryEvent({\n                eventName: \"connectedStateRejected\",\n                category: source === \"timeout\" ? \"error\" : \"generic\",\n                details: JSON.stringify({\n                    source,\n                    pendingClientId: this.pendingClientId,\n                    clientId: this.clientId,\n                    waitingForLeaveOp: this.waitingForLeaveOp,\n                    clientJoined: this.hasMember(this.pendingClientId),\n                }),\n            });\n        }\n    }\n\n    private receivedRemoveMemberEvent(clientId: string) {\n        // If the client which has left was us, then finish the timer.\n        if (this.clientId === clientId) {\n            this.prevClientLeftTimer.clear();\n            this.applyForConnectedState(\"removeMemberEvent\");\n        }\n    }\n\n    public receivedDisconnectEvent(reason: string) {\n        this.setConnectionState(ConnectionState.Disconnected, reason);\n    }\n\n    /**\n     * The \"connect\" event indicates the connection to the Relay Service is live.\n     * However, some additional conditions must be met before we can fully transition to\n     * \"Connected\" state. This function handles that interim period, known as \"Connecting\" state.\n     * @param connectionMode - Read or Write connection\n     * @param details - Connection details returned from the Relay Service\n     * @param deltaManager - DeltaManager to be used for delaying Connected transition until caught up.\n     * If it's undefined, then don't delay and transition to Connected as soon as Leave/Join op are accounted for\n     */\n    public receivedConnectEvent(\n        connectionMode: ConnectionMode,\n        details: IConnectionDetails,\n    ) {\n        const oldState = this._connectionState;\n        this._connectionState = ConnectionState.CatchingUp;\n\n        const writeConnection = connectionMode === \"write\";\n\n        // The following checks are wrong. They are only valid if user has write access to a file.\n        // If user lost such access mid-session, user will not be able to get \"write\" connection.\n        // assert(!this.handler.shouldClientJoinWrite() || writeConnection,\n        //    0x30a /* shouldClientJoinWrite should imply this is a writeConnection */);\n        // assert(!this.waitingForLeaveOp || writeConnection,\n        //    0x2a6 /* \"waitingForLeaveOp should imply writeConnection (we need to be ready to flush pending ops)\" */);\n\n        // Stash the clientID to detect when transitioning from connecting (socket.io channel open) to connected\n        // (have received the join message for the client ID)\n        // This is especially important in the reconnect case. It's possible there could be outstanding\n        // ops sent by this client, so we should keep the old client id until we see our own client's\n        // join message. after we see the join message for our new connection with our new client id,\n        // we know there can no longer be outstanding ops that we sent with the previous client id.\n        this._pendingClientId = details.clientId;\n\n        // IMPORTANT: Report telemetry after we set _pendingClientId, but before transitioning to Connected state\n        this.handler.connectionStateChanged(ConnectionState.CatchingUp, oldState);\n\n        // For write connections, this pending clientId could be in the quorum already (i.e. join op already processed).\n        // We are fetching ops from storage in parallel to connecting to Relay Service,\n        // and given async processes, it's possible that we have already processed our own join message before\n        // connection was fully established.\n        // If protocol is not initialized yet, we expect it will process the join op after it's initialized.\n        const waitingForJoinOp = writeConnection && !this.hasMember(this._pendingClientId);\n\n        if (waitingForJoinOp) {\n            // Previous client left, and we are waiting for our own join op. When it is processed we'll join the quorum\n            // and attempt to transition to Connected state via receivedAddMemberEvent.\n            this.startJoinOpTimer();\n        } else if (!this.waitingForLeaveOp) {\n            // We're not waiting for Join or Leave op (if read-only connection those don't even apply),\n            // go ahead and declare the state to be Connected!\n            // If we are waiting for Leave op still, do nothing for now, we will transition to Connected later.\n            this.setConnectionState(ConnectionState.Connected);\n        }\n        // else - We are waiting for Leave op still, do nothing for now, we will transition to Connected later\n    }\n\n    private setConnectionState(value: ConnectionState.Disconnected, reason: string): void;\n    private setConnectionState(value: ConnectionState.Connected): void;\n    private setConnectionState(value: ConnectionState.Disconnected | ConnectionState.Connected, reason?: string): void {\n        if (this.connectionState === value) {\n            // Already in the desired state - exit early\n            this.handler.logger.sendErrorEvent({ eventName: \"setConnectionStateSame\", value });\n            return;\n        }\n\n        const oldState = this._connectionState;\n        this._connectionState = value;\n        let client: ILocalSequencedClient | undefined;\n        if (this._clientId !== undefined) {\n            client = this.protocol?.quorum?.getMember(this._clientId);\n        }\n        if (value === ConnectionState.Connected) {\n            assert(oldState === ConnectionState.CatchingUp,\n                0x1d8 /* \"Should only transition from Connecting state\" */);\n            // Mark our old client should have left in the quorum if it's still there\n            if (client !== undefined) {\n                client.shouldHaveLeft = true;\n            }\n            this._clientId = this.pendingClientId;\n        } else if (value === ConnectionState.Disconnected) {\n            // Clear pending state immediately to prepare for reconnect\n            this._pendingClientId = undefined;\n\n            if (this.joinOpTimer.hasTimer) {\n                this.stopJoinOpTimer();\n            }\n\n            // Only wait for \"leave\" message if the connected client exists in the quorum and had some non-acked ops\n            // Also check if the timer is not already running as\n            // we could receive \"Disconnected\" event multiple times without getting connected and in that case we\n            // don't want to reset the timer as we still want to wait on original client which started this timer.\n            if (client !== undefined\n                && this.handler.shouldClientJoinWrite()\n                && !this.waitingForLeaveOp // same as !this.prevClientLeftTimer.hasTimer\n            ) {\n                this.prevClientLeftTimer.restart();\n            } else {\n                // Adding this event temporarily so that we can get help debugging if something goes wrong.\n                this.handler.logger.sendTelemetryEvent({\n                    eventName: \"noWaitOnDisconnected\",\n                    details: JSON.stringify({\n                        clientId: this._clientId,\n                        inQuorum: client !== undefined,\n                        waitingForLeaveOp: this.waitingForLeaveOp,\n                        hadOutstandingOps: this.handler.shouldClientJoinWrite(),\n                    }),\n                });\n            }\n        }\n\n        // Report transition before we propagate event across layers\n        this.handler.connectionStateChanged(this._connectionState, oldState, reason);\n    }\n\n    // Helper method to switch between quorum and audience.\n    // Old design was checking only quorum for \"write\" clients.\n    // Latest change checks audience for all types of connections.\n    protected get membership() {\n        return this.protocol?.quorum;\n    }\n\n    public initProtocol(protocol: IProtocolHandler) {\n        this.protocol = protocol;\n\n        this.membership?.on(\"addMember\", (clientId) => {\n            this.receivedAddMemberEvent(clientId);\n        });\n\n        this.membership?.on(\"removeMember\", (clientId) => {\n            this.receivedRemoveMemberEvent(clientId);\n        });\n\n        // Very unlikely race condition, but theoretically can happen - our new connection is already\n        // summarized and we are loading from such summary.\n        if (this.hasMember(this.pendingClientId)) {\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            this.receivedAddMemberEvent(this.pendingClientId!);\n        }\n\n        // if we have a clientId from a previous container we need to wait for its leave message\n        if (this.clientId !== undefined && this.hasMember(this.clientId)) {\n            this.prevClientLeftTimer.restart();\n        }\n    }\n\n    protected hasMember(clientId?: string) {\n        return this.membership?.getMember(clientId ?? \"\") !== undefined;\n    }\n}\n"]}