@fluidframework/task-manager 2.63.0-359734 → 2.63.0-359962

package/src/taskManager.ts

@@ -101,6 +101,8 @@ export class TaskManagerClass
 	private readonly completedWatcher: EventEmitter = new EventEmitter();
 	// rollbackWatcher emits an event whenever a pending op is rolled back.
 	private readonly rollbackWatcher: EventEmitter = new EventEmitter();
+	// attachedWatcher emits an event whenever the client becomes attached.
+	private readonly attachedWatcher: EventEmitter = new EventEmitter();
 
 	private nextPendingMessageId: number = 0;
 	/**
@@ -116,8 +118,8 @@ export class TaskManagerClass
 	/**
 	 * Returns the clientId. Will return a placeholder if the runtime is detached and not yet assigned a clientId.
 	 */
-	private get clientId(): string | undefined {
-		return this.isAttached() ? this.runtime.clientId : placeholderClientId;
+	private get clientId(): string {
+		return this.runtime.clientId ?? placeholderClientId;
 	}
 
 	/**
@@ -220,11 +222,6 @@ export class TaskManagerClass
 					return;
 				}
 
-				// Exit early if we are still catching up on reconnect -- we can't be the leader yet anyway.
-				if (this.clientId === undefined) {
-					return;
-				}
-
 				if (oldLockHolder !== this.clientId && newLockHolder === this.clientId) {
 					this.emit("assigned", taskId);
 				} else if (oldLockHolder === this.clientId && newLockHolder !== this.clientId) {
@@ -234,8 +231,6 @@ export class TaskManagerClass
 		);
 
 		this.connectionWatcher.on("disconnect", () => {
-			assert(this.clientId !== undefined, 0x1d3 /* "Missing client id on disconnect" */);
-
 			// Emit "lost" for any tasks we were assigned to.
 			for (const [taskId, clientQueue] of this.taskQueues.entries()) {
 				if (this.isAttached() && clientQueue[0] === this.clientId) {
@@ -325,7 +320,6 @@ export class TaskManagerClass
 
 		if (this.isDetached()) {
 			// Simulate auto-ack in detached scenario
-			assert(this.clientId !== undefined, 0x472 /* clientId should not be undefined */);
 			this.addClientToQueue(taskId, this.clientId);
 			return true;
 		}
@@ -382,6 +376,7 @@ export class TaskManagerClass
 			};
 
 			const rejectOnDisconnect = (): void => {
+				this.abandon(taskId);
 				removeListeners();
 				reject(new Error("Disconnected before acquiring task assignment"));
 			};
@@ -430,6 +425,7 @@ export class TaskManagerClass
 		}
 
 		let volunteerOpMessageId: number | undefined;
