@fluidframework/container-runtime 2.1.0 → 2.3.0-288113

package/lib/pendingStateManager.d.ts

@@ -2,11 +2,10 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { ICriticalContainerError } from "@fluidframework/container-definitions";
 import { IDisposable } from "@fluidframework/core-interfaces";
 import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils/internal";
 import { type InboundSequencedContainerRuntimeMessage } from "./messageTypes.js";
-import { BatchId, BatchMessage } from "./opLifecycle/index.js";
+import { BatchId, BatchMessage, InboundBatch } from "./opLifecycle/index.js";
 /**
  * This represents a message that has been submitted and is added to the pending queue when `submit` is called on the
  * ContainerRuntime. This message has either not been ack'd by the server or has not been submitted to the server yet.
@@ -20,8 +19,8 @@ export interface IPendingMessage {
     localOpMetadata: unknown;
     opMetadata: Record<string, unknown> | undefined;
     sequenceNumber?: number;
-    /** Info needed to compute the batchId on reconnect */
-    batchIdContext: {
+    /** Info about the batch this pending message belongs to, for validation and for computing the batchId on reconnect */
+    batchInfo: {
         /** The Batch's original clientId, from when it was first flushed to be submitted */
         clientId: string;
         /**
@@ -29,6 +28,8 @@ export interface IPendingMessage {
          *	@remarks A negative value means it was not yet submitted when queued here (e.g. disconnected right before flush fired)
          */
         batchStartCsn: number;
+        /** length of the batch (how many runtime messages here) */
+        length: number;
     };
 }
 export interface IPendingLocalState {
@@ -42,7 +43,6 @@ export type PendingMessageResubmitData = Pick<IPendingMessage, "content" | "loca
 export interface IRuntimeStateHandler {
     connected(): boolean;
     clientId(): string | undefined;
-    close(error?: ICriticalContainerError): void;
     applyStashedOp(content: string): Promise<unknown>;
     reSubmitBatch(batch: PendingMessageResubmitData[], batchId: BatchId): void;
     isActiveConnection: () => boolean;
@@ -71,8 +71,6 @@ export declare class PendingStateManager implements IDisposable {
     /** Used to stand in for batchStartCsn for messages that weren't submitted (so no CSN) */
     private negativeCounter;
     private readonly disposeOnce;
-    private isProcessingBatch;
-    private pendingBatchBeginMessage;
     /** Used to ensure we don't replay ops on the same connection twice */
     private clientIdFromLastReplay;
     /**
@@ -109,35 +107,38 @@ export declare class PendingStateManager implements IDisposable {
      */
     applyStashedOpsAt(seqNum?: number): Promise<void>;
     /**
-     * Processes the incoming batch from the server. It verifies that messages are received in the right order and
-     * that the batch information is correct.
-     * @param batch - The batch that is being processed.
-     * @param batchStartCsn - The clientSequenceNumber of the start of this message's batch
+     * Processes an inbound batch of messages - May be local or remote.
+     *
+     * @param batch - The inbound batch of messages to process. Could be local or remote.
+     * @param local - true if we submitted this batch and expect corresponding pending messages
+     * @returns The inbound batch's messages with localOpMetadata "zipped" in.
+     *
+     * @remarks Closes the container if:
+     * - The batchStartCsn doesn't match for local batches
      */
-    processPendingLocalBatch(batch: InboundSequencedContainerRuntimeMessage[], batchStartCsn: number): {
+    processInboundBatch(batch: InboundBatch, local: boolean): {
         message: InboundSequencedContainerRuntimeMessage;
-        localOpMetadata: unknown;
+        localOpMetadata?: unknown;
     }[];
     /**
-     * Processes a local message once its ack'd by the server. It verifies that there was no data corruption and that
-     * the batch information was preserved for batch messages.
-     * @param message - The message that got ack'd and needs to be processed.
-     * @param batchStartCsn - The clientSequenceNumber of the start of this message's batch (assigned during submit)
-     * (not to be confused with message.clientSequenceNumber - the overwritten value in case of grouped batching)
+     * Processes the incoming batch from the server that was submitted by this client.
+     * It verifies that messages are received in the right order and that the batch information is correct.
+     * @param batch - The inbound batch (originating from this client) to correlate with the pending local state
+     * @returns The inbound batch's messages with localOpMetadata "zipped" in.
      */
-    private processPendingLocalMessage;
+    private processPendingLocalBatch;
     /**
-     * This message could be the first message in batch. If so, set batch state marking the beginning of a batch.
-     * @param message - The message that is being processed.
-     * @param batchStartCsn - The clientSequenceNumber of the start of this message's batch (assigned during submit)
-     * @param pendingMessage - The corresponding pendingMessage.
+     * Processes the pending local copy of message that's been ack'd by the server.
+     * @param sequenceNumber - The sequenceNumber from the server corresponding to the next pending message.
+     * @param message - [optional] The entire incoming message, for comparing contents with the pending message for extra validation.
+     * @throws DataProcessingError if the pending message content doesn't match the incoming message content.
+     * @returns - The localOpMetadata of the next pending message, to be sent to whoever submitted the original message.
      */
-    private maybeProcessBatchBegin;
+    private processNextPendingMessage;
     /**
-     * This message could be the last message in batch. If so, clear batch state since the batch is complete.
-     * @param message - The message that is being processed.
+     * Check if the incoming batch matches the batch info for the next pending message.
      */
-    private maybeProcessBatchEnd;
+    private onLocalBatchBegin;
     /**
      * Called when the Container's connection state changes. If the Container gets connected, it replays all the pending
      * states in its queue. This includes triggering resubmission of unacked ops.

package/lib/pendingStateManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pendingStateManager.d.ts","sourceRoot":"","sources":["../src/pendingStateManager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"pendingStateManager.d.ts","sourceRoot":"","sources":["../src/pendingStateManager.ts"],"names":[],"mappings":"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"}

package/lib/pendingStateManager.js

@@ -6,25 +6,52 @@ import { assert, Lazy } from "@fluidframework/core-utils/internal";
 import { DataProcessingError, LoggingError, extractSafePropertiesFromMessage, } from "@fluidframework/telemetry-utils/internal";
 import Deque from "double-ended-queue";
 import { v4 as uuid } from "uuid";
-import { asBatchMetadata } from "./metadata.js";
+import { asBatchMetadata, asEmptyBatchLocalOpMetadata } from "./metadata.js";
 import { generateBatchId } from "./opLifecycle/index.js";
-import { pkgVersion } from "./packageVersion.js";
-function buildPendingMessageContent(
-// AnyComboFromUnion is needed need to gain access to compatDetails that
-// is only defined for some cases.
-message) {
+function isEmptyBatchPendingMessage(message) {
+    const content = JSON.parse(message.content);
+    return content.type === "groupedBatch" && content.contents?.length === 0;
+}
+function buildPendingMessageContent(message) {
     // IMPORTANT: Order matters here, this must match the order of the properties used
     // when submitting the message.
     const { type, contents, compatDetails } = message;
     // Any properties that are not defined, won't be emitted by stringify.
     return JSON.stringify({ type, contents, compatDetails });
 }
+function typesOfKeys(obj) {
+    return Object.keys(obj).reduce((acc, key) => {
+        acc[key] = typeof obj[key];
+        return acc;
+    }, {});
+}
+function scrubAndStringify(message) {
+    // Scrub the whole object in case there are unexpected keys
+    const scrubbed = typesOfKeys(message);
+    // For these known/expected keys, we can either drill in (for contents)
+    // or just use the value as-is (since it's not personal info)
+    scrubbed.contents = message.contents && typesOfKeys(message.contents);
+    scrubbed.compatDetails = message.compatDetails;
+    scrubbed.type = message.type;
+    return JSON.stringify(scrubbed);
+}
 function withoutLocalOpMetadata(message) {
     return {
         ...message,
         localOpMetadata: undefined,
     };
 }
+/**
+ * Get the effective batch ID for a pending message.
+ * If the batch ID is already present in the message's op metadata, return it.
+ * Otherwise, generate a new batch ID using the client ID and batch start CSN.
+ * @param pendingMessage - The pending message
+ * @returns The effective batch ID
+ */
+function getEffectiveBatchId(pendingMessage) {
+    return (asBatchMetadata(pendingMessage.opMetadata)?.batchId ??
+        generateBatchId(pendingMessage.batchInfo.clientId, pendingMessage.batchInfo.batchStartCsn));
+}
 /**
  * PendingStateManager is responsible for maintaining the messages that have not been sent or have not yet been
  * acknowledged by the server. It also maintains the batch information for both automatically and manually flushed
@@ -96,8 +123,6 @@ export class PendingStateManager {
             this.initialMessages.clear();
             this.pendingMessages.clear();
         });
-        // Indicates whether we are processing a batch.
-        this.isProcessingBatch = false;
         this.dispose = () => this.disposeOnce.value;
         if (stashedLocalState?.pendingStates) {
             this.initialMessages.push(...stashedLocalState.pendingStates);
@@ -130,8 +155,8 @@ export class PendingStateManager {
                 content,
                 localOpMetadata,
                 opMetadata,
-                // Note: We only need this on the first message.
-                batchIdContext: { clientId, batchStartCsn },
+                // Note: We only will read this off the first message, but put it on all for simplicity
+                batchInfo: { clientId, batchStartCsn, length: batch.length },
             };
             this.pendingMessages.push(pendingMessage);
         }
@@ -155,7 +180,15 @@ export class PendingStateManager {
             }
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const nextMessage = this.initialMessages.shift();
+            // Nothing to apply if the message is an empty batch.
+            // We still need to track it for resubmission.
             try {
+                if (isEmptyBatchPendingMessage(nextMessage)) {
+                    nextMessage.localOpMetadata = { emptyBatch: true }; // equivalent to applyStashedOp for empty batch
+                    patchbatchInfo(nextMessage); // Back compat
+                    this.pendingMessages.push(nextMessage);
+                    continue;
+                }
                 // 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.content);
                 if (!this.stateHandler.isAttached()) {
@@ -166,7 +199,7 @@ export class PendingStateManager {
                 else {
                     nextMessage.localOpMetadata = localOpMetadata;
                     // then we push onto pendingMessages which will cause PendingStateManager to resubmit when we connect
-                    patchBatchIdContext(nextMessage); // Back compat
+                    patchbatchInfo(nextMessage); // Back compat
                     this.pendingMessages.push(nextMessage);
                 }
             }
@@ -176,117 +209,113 @@ export class PendingStateManager {
         }
     }
     /**
-     * Processes the incoming batch from the server. It verifies that messages are received in the right order and
-     * that the batch information is correct.
-     * @param batch - The batch that is being processed.
-     * @param batchStartCsn - The clientSequenceNumber of the start of this message's batch
+     * Processes an inbound batch of messages - May be local or remote.
+     *
+     * @param batch - The inbound batch of messages to process. Could be local or remote.
+     * @param local - true if we submitted this batch and expect corresponding pending messages
+     * @returns The inbound batch's messages with localOpMetadata "zipped" in.
+     *
+     * @remarks Closes the container if:
+     * - The batchStartCsn doesn't match for local batches
+     */
+    processInboundBatch(batch, local) {
+        if (local) {
+            return this.processPendingLocalBatch(batch);
+        }
+        // No localOpMetadata for remote messages
+        return batch.messages.map((message) => ({ message }));
+    }
+    /**
+     * Processes the incoming batch from the server that was submitted by this client.
+     * It verifies that messages are received in the right order and that the batch information is correct.
+     * @param batch - The inbound batch (originating from this client) to correlate with the pending local state
+     * @returns The inbound batch's messages with localOpMetadata "zipped" in.
      */
-    processPendingLocalBatch(batch, batchStartCsn) {
-        return batch.map((message) => ({
+    processPendingLocalBatch(batch) {
+        this.onLocalBatchBegin(batch);
+        // Empty batch
+        if (batch.messages.length === 0) {
+            assert(batch.emptyBatchSequenceNumber !== undefined, 0x9fb /* Expected sequence number for empty batch */);
+            const localOpMetadata = this.processNextPendingMessage(batch.emptyBatchSequenceNumber);
+            assert(asEmptyBatchLocalOpMetadata(localOpMetadata)?.emptyBatch === true, 0xa20 /* Expected empty batch marker */);
+            return [];
+        }
+        return batch.messages.map((message) => ({
             message,
-            localOpMetadata: this.processPendingLocalMessage(message, batchStartCsn),
+            localOpMetadata: this.processNextPendingMessage(message.sequenceNumber, message),
         }));
     }
     /**
-     * Processes a local message once its ack'd by the server. It verifies that there was no data corruption and that
-     * the batch information was preserved for batch messages.
-     * @param message - The message that got ack'd and needs to be processed.
-     * @param batchStartCsn - The clientSequenceNumber of the start of this message's batch (assigned during submit)
-     * (not to be confused with message.clientSequenceNumber - the overwritten value in case of grouped batching)
+     * Processes the pending local copy of message that's been ack'd by the server.
+     * @param sequenceNumber - The sequenceNumber from the server corresponding to the next pending message.
+     * @param message - [optional] The entire incoming message, for comparing contents with the pending message for extra validation.
+     * @throws DataProcessingError if the pending message content doesn't match the incoming message content.
+     * @returns - The localOpMetadata of the next pending message, to be sent to whoever submitted the original message.
      */
-    processPendingLocalMessage(message, batchStartCsn) {
-        // Get the next message from the pending queue. Verify a message exists.
+    processNextPendingMessage(sequenceNumber, message) {
         const pendingMessage = this.pendingMessages.peekFront();
         assert(pendingMessage !== undefined, 0x169 /* "No pending message found for this remote message" */);
-        // This may be the start of a batch.
-        this.maybeProcessBatchBegin(message, batchStartCsn, pendingMessage);
-        pendingMessage.sequenceNumber = message.sequenceNumber;
+        pendingMessage.sequenceNumber = sequenceNumber;
         this.savedOps.push(withoutLocalOpMetadata(pendingMessage));
         this.pendingMessages.shift();
-        const messageContent = buildPendingMessageContent(message);
-        // Stringified content should match
-        if (pendingMessage.content !== messageContent) {
-            this.stateHandler.close(DataProcessingError.create("pending local message content mismatch", "unexpectedAckReceived", message, {
-                expectedMessageType: JSON.parse(pendingMessage.content).type,
-            }));
-            return;
-        }
-        // Post-processing part - If we are processing a batch then this could be the last message in the batch.
-        this.maybeProcessBatchEnd(message);
-        return pendingMessage.localOpMetadata;
-    }
-    /**
-     * This message could be the first message in batch. If so, set batch state marking the beginning of a batch.
-     * @param message - The message that is being processed.
-     * @param batchStartCsn - The clientSequenceNumber of the start of this message's batch (assigned during submit)
-     * @param pendingMessage - The corresponding pendingMessage.
-     */
-    maybeProcessBatchBegin(message, batchStartCsn, pendingMessage) {
-        if (!this.isProcessingBatch) {
-            // Expecting the start of a batch (maybe single-message).
-            if (pendingMessage.batchIdContext.batchStartCsn !== batchStartCsn) {
-                this.logger?.sendErrorEvent({
-                    eventName: "BatchClientSequenceNumberMismatch",
+        // message is undefined in the Empty Batch case,
+        // because we don't have an incoming message to compare and pendingMessage is just a placeholder anyway.
+        if (message !== undefined) {
+            const messageContent = buildPendingMessageContent(message);
+            // Stringified content should match
+            if (pendingMessage.content !== messageContent) {
+                const pendingContentObj = JSON.parse(pendingMessage.content);
+                const incomingContentObj = JSON.parse(messageContent);
+                const contentsMatch = pendingContentObj.contents === incomingContentObj.contents ||
+                    (pendingContentObj.contents !== undefined &&
+                        incomingContentObj.contents !== undefined &&
+                        JSON.stringify(pendingContentObj.contents) ===
+                            JSON.stringify(incomingContentObj.contents));
+                this.logger.sendErrorEvent({
+                    eventName: "unexpectedAckReceived",
                     details: {
-                        processingBatch: !!this.pendingBatchBeginMessage,
-                        pendingBatchCsn: pendingMessage.batchIdContext.batchStartCsn,
-                        batchStartCsn,
-                        messageBatchMetadata: message.metadata?.batch,
-                        pendingMessageBatchMetadata: pendingMessage.opMetadata?.batch,
+                        pendingContentScrubbed: scrubAndStringify(pendingContentObj),
+                        incomingContentScrubbed: scrubAndStringify(incomingContentObj),
+                        contentsMatch,
                     },
-                    messageDetails: extractSafePropertiesFromMessage(message),
                 });
+                throw DataProcessingError.create("pending local message content mismatch", "unexpectedAckReceived", message);
             }
         }
-        // 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.
-            assert(!this.isProcessingBatch && this.pendingBatchBeginMessage === undefined, 0x16b /* "The pending batch state indicates we are already processing a batch" */);
-            // Set the pending batch state indicating we have started processing a batch.
-            this.pendingBatchBeginMessage = message;
-            this.isProcessingBatch = true;
-        }
+        return pendingMessage.localOpMetadata;
     }
     /**
-     * This message could be the last message in batch. If so, clear batch state since the batch is complete.
-     * @param message - The message that is being processed.
+     * Check if the incoming batch matches the batch info for the next pending message.
      */
-    maybeProcessBatchEnd(message) {
-        if (!this.isProcessingBatch) {
-            return;
-        }
-        // There should be a pending batch begin message.
-        assert(this.pendingBatchBeginMessage !== undefined, 0x16d /* "There is no pending batch begin message" */);
-        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: 
-                        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-                        this.pendingBatchBeginMessage.clientId === null
-                            ? "null"
-                            : this.pendingBatchBeginMessage.clientId,
-                        clientId: this.stateHandler.clientId(),
-                        hasBatchStart: batchBeginMetadata === true,
-                        hasBatchEnd: batchEndMetadata === false,
-                        messageType: message.type,
-                        pendingMessagesCount: this.pendingMessagesCount,
-                    }));
-                }
-            }
-            // Clear the pending batch state now that we have processed the entire batch.
-            this.pendingBatchBeginMessage = undefined;
-            this.isProcessingBatch = false;
+    onLocalBatchBegin(batch) {
+        // Get the next message from the pending queue. Verify a message exists.
+        const pendingMessage = this.pendingMessages.peekFront();
+        assert(pendingMessage !== undefined, 0xa21 /* No pending message found as we start processing this remote batch */);
+        // Note: This could be undefined if this batch became empty on resubmit.
+        // In this case the next pending message is an empty batch marker.
+        // Empty batches became empty on Resubmit, and submit them and track them in case
+        // a different fork of this container also submitted the same batch (and it may not be empty for that fork).
+        const firstMessage = batch.messages.length > 0 ? batch.messages[0] : undefined;
+        const expectedPendingBatchLength = batch.messages.length === 0 ? 1 : batch.messages.length;
+        // We expect the incoming batch to be of the same length, starting at the same clientSequenceNumber,
+        // as the batch we originally submitted.
+        // We have another later check to compare the message contents, which we'd expect to fail if this check does,
+        // so we don't throw here, merely log.  In a later release this check may replace that one.
+        if (pendingMessage.batchInfo.batchStartCsn !== batch.batchStartCsn ||
+            (pendingMessage.batchInfo.length >= 0 && // -1 length is back compat and isn't suitable for this check
+                pendingMessage.batchInfo.length !== expectedPendingBatchLength)) {
+            this.logger?.sendErrorEvent({
+                eventName: "BatchInfoMismatch",
+                details: {
+                    pendingBatchCsn: pendingMessage.batchInfo.batchStartCsn,
+                    batchStartCsn: batch.batchStartCsn,
+                    pendingBatchLength: pendingMessage.batchInfo.length,
+                    batchLength: batch.messages.length,
+                    pendingMessageBatchMetadata: asBatchMetadata(pendingMessage.opMetadata)?.batch,
+                    messageBatchMetadata: asBatchMetadata(firstMessage?.metadata)?.batch,
+                },
+                messageDetails: firstMessage && extractSafePropertiesFromMessage(firstMessage),
+            });
         }
     }
     /**
@@ -312,10 +341,12 @@ export class PendingStateManager {
             const batchMetadataFlag = asBatchMetadata(pendingMessage.opMetadata)?.batch;
             assert(batchMetadataFlag !== false, 0x41b /* We cannot process batches in chunks */);
             // The next message starts a batch (possibly single-message), and we'll need its batchId.
-            // We'll find batchId on this message if it was previously generated.
-            // Otherwise, generate it now - this is the first time resubmitting this batch.
-            const batchId = asBatchMetadata(pendingMessage.opMetadata)?.batchId ??
-                generateBatchId(pendingMessage.batchIdContext.clientId, pendingMessage.batchIdContext.batchStartCsn);
+            const batchId = getEffectiveBatchId(pendingMessage);
+            // Resubmit no messages, with the batchId. Will result in another empty batch marker.
+            if (asEmptyBatchLocalOpMetadata(pendingMessage.localOpMetadata)?.emptyBatch === true) {
+                this.stateHandler.reSubmitBatch([], batchId);
+                continue;
+            }
             /**
              * We must preserve the distinct batches on resubmit.
              * Note: It is not possible for the PendingStateManager to receive a partially acked batch. It will
@@ -367,12 +398,12 @@ export class PendingStateManager {
         }
     }
 }
-/** For back-compat if trying to apply stashed ops that pre-date batchIdContext */
-function patchBatchIdContext(message) {
-    const batchIdContext = message.batchIdContext;
-    if (batchIdContext === undefined) {
+/** For back-compat if trying to apply stashed ops that pre-date batchInfo */
+function patchbatchInfo(message) {
+    const batchInfo = message.batchInfo;
+    if (batchInfo === undefined) {
         // Using uuid guarantees uniqueness, retaining existing behavior
-        message.batchIdContext = { clientId: uuid(), batchStartCsn: -1 };
+        message.batchInfo = { clientId: uuid(), batchStartCsn: -1, length: -1 };
     }
 }
 //# sourceMappingURL=pendingStateManager.js.map