@fluidframework/container-loader 2.0.0-dev.4.4.0.162574 → 2.0.0-dev.5.3.2.178189

package/src/connectionStateHandler.ts

@@ -3,19 +3,19 @@
  * Licensed under the MIT License.
  */
 
-import {
-	ITelemetryLogger,
-	ITelemetryProperties,
-	TelemetryEventCategory,
-} from "@fluidframework/common-definitions";
+import { ITelemetryProperties, TelemetryEventCategory } from "@fluidframework/core-interfaces";
 import { assert, Timer } from "@fluidframework/common-utils";
 import { IConnectionDetailsInternal, IDeltaManager } from "@fluidframework/container-definitions";
 import { IAnyDriverError } from "@fluidframework/driver-definitions";
 import { ISequencedClient, IClient } from "@fluidframework/protocol-definitions";
-import { PerformanceEvent, loggerToMonitoringContext } from "@fluidframework/telemetry-utils";
+import {
+	ITelemetryLoggerExt,
+	PerformanceEvent,
+	loggerToMonitoringContext,
+} from "@fluidframework/telemetry-utils";
 import { ConnectionState } from "./connectionState";
 import { CatchUpMonitor, ICatchUpMonitor } from "./catchUpMonitor";
-import { ILocalSequencedClient, IProtocolHandler } from "./protocol";
+import { IProtocolHandler } from "./protocol";
 
 // 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
@@ -27,7 +27,7 @@ const JoinSignalTimeoutMs = 5000;
 
 /** Constructor parameter type for passing in dependencies needed by the ConnectionStateHandler */
 export interface IConnectionStateHandlerInputs {
-	logger: ITelemetryLogger;
+	logger: ITelemetryLoggerExt;
 	/** Log to telemetry any change in state, included to Connecting */
 	connectionStateChanged: (
 		value: ConnectionState,
@@ -45,6 +45,8 @@ export interface IConnectionStateHandlerInputs {
 		category: TelemetryEventCategory,
 		details?: ITelemetryProperties,
 	) => void;
+	/** Callback to note that an old local client ID is still present in the Quorum that should have left and should now be considered invalid */
+	clientShouldHaveLeft: (clientId: string) => void;
 }
 
 /**
@@ -59,6 +61,13 @@ export interface IConnectionStateHandler {
 	initProtocol(protocol: IProtocolHandler): void;
 	receivedConnectEvent(details: IConnectionDetailsInternal): void;
 	receivedDisconnectEvent(reason: string, error?: IAnyDriverError): void;
+	establishingConnection(reason: string): void;
+	/**
+	 * Switches state to disconnected when we are still establishing connection during container.load(),
+	 * container connect() or reconnect and the container gets closed or disposed or disconnect happens.
+	 * @param reason - reason for cancelling the connection.
+	 */
+	cancelEstablishingConnection(reason: string): void;
 }
 
 export function createConnectionStateHandler(
@@ -144,6 +153,14 @@ class ConnectionStateHandlerPassThrough
 		return this.pimpl.receivedDisconnectEvent(reason, error);
 	}
 
+	public establishingConnection(reason: string) {
+		return this.pimpl.establishingConnection(reason);
+	}
+
+	public cancelEstablishingConnection(reason: string) {
+		return this.pimpl.cancelEstablishingConnection(reason);
+	}
+
 	public receivedConnectEvent(details: IConnectionDetailsInternal) {
 		return this.pimpl.receivedConnectEvent(details);
 	}
@@ -176,6 +193,9 @@ class ConnectionStateHandlerPassThrough
 	) {
 		return this.inputs.logConnectionIssue(eventName, category, details);
 	}
+	public clientShouldHaveLeft(clientId: string) {
+		return this.inputs.clientShouldHaveLeft(clientId);
+	}
 }
 
 /**
@@ -230,9 +250,17 @@ class ConnectionStateCatchup extends ConnectionStateHandlerPassThrough {
 				this.catchUpMonitor?.dispose();
 				this.catchUpMonitor = undefined;
 				break;
-			case ConnectionState.CatchingUp:
+			// ConnectionState.EstablishingConnection state would be set when we start establishing connection
+			// during container.connect() or reconnect because of an error.
+			case ConnectionState.EstablishingConnection:
 				assert(
 					this._connectionState === ConnectionState.Disconnected,
+					0x6d2 /* connectivity transition to establishing connection */,
+				);
+				break;
+			case ConnectionState.CatchingUp:
+				assert(
+					this._connectionState === ConnectionState.EstablishingConnection,
 					0x3e3 /* connectivity transitions */,
 				);
 				break;
@@ -471,6 +499,27 @@ class ConnectionStateHandler implements IConnectionStateHandler {
 		this.setConnectionState(ConnectionState.Disconnected, reason, error);
 	}
 
+	public cancelEstablishingConnection(reason: string) {
+		assert(
+			this._connectionState === ConnectionState.EstablishingConnection,
+			0x6d3 /* Connection state should be EstablishingConnection */,
+		);
+		assert(this.connection === undefined, 0x6d4 /* No connetion should be present */);
+		const oldState = this._connectionState;
+		this._connectionState = ConnectionState.Disconnected;
+		this.handler.connectionStateChanged(ConnectionState.Disconnected, oldState, reason);
+	}
+
+	public establishingConnection(reason: string) {
+		const oldState = this._connectionState;
+		this._connectionState = ConnectionState.EstablishingConnection;
+		this.handler.connectionStateChanged(
+			ConnectionState.EstablishingConnection,
+			oldState,
+			`Establishing Connection due to ${reason}`,
+		);
+	}
+
 	private shouldWaitForJoinSignal() {
 		assert(
 			this.connection !== undefined,
@@ -554,18 +603,18 @@ class ConnectionStateHandler implements IConnectionStateHandler {
 		// This is the only place in code that deals with quorum. The rest works with audience
 		// The code below ensures that we do not send ops until we know that old "write" client's disconnect
 		// produced (and sequenced) leave op
-		let client: ILocalSequencedClient | undefined;
-		if (this._clientId !== undefined) {
-			client = this.protocol?.quorum?.getMember(this._clientId);
-		}
+		const currentClientInQuorum =
+			this._clientId !== undefined &&
+			this.protocol?.quorum?.getMember(this._clientId) !== undefined;
 		if (value === ConnectionState.Connected) {
 			assert(
 				oldState === ConnectionState.CatchingUp,
 				0x1d8 /* "Should only transition from Connecting state" */,
 			);
 			// Mark our old client should have left in the quorum if it's still there
-			if (client !== undefined) {
-				client.shouldHaveLeft = true;
+			if (currentClientInQuorum) {
+				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+				this.handler.clientShouldHaveLeft(this._clientId!);
 			}
 			this._clientId = this.pendingClientId;
 		} else if (value === ConnectionState.Disconnected) {
@@ -581,7 +630,7 @@ class ConnectionStateHandler implements IConnectionStateHandler {
 			// 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 &&
+				currentClientInQuorum &&
 				this.handler.shouldClientJoinWrite() &&
 				!this.waitingForLeaveOp // same as !this.prevClientLeftTimer.hasTimer
 			) {
@@ -592,7 +641,7 @@ class ConnectionStateHandler implements IConnectionStateHandler {
 					eventName: "noWaitOnDisconnected",
 					details: JSON.stringify({
 						clientId: this._clientId,
-						inQuorum: client !== undefined,
+						inQuorum: currentClientInQuorum,
 						waitingForLeaveOp: this.waitingForLeaveOp,
 						hadOutstandingOps: this.handler.shouldClientJoinWrite(),
 					}),