+		let abandoned = false;
 
 		const submitVolunteerOp = (): void => {
 			volunteerOpMessageId = this.nextPendingMessageId;
@@ -445,14 +441,16 @@ export class TaskManagerClass
 		const removeListeners = (): void => {
 			this.abandonWatcher.off("abandon", checkIfAbandoned);
 			this.connectionWatcher.off("disconnect", disconnectHandler);
-			this.connectionWatcher.off("connect", submitVolunteerOp);
 			this.completedWatcher.off("completed", checkIfCompleted);
 			this.rollbackWatcher.off("rollback", checkIfRolledBack);
 		};
-
 		const disconnectHandler = (): void => {
-			// Wait to be connected again and then re-submit volunteer op
-			this.connectionWatcher.once("connect", submitVolunteerOp);
+			// If we are disconnected and have not already sent a volunteer op, then we should
+			// submit another volunteer op while disconnected. This will allow the op to be
+			// picked up by resubmitCore() and resubmitted when we reconnect.
+			if (!this.queuedOptimistically(taskId)) {
+				submitVolunteerOp();
+			}
 		};
 
 		const checkIfAbandoned = (eventTaskId: string, messageId: number | undefined): void => {
@@ -475,6 +473,7 @@ export class TaskManagerClass
 			}
 			removeListeners();
 			this.subscribedTasks.delete(taskId);
+			abandoned = true;
 		};
 
 		const checkIfCompleted = (eventTaskId: string, messageId: number | undefined): void => {
@@ -506,23 +505,18 @@ export class TaskManagerClass
 
 		if (this.isDetached()) {
 			// Simulate auto-ack in detached scenario
-			assert(this.clientId !== undefined, 0x473 /* clientId should not be undefined */);
 			this.addClientToQueue(taskId, this.clientId);
 			// Because we volunteered with placeholderClientId, we need to wait for when we attach and are assigned
 			// a real clientId. At that point we should re-enter the queue with a real volunteer op (assuming we are
 			// connected).
-			this.runtime.once("attached", () => {
+			this.attachedWatcher.once("attached", () => {
 				// We call scrubClientsNotInQuorum() in case our clientId changed during the attach process.
 				this.scrubClientsNotInQuorum();
-				if (this.connected) {
+				// Make sure abandon() was not called while we were detached.
+				if (!abandoned) {
 					submitVolunteerOp();
-				} else {
-					this.connectionWatcher.once("connect", submitVolunteerOp);
 				}
 			});
-		} else if (!this.connected) {
-			// If we are disconnected (and attached), wait to be connected and submit volunteer op
-			disconnectHandler();
 		} else if (!this.queuedOptimistically(taskId)) {
 			// We don't need to send a second volunteer op if we just sent one.
 			submitVolunteerOp();
@@ -543,7 +537,6 @@ export class TaskManagerClass
 
 		if (this.isDetached()) {
 			// Simulate auto-ack in detached scenario
-			assert(this.clientId !== undefined, 0x474 /* clientId is undefined */);
 			this.removeClientFromQueue(taskId, this.clientId);
 			this.abandonWatcher.emit("abandon", taskId);
 			return;
@@ -573,7 +566,6 @@ export class TaskManagerClass
 			return false;
 		}
 
-		assert(this.clientId !== undefined, 0x07f /* "clientId undefined" */);
 		return this.taskQueues.get(taskId)?.includes(this.clientId) ?? false;
 	}
 
@@ -624,7 +616,7 @@ export class TaskManagerClass
 	 * @returns the summary of the current state of the task manager
 	 */
 	protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats {
-		if (this.runtime.clientId === undefined) {
+		if (this.clientId === placeholderClientId) {
 			// If the runtime has still not been assigned a clientId, we should not summarize with the placeholder
 			// clientIds and instead remove them from the queues and require the client to re-volunteer when assigned
 			// a new clientId.
@@ -688,6 +680,12 @@ export class TaskManagerClass
 		);
 		assert(pendingOpIndex !== -1, 0xc43 /* Could not match pending op on resubmit attempt */);
 		pendingOps.splice(pendingOpIndex, 1);
+		if (
+			content.type === "volunteer" &&
+			pendingOps[pendingOps.length - 1]?.type !== "abandon"
+		) {
+			this.submitVolunteerOp(content.taskId);
+		}
 		if (pendingOps.length === 0) {
 			this.latestPendingOps.delete(content.taskId);
 		}
@@ -837,12 +835,6 @@ export class TaskManagerClass
 	 * for the latest pending ops.
 	 */
 	private queuedOptimistically(taskId: string): boolean {
-		if (this.isAttached() && !this.connected) {
-			return false;
-		}
-
-		assert(this.clientId !== undefined, 0xc44 /* clientId undefined */);
-
 		const inQueue = this.taskQueues.get(taskId)?.includes(this.clientId) ?? false;
 		const latestPendingOps = this.latestPendingOps.get(taskId);
 
@@ -896,4 +888,11 @@ export class TaskManagerClass
 		}
 		this.rollbackWatcher.emit("rollback", content.taskId);
 	}
+
+	/**
+	 * {@inheritDoc @fluidframework/shared-object-base#SharedObject.didAttach}
+	 */
+	protected didAttach(): void {
+		this.attachedWatcher.emit("attached");
+	}
 }