@fluidframework/container-runtime 2.0.0-internal.2.3.1 → 2.0.0-internal.3.0.0

package/src/pendingStateManager.ts

@@ -31,6 +31,7 @@ export interface IPendingMessage {
 /**
  * This represents an explicit flush call and is added to the pending queue when flush is called on the ContainerRuntime
  * to flush pending messages.
+ * @deprecated Use batch metadata on IPendingMessage instead. To be removed in 2.0.0-internal.4.0.0 (AB#2496)
  */
 export interface IPendingFlush {
     type: "flush";
@@ -45,12 +46,11 @@ export interface IPendingLocalState {
     pendingStates: IPendingState[];
 }
 
-export interface IRuntimeStateHandler{
+export interface IRuntimeStateHandler {
     connected(): boolean;
     clientId(): string | undefined;
     close(error?: ICriticalContainerError): void;
     applyStashedOp: (type: ContainerMessageType, content: ISequencedDocumentMessage) => Promise<unknown>;
-    flush(): void;
     reSubmit(
         type: ContainerMessageType,
         content: any,
@@ -73,17 +73,15 @@ export interface IRuntimeStateHandler{
  * It verifies that all the ops are acked, are received in the right order and batch information is correct.
  */
 export class PendingStateManager implements IDisposable {
-    private readonly pendingStates = new Deque<IPendingState>();
-    private readonly initialStates: Deque<IPendingState>;
+    private readonly pendingMessages = new Deque<IPendingMessage>();
+    private readonly initialMessages = new Deque<IPendingMessage>();
     private readonly disposeOnce = new Lazy<void>(() => {
-        this.initialStates.clear();
-        this.pendingStates.clear();
+        this.initialMessages.clear();
+        this.pendingMessages.clear();
     });
 
-    // Maintains the count of messages that are currently unacked.
-    private _pendingMessagesCount: number = 0;
     public get pendingMessagesCount(): number {
-        return this._pendingMessagesCount;
+        return this.pendingMessages.length;
     }
 
     // Indicates whether we are processing a batch.
@@ -96,21 +94,28 @@ export class PendingStateManager implements IDisposable {
     private clientId: string | undefined;
 
     /**
-     * Called to check if there are any pending messages in the pending state queue.
+     * Called to check if there are any pending messages in the pending message queue.
      * @returns A boolean indicating whether there are messages or not.
      */
     public hasPendingMessages(): boolean {
-        return this._pendingMessagesCount !== 0 || !this.initialStates.isEmpty();
+        return !this.pendingMessages.isEmpty() || !this.initialMessages.isEmpty();
     }
 
     public getLocalState(): IPendingLocalState | undefined {
-        assert(this.initialStates.isEmpty(), 0x2e9 /* "Must call getLocalState() after applying initial states" */);
-        if (this.hasPendingMessages()) {
+        assert(this.initialMessages.isEmpty(), 0x2e9 /* "Must call getLocalState() after applying initial states" */);
+        if (!this.pendingMessages.isEmpty()) {
             return {
-                pendingStates: this.pendingStates.toArray().map(
+                pendingStates: this.pendingMessages.toArray().reduce((arr, message) => {
                     // delete localOpMetadata since it may not be serializable
                     // and will be regenerated by applyStashedOp()
-                    (state) => state.type === "message" ? { ...state, localOpMetadata: undefined } : state),
+                    arr.push({ ...message, localOpMetadata: undefined });
+
+                    // TODO: Remove in 2.0.0-internal.4.0.0 (AB#2496)
+                    if (message.opMetadata?.batch === false) {
+                        arr.push({ type: "flush" });
+                    }
+                    return arr;
+                }, new Array<IPendingState>()),
             };
         }
     }
@@ -119,7 +124,37 @@ export class PendingStateManager implements IDisposable {
         private readonly stateHandler: IRuntimeStateHandler,
         initialLocalState: IPendingLocalState | undefined,
     ) {
-        this.initialStates = new Deque<IPendingState>(initialLocalState?.pendingStates ?? []);
+        /**
+         * Convert old local state format to the new format
+         * The old format contained "flush" messages as the indicator of batch ends
+         * The new format instead uses batch metadata on the last message to indicate batch ends
+         * ! TODO: Remove this conversion in "2.0.0-internal.4.0.0" as rollback from future version will be new format
+         * AB#2496 tracks removal
+         */
+        if (initialLocalState?.pendingStates) {
+            const pendingStates = initialLocalState?.pendingStates;
+            let currentlyBatching = false;
+            for (let i = 0; i < pendingStates.length; i++) {
+                const initialState = pendingStates[i];
+
+                // Skip over "flush" messages
+                if (initialState.type === "message") {
+                    if (initialState.opMetadata?.batch) {
+                        currentlyBatching = true;
+                    } else if (initialState.opMetadata?.batch === false) {
+                        currentlyBatching = false;
+                    } else if (
+                        // End of batch if we are currently batching and this is last message or next message is flush
+                        currentlyBatching
+                        && (i === pendingStates.length - 1 || pendingStates[i + 1].type === "flush")
+                    ) {
+                        currentlyBatching = false;
+                        initialState.opMetadata = { ...initialState.opMetadata, batch: false };
+                    }
+                    this.initialMessages.push(initialState);
+                }
+            }
+        }
     }
 
     public get disposed() { return this.disposeOnce.evaluated; }
@@ -151,23 +186,7 @@ export class PendingStateManager implements IDisposable {
             opMetadata,
         };
 
-        this.pendingStates.push(pendingMessage);
-
-        this._pendingMessagesCount++;
-    }
-
-    /**
-     * Called when flush() is called on the ContainerRuntime to manually flush messages.
-     */
-    public onFlush() {
-        // If the previous state is not a message, flush is a no-op.
-        const previousState = this.pendingStates.peekBack();
-        if (previousState?.type !== "message") {
-            return;
-        }
-
-        // An explicit flush is interesting and is tracked only if there are messages sent in TurnBased mode.
-        this.pendingStates.push({ type: "flush" });
+        this.pendingMessages.push(pendingMessage);
     }
 
     /**
@@ -176,31 +195,26 @@ export class PendingStateManager implements IDisposable {
      */
     public async applyStashedOpsAt(seqNum?: number) {
         // apply stashed ops at sequence number
-        while (!this.initialStates.isEmpty()) {
+        while (!this.initialMessages.isEmpty()) {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const nextState = this.initialStates.peekFront()!;
-            if (nextState.type === "message") {
-                if (seqNum !== undefined) {
-                    if (nextState.referenceSequenceNumber > seqNum) {
-                        break; // nothing left to do at this sequence number
-                    } else if (nextState.referenceSequenceNumber < seqNum) {
-                        throw new Error("loaded from snapshot too recent to apply stashed ops");
-                    }
+            const nextMessage = this.initialMessages.peekFront()!;
+            if (seqNum !== undefined) {
+                if (nextMessage.referenceSequenceNumber > seqNum) {
+                    break; // nothing left to do at this sequence number
+                }
+                if (nextMessage.referenceSequenceNumber < seqNum) {
+                    throw new Error("loaded from snapshot too recent to apply stashed ops");
                 }
-
-                // applyStashedOp will cause the DDS to behave as if it has sent the op but not actually send it
-                const localOpMetadata =
-                    await this.stateHandler.applyStashedOp(nextState.messageType, nextState.content);
-                nextState.localOpMetadata = localOpMetadata;
             }
 
-            // then we push onto pendingStates which will cause PendingStateManager to resubmit when we connect
+            // applyStashedOp will cause the DDS to behave as if it has sent the op but not actually send it
+            const localOpMetadata =
+                await this.stateHandler.applyStashedOp(nextMessage.messageType, nextMessage.content);
+            nextMessage.localOpMetadata = localOpMetadata;
+
+            // then we push onto pendingMessages which will cause PendingStateManager to resubmit when we connect
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const firstPendingState = this.initialStates.shift()!;
-            this.pendingStates.push(firstPendingState);
-            if (firstPendingState.type === "message") {
-                this._pendingMessagesCount++;
-            }
+            this.pendingMessages.push(this.initialMessages.shift()!);
         }
     }
 
@@ -213,33 +227,30 @@ export class PendingStateManager implements IDisposable {
         // Pre-processing part - This may be the start of a batch.
         this.maybeProcessBatchBegin(message);
 
-        // Get the next state from the pending queue and verify that it is of type "message".
-        const pendingState = this.peekNextPendingState();
-        assert(pendingState.type === "message", 0x169 /* "No pending message found for this remote message" */);
-        this.pendingStates.shift();
+        // Get the next message from the pending queue. Verify a message exists.
+        const pendingMessage = this.pendingMessages.peekFront();
+        assert(pendingMessage !== undefined, 0x169 /* "No pending message found for this remote message" */);
+        this.pendingMessages.shift();
 
         // Processing part - Verify that there has been no data corruption.
         // The clientSequenceNumber of the incoming message must match that of the pending message.
-        if (pendingState.clientSequenceNumber !== message.clientSequenceNumber) {
+        if (pendingMessage.clientSequenceNumber !== message.clientSequenceNumber) {
             // Close the container because this could indicate data corruption.
             const error = DataProcessingError.create(
                 "pending local message clientSequenceNumber mismatch",
                 "unexpectedAckReceived",
                 message,
-                { expectedClientSequenceNumber: pendingState.clientSequenceNumber },
+                { expectedClientSequenceNumber: pendingMessage.clientSequenceNumber },
             );
 
             this.stateHandler.close(error);
             return;
         }
 
-        this._pendingMessagesCount--;
-        assert(this._pendingMessagesCount >= 0, 0x3d6 /* positive */);
-
         // Post-processing part - If we are processing a batch then this could be the last message in the batch.
         this.maybeProcessBatchEnd(message);
 
-        return pendingState.localOpMetadata;
+        return pendingMessage.localOpMetadata;
     }
 
     /**
@@ -247,21 +258,6 @@ export class PendingStateManager implements IDisposable {
      * @param message - The message that is being processed.
      */
     private maybeProcessBatchBegin(message: ISequencedDocumentMessage) {
-        /**
-         * We are checking if the next message is the start of a batch. It can happen in the following scenarios:
-         *
-         * 1. The FlushMode was set to TurnBased before this message was sent.
-         *
-         * 2. The FlushMode was already TurnBased and a flush was called before this message was sent. This essentially
-         * means that the flush marked the end of a previous batch and beginning of a new batch.
-         *
-         * Keep reading pending states from the queue until we encounter a message. It's possible that the FlushMode was
-         * updated a bunch of times without sending any messages.
-         */
-        while (this.peekNextPendingState().type !== "message") {
-            this.pendingStates.shift();
-        }
-
         // This message is the first in a batch if the "batch" property on the metadata is set to true
         if (message.metadata?.batch) {
             // We should not already be processing a batch and there should be no pending batch begin message.
@@ -283,56 +279,42 @@ export class PendingStateManager implements IDisposable {
             return;
         }
 
-        const nextPendingState = this.peekNextPendingState();
-        if (nextPendingState.type === "message") {
-            return;
-        }
-
         // There should be a pending batch begin message.
         assert(this.pendingBatchBeginMessage !== undefined, 0x16d /* "There is no pending batch begin message" */);
 
-        // Get the batch begin metadata from the first message in the batch.
-        const batchBeginMetadata = this.pendingBatchBeginMessage.metadata?.batch;
-
-        // There could be just a single message in the batch. If so, it should not have any batch metadata. If there
-        // are multiple messages in the batch, verify that we got the correct batch begin and end metadata.
-        if (this.pendingBatchBeginMessage === message) {
-            assert(batchBeginMetadata === undefined,
-                0x16e /* "Batch with single message should not have batch metadata" */);
-        } else {
-            // Get the batch metadata from the last message in the batch.
-            const batchEndMetadata = message.metadata?.batch;
-            if (batchBeginMetadata !== true || batchEndMetadata !== false) {
-                this.stateHandler.close(DataProcessingError.create(
-                    "Pending batch inconsistency", // Formerly known as asserts 0x16f and 0x170
-                    "processPendingLocalMessage",
-                    message,
-                    {
-                        runtimeVersion: pkgVersion,
-                        batchClientId: this.pendingBatchBeginMessage.clientId,
-                        clientId: this.stateHandler.clientId(),
-                        hasBatchStart: batchBeginMetadata === true,
-                        hasBatchEnd: batchEndMetadata === false,
-                        messageType: message.type,
-                        batchStartSequenceNumber: this.pendingBatchBeginMessage.clientSequenceNumber,
-                        pendingMessagesCount: this.pendingMessagesCount,
-                        nextPendingState: nextPendingState.type,
-                    }));
+        const batchEndMetadata = message.metadata?.batch;
+        if (this.pendingMessages.isEmpty() || batchEndMetadata === false) {
+            // Get the batch begin metadata from the first message in the batch.
+            const batchBeginMetadata = this.pendingBatchBeginMessage.metadata?.batch;
+
+            // There could be just a single message in the batch. If so, it should not have any batch metadata. If there
+            // are multiple messages in the batch, verify that we got the correct batch begin and end metadata.
+            if (this.pendingBatchBeginMessage === message) {
+                assert(batchBeginMetadata === undefined,
+                    0x16e /* "Batch with single message should not have batch metadata" */);
+            } else {
+                if (batchBeginMetadata !== true || batchEndMetadata !== false) {
+                    this.stateHandler.close(DataProcessingError.create(
+                        "Pending batch inconsistency", // Formerly known as asserts 0x16f and 0x170
+                        "processPendingLocalMessage",
+                        message,
+                        {
+                            runtimeVersion: pkgVersion,
+                            batchClientId: this.pendingBatchBeginMessage.clientId,
+                            clientId: this.stateHandler.clientId(),
+                            hasBatchStart: batchBeginMetadata === true,
+                            hasBatchEnd: batchEndMetadata === false,
+                            messageType: message.type,
+                            batchStartSequenceNumber: this.pendingBatchBeginMessage.clientSequenceNumber,
+                            pendingMessagesCount: this.pendingMessagesCount,
+                        }));
+                }
             }
-        }
 
-        // Clear the pending batch state now that we have processed the entire batch.
-        this.pendingBatchBeginMessage = undefined;
-        this.isProcessingBatch = false;
-    }
-
-    /**
-     * Returns the next pending state from the pending state queue.
-     */
-    private peekNextPendingState(): IPendingState {
-        const nextPendingState = this.pendingStates.peekFront();
-        assert(!!nextPendingState, 0x171 /* "No pending state found for the remote message" */);
-        return nextPendingState;
+            // Clear the pending batch state now that we have processed the entire batch.
+            this.pendingBatchBeginMessage = undefined;
+            this.isProcessingBatch = false;
+        }
     }
 
     /**
@@ -347,80 +329,57 @@ export class PendingStateManager implements IDisposable {
             0x173 /* "replayPendingStates called twice for same clientId!" */);
         this.clientId = this.stateHandler.clientId();
 
-        assert(this.initialStates.isEmpty(), 0x174 /* "initial states should be empty before replaying pending" */);
+        assert(this.initialMessages.isEmpty(), 0x174 /* "initial states should be empty before replaying pending" */);
 
-        let pendingStatesCount = this.pendingStates.length;
-        if (pendingStatesCount === 0) {
+        let pendingMessagesCount = this.pendingMessages.length;
+        if (pendingMessagesCount === 0) {
             return;
         }
 
-        // Reset the pending message count because all these messages will be removed from the queue.
-        this._pendingMessagesCount = 0;
-
-        const messageBatchQueue = new Deque<IPendingMessage>();
-
-        // Process exactly `pendingStatesCount` items in the queue as it represents the number of states that were
+        // Process exactly `pendingMessagesCount` items in the queue as it represents the number of messages that were
         // pending when we connected. This is important because the `reSubmitFn` might add more items in the queue
         // which must not be replayed.
-        while (pendingStatesCount > 0) {
+        while (pendingMessagesCount > 0) {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const pendingState = this.pendingStates.shift()!;
-            switch (pendingState.type) {
-                case "message":
-                    assert(pendingState.opMetadata?.batch !== false || messageBatchQueue.length > 0,
-                        0x41b /* We cannot process batches in chunks */);
-                    /**
-                     * We want to ensure grouped messages get processed in a batch.
-                     * Note: It is not possible for the PendingStateManager to receive a partially acked batch. It will
-                     * either receive the whole batch ack or nothing at all.
-                     */
-                    if (messageBatchQueue.length > 0 || pendingState.opMetadata?.batch) {
-                        messageBatchQueue.enqueue(pendingState);
-                    } else {
+            let pendingMessage = this.pendingMessages.shift()!;
+            pendingMessagesCount--;
+            assert(pendingMessage.opMetadata?.batch !== false, 0x41b /* We cannot process batches in chunks */);
+
+            /**
+             * We want to ensure grouped messages get processed in a batch.
+             * Note: It is not possible for the PendingStateManager to receive a partially acked batch. It will
+             * either receive the whole batch ack or nothing at all.
+             */
+            if (pendingMessage.opMetadata?.batch) {
+                assert(pendingMessagesCount > 0, 0x554 /* Last pending message cannot be a batch begin */);
+
+                this.stateHandler.orderSequentially(() => {
+                    while (pendingMessagesCount >= 0) { // check is >= because batch end may be last pending message
                         this.stateHandler.reSubmit(
-                            pendingState.messageType,
-                            pendingState.content,
-                            pendingState.localOpMetadata,
-                            pendingState.opMetadata);
-                    }
-                    break;
-                case "flush":
-                    /**
-                     * A "flush" call can indicate the end of a batch.
-                     * We can't rely on the "batch" property in the message metadata as it gets
-                     * updated elsewhere and it is not the same object instance that gets updated.
-                     */
-                    if (messageBatchQueue.length > 0) {
-                        this.stateHandler.orderSequentially(() => {
-                            while (messageBatchQueue.length > 0) {
-                                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                                const message = messageBatchQueue.dequeue()!;
-                                this.stateHandler.reSubmit(
-                                    message.messageType,
-                                    message.content,
-                                    message.localOpMetadata,
-                                    message.opMetadata);
-                            }
-                        });
+                            pendingMessage.messageType,
+                            pendingMessage.content,
+                            pendingMessage.localOpMetadata,
+                            pendingMessage.opMetadata);
+
+                        if (pendingMessage.opMetadata?.batch === false) {
+                            break;
+                        }
+                        assert(pendingMessagesCount > 0, 0x555 /* No batch end found */);
+
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                        pendingMessage = this.pendingMessages.shift()!;
+                        pendingMessagesCount--;
+                        assert(pendingMessage.opMetadata?.batch !== true,
+                            0x556 /* Batch start needs a corresponding batch end */);
                     }
-                    assert(messageBatchQueue.length === 0, 0x41c /* cannot flush in the middle of a batch */);
-                    this.stateHandler.flush();
-                    break;
-                default:
-                    break;
+                });
+            } else {
+                this.stateHandler.reSubmit(
+                    pendingMessage.messageType,
+                    pendingMessage.content,
+                    pendingMessage.localOpMetadata,
+                    pendingMessage.opMetadata);
             }
-            pendingStatesCount--;
-        }
-
-        // There are some cases where ops are stashed but not flushed. We need to ensure they are resubmitted
-        while (messageBatchQueue.length > 0) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const message = messageBatchQueue.dequeue()!;
-            this.stateHandler.reSubmit(
-                message.messageType,
-                message.content,
-                message.localOpMetadata,
-                message.opMetadata);
         }
     }
 }

package/src/summarizer.ts

@@ -160,7 +160,7 @@ export class Summarizer extends EventEmitter implements ISummarizer {
         // This will result in "summarizerClientDisconnected" stop reason recorded in telemetry,
         // unless stop() was called earlier
         this.dispose();
-        (this.runtime.disposeFn ?? this.runtime.closeFn)()
+        (this.runtime.disposeFn ?? this.runtime.closeFn)();
     }
 
     private async runCore(onBehalfOf: string): Promise<SummarizerStopReason> {

package/src/summarizerClientElection.ts

@@ -54,7 +54,6 @@ export class SummarizerClientElection
         private readonly summaryCollection: IEventProvider<ISummaryCollectionOpEvents>,
         public readonly clientElection: IOrderedClientElection,
         private readonly maxOpsSinceLastSummary: number,
-        private readonly electionEnabled: boolean,
     ) {
         super();
         // On every inbound op, if enough ops pass without seeing a summary ack (per elected client),
@@ -71,7 +70,7 @@ export class SummarizerClientElection
                 }
                 return;
             }
-            let electionSequenceNumber = this.clientElection.electionSequenceNumber;
+            const electionSequenceNumber = this.clientElection.electionSequenceNumber;
             const opsWithoutSummary = sequenceNumber - (this.lastSummaryAckSeqForClient ?? electionSequenceNumber);
             if (opsWithoutSummary > this.maxOpsSinceLastSummary) {
                 // Log and elect a new summarizer client.
@@ -83,37 +82,9 @@ export class SummarizerClientElection
                         lastSummaryAckSeqForClient: this.lastSummaryAckSeqForClient,
                         electionSequenceNumber,
                         nextElectedClientId: this.clientElection.peekNextElectedClient()?.clientId,
-                        electionEnabled: this.electionEnabled,
                     });
                     this.lastReportedSeq = sequenceNumber;
                 }
-
-                if (this.electionEnabled) {
-                    const previousParentId = this.electedParentId;
-                    this.clientElection.incrementElectedClient(sequenceNumber);
-
-                    // Verify that state incremented as expected. This should be reliable,
-                    // since all of OrderedClientElection is synchronous.
-                    electionSequenceNumber = this.clientElection.electionSequenceNumber;
-                    if (sequenceNumber > (this.lastSummaryAckSeqForClient ?? electionSequenceNumber)) {
-                        if (opsSinceLastReport > this.maxOpsSinceLastSummary) {
-                            this.logger.sendErrorEvent({
-                                eventName: "UnexpectedElectionSequenceNumber",
-                                // Expected to be undefined
-                                lastSummaryAckSeqForClient: this.lastSummaryAckSeqForClient,
-                                // Expected to be same as op sequenceNumber
-                                electionSequenceNumber,
-                                sequenceNumber,
-                                previousClientId: electedClientId,
-                                previousParentId,
-                                electedParentId: this.electedParentId,
-                                electedClientId: this.electedClientId,
-                                opsSinceLastReport,
-                                maxOpsSinceLastSummary,
-                            });
-                        }
-                    }
-                }
             }
         });
 

package/src/summarizerTypes.ts

@@ -96,10 +96,6 @@ export interface ISummarizerRuntime extends IConnectableRuntime {
     readonly summarizerClientId: string | undefined;
     disposeFn?(): void;
     closeFn(): void;
-    /** @deprecated 1.0, please remove all implementations and usage */
-    on(event: "batchEnd", listener: (error: any, op: ISequencedDocumentMessage) => void): this;
-    /** @deprecated 1.0, please remove all implementations and usage */
-    removeListener(event: "batchEnd", listener: (error: any, op: ISequencedDocumentMessage) => void): this;
 }
 
 /** Options affecting summarize behavior. */