@fluidframework/container-runtime 2.1.0-281041 → 2.1.1

package/src/opLifecycle/remoteMessageProcessor.ts

@@ -13,6 +13,7 @@ import {
 	ContainerMessageType,
 	type InboundContainerRuntimeMessage,
 	type InboundSequencedContainerRuntimeMessage,
+	type InboundSequencedContainerRuntimeMessageOrSystemMessage,
 	type InboundSequencedRecentlyAddedContainerRuntimeMessage,
 } from "../messageTypes.js";
 import { asBatchMetadata } from "../metadata.js";
@@ -35,7 +36,6 @@ export class RemoteMessageProcessor {
 	 * @remarks For chunked batches, this is the CSN of the "representative" chunk (the final chunk)
 	 */
 	private batchStartCsn: number | undefined;
-	private readonly processorBatch: InboundSequencedContainerRuntimeMessage[] = [];
 
 	constructor(
 		private readonly opSplitter: OpSplitter,
@@ -52,7 +52,7 @@ export class RemoteMessageProcessor {
 	}
 
 	/**
-	 * Ungroups and Unchunks the runtime ops of a batch received over the wire
+	 * Ungroups and Unchunks the runtime ops encapsulated by the single remoteMessage received over the wire
 	 * @param remoteMessageCopy - A shallow copy of a message from another client, possibly virtualized
 	 * (grouped, compressed, and/or chunked).
 	 * Being a shallow copy, it's considered mutable, meaning no other Container or other parallel procedure
@@ -67,19 +67,18 @@ export class RemoteMessageProcessor {
 	 * 3. If grouped, ungroup the message
 	 * For more details, see https://github.com/microsoft/FluidFramework/blob/main/packages/runtime/container-runtime/src/opLifecycle/README.md#inbound
 	 *
-	 * @returns all the unchunked, decompressed, ungrouped, unpacked InboundSequencedContainerRuntimeMessage from a single batch
-	 * or undefined if the batch is not yet complete.
+	 * @returns the unchunked, decompressed, ungrouped, unpacked SequencedContainerRuntimeMessages encapsulated in the remote message.
+	 * For ops that weren't virtualized (e.g. System ops that the ContainerRuntime will ultimately ignore),
+	 * a singleton array [remoteMessageCopy] is returned
 	 */
 	public process(remoteMessageCopy: ISequencedDocumentMessage):
 		| {
-				messages: InboundSequencedContainerRuntimeMessage[];
+				messages: InboundSequencedContainerRuntimeMessageOrSystemMessage[];
 				batchStartCsn: number;
 		  }
 		| undefined {
 		let message = remoteMessageCopy;
 
-		ensureContentsDeserialized(message);
-
 		if (isChunkedMessage(message)) {
 			const chunkProcessingResult = this.opSplitter.processChunk(message);
 			// Only continue further if current chunk is the final chunk
@@ -104,10 +103,9 @@ export class RemoteMessageProcessor {
 
 		if (isGroupedBatch(message)) {
 			// We should be awaiting a new batch (batchStartCsn undefined)
-			assert(this.batchStartCsn === undefined, "Grouped batch interrupting another batch");
 			assert(
-				this.processorBatch.length === 0,
-				"Processor batch should be empty on grouped batch",
+				this.batchStartCsn === undefined,
+				0x9d3 /* Grouped batch interrupting another batch */,
 			);
 			return {
 				messages: this.opGroupingManager.ungroupOp(message).map(unpack),
@@ -119,20 +117,8 @@ export class RemoteMessageProcessor {
 
 		// Do a final unpack of runtime messages in case the message was not grouped, compressed, or chunked
 		unpackRuntimeMessage(message);
-		this.processorBatch.push(message as InboundSequencedContainerRuntimeMessage);
-
-		// this.batchStartCsn is undefined only if we have processed all messages in the batch.
-		// If it's still defined, we're still in the middle of a batch, so we return nothing, letting
-		// containerRuntime know that we're waiting for more messages to complete the batch.
-		if (this.batchStartCsn !== undefined) {
-			// batch not yet complete
-			return undefined;
-		}
-
-		const messages = [...this.processorBatch];
-		this.processorBatch.length = 0;
 		return {
-			messages,
+			messages: [message as InboundSequencedContainerRuntimeMessageOrSystemMessage],
 			batchStartCsn,
 		};
 	}
@@ -146,7 +132,7 @@ export class RemoteMessageProcessor {
 		const batchMetadataFlag = asBatchMetadata(message.metadata)?.batch;
 		if (this.batchStartCsn === undefined) {
 			// We are waiting for a new batch
-			assert(batchMetadataFlag !== false, "Unexpected batch end marker");
+			assert(batchMetadataFlag !== false, 0x9d5 /* Unexpected batch end marker */);
 
 			// Start of a new multi-message batch
 			if (batchMetadataFlag === true) {
@@ -162,7 +148,7 @@ export class RemoteMessageProcessor {
 		// We are in the middle or end of an existing multi-message batch. Return the current batchStartCsn
 		const batchStartCsn = this.batchStartCsn;
 
-		assert(batchMetadataFlag !== true, "Unexpected batch start marker");
+		assert(batchMetadataFlag !== true, 0x9d6 /* Unexpected batch start marker */);
 		if (batchMetadataFlag === false) {
 			// Batch end? Then get ready for the next batch to start
 			this.batchStartCsn = undefined;
@@ -173,12 +159,27 @@ export class RemoteMessageProcessor {
 }
 
 /** Takes an incoming message and if the contents is a string, JSON.parse's it in place */
-function ensureContentsDeserialized(mutableMessage: ISequencedDocumentMessage): void {
+export function ensureContentsDeserialized(
+	mutableMessage: ISequencedDocumentMessage,
+	modernRuntimeMessage: boolean,
+	logLegacyCase: (codePath: string) => void,
+): void {
 	// back-compat: ADO #1385: eventually should become unconditional, but only for runtime messages!
 	// System message may have no contents, or in some cases (mostly for back-compat) they may have actual objects.
 	// Old ops may contain empty string (I assume noops).
+	let parsedJsonContents: boolean;
 	if (typeof mutableMessage.contents === "string" && mutableMessage.contents !== "") {
 		mutableMessage.contents = JSON.parse(mutableMessage.contents);
+		parsedJsonContents = true;
+	} else {
+		parsedJsonContents = false;
+	}
+
+	// We expect Modern Runtime Messages to have JSON serialized contents,
+	// and all other messages not to (system messages and legacy runtime messages without outer "op" type envelope)
+	// Let's observe if we are wrong about this to learn about these cases.
+	if (modernRuntimeMessage !== parsedJsonContents) {
+		logLegacyCase("ensureContentsDeserialized_unexpectedContentsType");
 	}
 }
 
@@ -214,7 +215,10 @@ function unpack(message: ISequencedDocumentMessage): InboundSequencedContainerRu
  *
  * @internal
  */
-export function unpackRuntimeMessage(message: ISequencedDocumentMessage): boolean {
+export function unpackRuntimeMessage(
+	message: ISequencedDocumentMessage,
+	logLegacyCase: (codePath: string) => void = () => {},
+): boolean {
 	if (message.type !== MessageType.Operation) {
 		// Legacy format, but it's already "unpacked",
 		// i.e. message.type is actually ContainerMessageType.
@@ -230,6 +234,7 @@ export function unpackRuntimeMessage(message: ISequencedDocumentMessage): boolea
 		(message.contents as { type?: unknown }).type === undefined
 	) {
 		message.type = ContainerMessageType.FluidDataStoreOp;
+		logLegacyCase("unpackRuntimeMessage_contentsWithAddress");
 	} else {
 		// new format
 		unpack(message);

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.1.0-281041";
+export const pkgVersion = "2.1.1";

package/src/pendingStateManager.ts

@@ -16,7 +16,7 @@ import {
 import Deque from "double-ended-queue";
 import { v4 as uuid } from "uuid";
 
-import { type InboundSequencedContainerRuntimeMessage } from "./messageTypes.js";
+import { InboundSequencedContainerRuntimeMessage } from "./messageTypes.js";
 import { asBatchMetadata, IBatchMetadata } from "./metadata.js";
 import { BatchId, BatchMessage, generateBatchId } from "./opLifecycle/index.js";
 import { pkgVersion } from "./packageVersion.js";
@@ -293,25 +293,6 @@ export class PendingStateManager implements IDisposable {
 		}
 	}
 
-	/**
-	 * 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
-	 */
-	public processPendingLocalBatch(
-		batch: InboundSequencedContainerRuntimeMessage[],
-		batchStartCsn: number,
-	): {
-		message: InboundSequencedContainerRuntimeMessage;
-		localOpMetadata: unknown;
-	}[] {
-		return batch.map((message) => ({
-			message,
-			localOpMetadata: this.processPendingLocalMessage(message, batchStartCsn),
-		}));
-	}
-
 	/**
 	 * 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.
@@ -319,7 +300,7 @@ export class PendingStateManager implements IDisposable {
 	 * @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)
 	 */
-	private processPendingLocalMessage(
+	public processPendingLocalMessage(
 		message: InboundSequencedContainerRuntimeMessage,
 		batchStartCsn: number,
 	): unknown {