@fluidframework/container-runtime 2.0.0-dev.2.3.0.115467 → 2.0.0-dev.3.1.0.125672

package/src/opLifecycle/outbox.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { assert } from "@fluidframework/common-utils";
 import { IContainerContext } from "@fluidframework/container-definitions";
 import { GenericError } from "@fluidframework/container-utils";
@@ -12,193 +13,216 @@ import { PendingStateManager } from "../pendingStateManager";
 import { BatchManager } from "./batchManager";
 import { BatchMessage, IBatch } from "./definitions";
 import { OpCompressor } from "./opCompressor";
+import { OpSplitter } from "./opSplitter";
 
 export interface IOutboxConfig {
-    readonly compressionOptions: ICompressionRuntimeOptions;
-    // The maximum size of a batch that we can send over the wire.
-    readonly maxBatchSizeInBytes: number;
-};
+	readonly compressionOptions: ICompressionRuntimeOptions;
+	// The maximum size of a batch that we can send over the wire.
+	readonly maxBatchSizeInBytes: number;
+	readonly enableOpReentryCheck?: boolean;
+}
 
 export interface IOutboxParameters {
-    readonly shouldSend: () => boolean,
-    readonly pendingStateManager: PendingStateManager,
-    readonly containerContext: IContainerContext,
-    readonly config: IOutboxConfig,
-    readonly compressor: OpCompressor;
+	readonly shouldSend: () => boolean;
+	readonly pendingStateManager: PendingStateManager;
+	readonly containerContext: IContainerContext;
+	readonly config: IOutboxConfig;
+	readonly compressor: OpCompressor;
+	readonly splitter: OpSplitter;
+	readonly logger: ITelemetryLogger;
 }
 
 export class Outbox {
-    private readonly attachFlowBatch: BatchManager;
-    private readonly mainBatch: BatchManager;
-    private readonly defaultAttachFlowSoftLimitInBytes = 64 * 1024;
-
-    constructor(private readonly params: IOutboxParameters) {
-        const isCompressionEnabled = this.params.config.compressionOptions.minimumBatchSizeInBytes !== Number.POSITIVE_INFINITY;
-        // We need to allow infinite size batches if we enable compression
-        const hardLimit = isCompressionEnabled ? Infinity : this.params.config.maxBatchSizeInBytes;
-        const softLimit = isCompressionEnabled ? Infinity : this.defaultAttachFlowSoftLimitInBytes;
-
-        this.attachFlowBatch = new BatchManager({
-            hardLimit,
-            softLimit,
-        });
-        this.mainBatch = new BatchManager({
-            hardLimit
-        });
-    }
-
-    public get isEmpty(): boolean {
-        return this.attachFlowBatch.length === 0 && this.mainBatch.length === 0;
-    }
-
-    public submit(message: BatchMessage) {
-        if (!this.mainBatch.push(message)) {
-            throw new GenericError(
-                "BatchTooLarge",
-                /* error */ undefined,
-                {
-                    opSize: (message.contents?.length) ?? 0,
-                    count: this.mainBatch.length,
-                    limit: this.mainBatch.options.hardLimit,
-                });
-        }
-    }
-
-    public submitAttach(message: BatchMessage) {
-        if (!this.attachFlowBatch.push(message)) {
-            // BatchManager has two limits - soft limit & hard limit. Soft limit is only engaged
-            // when queue is not empty.
-            // Flush queue & retry. Failure on retry would mean - single message is bigger than hard limit
-            this.flushInternal(this.attachFlowBatch.popBatch());
-            if (!this.attachFlowBatch.push(message)) {
-                throw new GenericError(
-                    "BatchTooLarge",
-                    /* error */ undefined,
-                    {
-                        opSize: (message.contents?.length) ?? 0,
-                        count: this.attachFlowBatch.length,
-                        limit: this.attachFlowBatch.options.hardLimit,
-                    });
-            }
-        }
-
-        // If compression is enabled, we will always successfully receive
-        // attach ops and compress then send them at the next JS turn, regardless
-        // of the overall size of the accumulated ops in the batch.
-        // However, it is more efficient to flush these ops faster, preferably
-        // after they reach a size which would benefit from compression.
-        if (this.attachFlowBatch.contentSizeInBytes >= this.params.config.compressionOptions.minimumBatchSizeInBytes) {
-            this.flushInternal(this.attachFlowBatch.popBatch());
-        }
-    }
-
-    public flush() {
-        this.flushInternal(this.attachFlowBatch.popBatch());
-        this.flushInternal(this.mainBatch.popBatch());
-    }
-
-    private flushInternal(rawBatch: IBatch) {
-        const processedBatch = this.compressBatch(rawBatch);
-        const clientSequenceNumber = this.sendBatch(processedBatch);
-
-        this.persistBatch(clientSequenceNumber, rawBatch.content);
-    }
-
-    private compressBatch(batch: IBatch): IBatch {
-        if (batch.content.length === 0
-            || this.params.config.compressionOptions === undefined
-            || this.params.config.compressionOptions.minimumBatchSizeInBytes > batch.contentSizeInBytes) {
-            // Nothing to do if the batch is empty or if compression is disabled or if we don't need to compress
-            return batch;
-        }
-
-        const compressedBatch = this.params.compressor.compressBatch(batch);
-        if (compressedBatch.contentSizeInBytes > this.params.config.maxBatchSizeInBytes) {
-            throw new GenericError(
-                "BatchTooLarge",
-                    /* error */ undefined,
-                {
-                    opSize: batch.contentSizeInBytes,
-                    count: batch.content.length,
-                    limit: this.params.config.maxBatchSizeInBytes,
-                    compressed: true,
-                });
-        }
-
-        // If we don't reach the maximum supported size of a batch, it safe to be sent as is
-        return compressedBatch;
-    }
-
-    /**
-     * Sends the batch object to the container context to be sent over the wire.
-     *
-     * @param batch - batch to be sent
-     * @returns the client sequence number of the last batched op which was sent and
-     * -1 if there are no ops or the container cannot send ops.
-     */
-    private sendBatch(batch: IBatch): number {
-        let clientSequenceNumber: number = -1;
-        const length = batch.content.length;
-
-        // Did we disconnect in the middle of turn-based batch?
-        // If so, do nothing, as pending state manager will resubmit it correctly on reconnect.
-        if (length === 0 || !this.params.shouldSend()) {
-            return clientSequenceNumber;
-        }
-
-        if (this.params.containerContext.submitBatchFn === undefined) {
-            // Legacy path - supporting old loader versions. Can be removed only when LTS moves above
-            // version that has support for batches (submitBatchFn)
-            for (const message of batch.content) {
-                // Legacy path doesn't support compressed payloads and will submit uncompressed payload anyways
-                if (message.metadata?.compressed) {
-                    delete message.metadata.compressed;
-                }
-
-                clientSequenceNumber = this.params.containerContext.submitFn(
-                    MessageType.Operation,
-                    message.deserializedContent,
-                    true, // batch
-                    message.metadata);
-            }
-
-            this.params.containerContext.deltaManager.flush();
-        } else {
-            // returns clientSequenceNumber of last message in a batch
-            clientSequenceNumber = this.params.containerContext.submitBatchFn(
-                batch.content.map((message) => ({ contents: message.contents, metadata: message.metadata })));
-        }
-
-        // Convert from clientSequenceNumber of last message in the batch to clientSequenceNumber of first message.
-        clientSequenceNumber -= length - 1;
-        assert(clientSequenceNumber >= 0, 0x3d0 /* clientSequenceNumber can't be negative */);
-        return clientSequenceNumber;
-    }
-
-    private persistBatch(initialClientSequenceNumber: number, batch: BatchMessage[]) {
-        let clientSequenceNumber = initialClientSequenceNumber;
-        // Let the PendingStateManager know that a message was submitted.
-        // In future, need to shift toward keeping batch as a whole!
-        for (const message of batch) {
-            this.params.pendingStateManager.onSubmitMessage(
-                message.deserializedContent.type,
-                clientSequenceNumber,
-                message.referenceSequenceNumber,
-                message.deserializedContent.contents,
-                message.localOpMetadata,
-                message.metadata,
-            );
-
-            clientSequenceNumber++;
-        }
-
-        this.params.pendingStateManager.onFlush();
-    }
-
-    public checkpoint() {
-        return {
-            mainBatch: this.mainBatch.checkpoint(),
-            attachFlowBatch: this.attachFlowBatch.checkpoint(),
-        };
-    }
+	private readonly attachFlowBatch: BatchManager;
+	private readonly mainBatch: BatchManager;
+	private readonly defaultAttachFlowSoftLimitInBytes = 64 * 1024;
+
+	constructor(private readonly params: IOutboxParameters) {
+		const isCompressionEnabled =
+			this.params.config.compressionOptions.minimumBatchSizeInBytes !==
+			Number.POSITIVE_INFINITY;
+		// We need to allow infinite size batches if we enable compression
+		const hardLimit = isCompressionEnabled ? Infinity : this.params.config.maxBatchSizeInBytes;
+		const softLimit = isCompressionEnabled ? Infinity : this.defaultAttachFlowSoftLimitInBytes;
+
+		this.attachFlowBatch = new BatchManager(
+			{
+				hardLimit,
+				softLimit,
+				enableOpReentryCheck: params.config.enableOpReentryCheck,
+			},
+			params.logger,
+		);
+		this.mainBatch = new BatchManager(
+			{
+				hardLimit,
+				enableOpReentryCheck: params.config.enableOpReentryCheck,
+			},
+			params.logger,
+		);
+	}
+
+	public get isEmpty(): boolean {
+		return this.attachFlowBatch.length === 0 && this.mainBatch.length === 0;
+	}
+
+	public submit(message: BatchMessage) {
+		if (!this.mainBatch.push(message)) {
+			throw new GenericError("BatchTooLarge", /* error */ undefined, {
+				opSize: message.contents?.length ?? 0,
+				batchSize: this.mainBatch.contentSizeInBytes,
+				count: this.mainBatch.length,
+				limit: this.mainBatch.options.hardLimit,
+			});
+		}
+	}
+
+	public submitAttach(message: BatchMessage) {
+		if (!this.attachFlowBatch.push(message)) {
+			// BatchManager has two limits - soft limit & hard limit. Soft limit is only engaged
+			// when queue is not empty.
+			// Flush queue & retry. Failure on retry would mean - single message is bigger than hard limit
+			this.flushInternal(this.attachFlowBatch.popBatch());
+			if (!this.attachFlowBatch.push(message)) {
+				throw new GenericError("BatchTooLarge", /* error */ undefined, {
+					opSize: message.contents?.length ?? 0,
+					batchSize: this.attachFlowBatch.contentSizeInBytes,
+					count: this.attachFlowBatch.length,
+					limit: this.attachFlowBatch.options.hardLimit,
+				});
+			}
+		}
+
+		// If compression is enabled, we will always successfully receive
+		// attach ops and compress then send them at the next JS turn, regardless
+		// of the overall size of the accumulated ops in the batch.
+		// However, it is more efficient to flush these ops faster, preferably
+		// after they reach a size which would benefit from compression.
+		if (
+			this.attachFlowBatch.contentSizeInBytes >=
+			this.params.config.compressionOptions.minimumBatchSizeInBytes
+		) {
+			this.flushInternal(this.attachFlowBatch.popBatch());
+		}
+	}
+
+	public flush() {
+		this.flushInternal(this.attachFlowBatch.popBatch());
+		this.flushInternal(this.mainBatch.popBatch());
+	}
+
+	private flushInternal(rawBatch: IBatch) {
+		const processedBatch = this.compressBatch(rawBatch);
+		const clientSequenceNumber = this.sendBatch(processedBatch);
+
+		this.persistBatch(clientSequenceNumber, rawBatch.content);
+	}
+
+	private compressBatch(batch: IBatch): IBatch {
+		if (
+			batch.content.length === 0 ||
+			this.params.config.compressionOptions === undefined ||
+			this.params.config.compressionOptions.minimumBatchSizeInBytes > batch.contentSizeInBytes
+		) {
+			// Nothing to do if the batch is empty or if compression is disabled or if we don't need to compress
+			return batch;
+		}
+
+		const compressedBatch = this.params.compressor.compressBatch(batch);
+		if (compressedBatch.contentSizeInBytes <= this.params.config.maxBatchSizeInBytes) {
+			// If we don't reach the maximum supported size of a batch, it can safely be sent as is
+			return compressedBatch;
+		}
+
+		if (this.params.splitter.isBatchChunkingEnabled) {
+			return this.params.splitter.splitCompressedBatch(compressedBatch);
+		}
+
+		// If we've reached this point, the runtime would attempt to send a batch larger than the allowed size
+		throw new GenericError("BatchTooLarge", /* error */ undefined, {
+			batchSize: batch.contentSizeInBytes,
+			compressedBatchSize: compressedBatch.contentSizeInBytes,
+			count: compressedBatch.content.length,
+			limit: this.params.config.maxBatchSizeInBytes,
+			chunkingEnabled: this.params.splitter.isBatchChunkingEnabled,
+			compressionOptions: JSON.stringify(this.params.config.compressionOptions),
+		});
+	}
+
+	/**
+	 * Sends the batch object to the container context to be sent over the wire.
+	 *
+	 * @param batch - batch to be sent
+	 * @returns the client sequence number of the last batched op which was sent and
+	 * -1 if there are no ops or the container cannot send ops.
+	 */
+	private sendBatch(batch: IBatch): number {
+		let clientSequenceNumber: number = -1;
+		const length = batch.content.length;
+
+		// Did we disconnect in the middle of turn-based batch?
+		// If so, do nothing, as pending state manager will resubmit it correctly on reconnect.
+		if (length === 0 || !this.params.shouldSend()) {
+			return clientSequenceNumber;
+		}
+
+		if (this.params.containerContext.submitBatchFn === undefined) {
+			// Legacy path - supporting old loader versions. Can be removed only when LTS moves above
+			// version that has support for batches (submitBatchFn)
+			for (const message of batch.content) {
+				// Legacy path doesn't support compressed payloads and will submit uncompressed payload anyways
+				if (message.metadata?.compressed) {
+					delete message.metadata.compressed;
+				}
+
+				clientSequenceNumber = this.params.containerContext.submitFn(
+					MessageType.Operation,
+					message.deserializedContent,
+					true, // batch
+					message.metadata,
+				);
+			}
+
+			this.params.containerContext.deltaManager.flush();
+		} else {
+			// returns clientSequenceNumber of last message in a batch
+			clientSequenceNumber = this.params.containerContext.submitBatchFn(
+				batch.content.map((message) => ({
+					contents: message.contents,
+					metadata: message.metadata,
+					compression: message.compression,
+				})),
+			);
+		}
+
+		// Convert from clientSequenceNumber of last message in the batch to clientSequenceNumber of first message.
+		clientSequenceNumber -= length - 1;
+		assert(clientSequenceNumber >= 0, 0x3d0 /* clientSequenceNumber can't be negative */);
+		return clientSequenceNumber;
+	}
+
+	private persistBatch(initialClientSequenceNumber: number, batch: BatchMessage[]) {
+		let clientSequenceNumber = initialClientSequenceNumber;
+		// Let the PendingStateManager know that a message was submitted.
+		// In future, need to shift toward keeping batch as a whole!
+		for (const message of batch) {
+			this.params.pendingStateManager.onSubmitMessage(
+				message.deserializedContent.type,
+				clientSequenceNumber,
+				message.referenceSequenceNumber,
+				message.deserializedContent.contents,
+				message.localOpMetadata,
+				message.metadata,
+			);
+
+			clientSequenceNumber++;
+		}
+	}
+
+	public checkpoint() {
+		return {
+			mainBatch: this.mainBatch.checkpoint(),
+			attachFlowBatch: this.attachFlowBatch.checkpoint(),
+		};
+	}
 }

package/src/opLifecycle/remoteMessageProcessor.ts

@@ -9,45 +9,61 @@ import { OpDecompressor } from "./opDecompressor";
 import { OpSplitter } from "./opSplitter";
 
 export class RemoteMessageProcessor {
-    constructor(
-        private readonly opSplitter: OpSplitter,
-        private readonly opDecompressor: OpDecompressor,
-    ) { }
+	constructor(
+		private readonly opSplitter: OpSplitter,
+		private readonly opDecompressor: OpDecompressor,
+	) {}
 
-    public get partialMessages(): ReadonlyMap<string, string[]> {
-        return this.opSplitter.chunks;
-    }
+	public get partialMessages(): ReadonlyMap<string, string[]> {
+		return this.opSplitter.chunks;
+	}
 
-    public clearPartialMessagesFor(clientId: string) {
-        this.opSplitter.clearPartialChunks(clientId);
-    }
+	public clearPartialMessagesFor(clientId: string) {
+		this.opSplitter.clearPartialChunks(clientId);
+	}
 
-    public process(remoteMessage: ISequencedDocumentMessage): ISequencedDocumentMessage {
-        let message = copy(remoteMessage);
+	public process(remoteMessage: ISequencedDocumentMessage): ISequencedDocumentMessage {
+		let message = copy(remoteMessage);
+		message = this.opDecompressor.processMessage(message).message;
+		unpackRuntimeMessage(message);
 
-        message = this.opDecompressor.processMessage(message);
-        unpackRuntimeMessage(message);
-        message = this.opSplitter.processRemoteMessage(message);
+		const chunkProcessingResult = this.opSplitter.processRemoteMessage(message);
+		message = chunkProcessingResult.message;
+		if (chunkProcessingResult.state !== "Processed") {
+			// If the message is not chunked or if the splitter is still rebuilding the original message,
+			// there is no need to continue processing
+			return message;
+		}
 
-        return message;
-    }
+		const decompressionAfterChunking = this.opDecompressor.processMessage(message);
+		message = decompressionAfterChunking.message;
+		if (decompressionAfterChunking.state === "Skipped") {
+			// After chunking, if the original message was not compressed,
+			// there is no need to continue processing
+			return message;
+		}
+
+		// The message needs to be unpacked after chunking + decompression
+		unpack(message);
+		return message;
+	}
 }
 
 const copy = (remoteMessage: ISequencedDocumentMessage): ISequencedDocumentMessage => {
-    // Do shallow copy of message, as the processing flow will modify it.
-    // There might be multiple container instances receiving same message
-    // We do not need to make deep copy, as each layer will just replace message.content itself,
-    // but would not modify contents details
-    const message = { ...remoteMessage };
+	// Do shallow copy of message, as the processing flow will modify it.
+	// There might be multiple container instances receiving same message
+	// We do not need to make deep copy, as each layer will just replace message.content itself,
+	// but would not modify contents details
+	const message = { ...remoteMessage };
 
-    // 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).
-    if (typeof message.contents === "string" && message.contents !== "") {
-        message.contents = JSON.parse(message.contents);
-    }
+	// 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).
+	if (typeof message.contents === "string" && message.contents !== "") {
+		message.contents = JSON.parse(message.contents);
+	}
 
-    return message;
+	return message;
 };
 
 /**
@@ -55,9 +71,9 @@ const copy = (remoteMessage: ISequencedDocumentMessage): ISequencedDocumentMessa
  *
  */
 const unpack = (message: ISequencedDocumentMessage) => {
-    const innerContents = message.contents as ContainerRuntimeMessage;
-    message.type = innerContents.type;
-    message.contents = innerContents.contents;
+	const innerContents = message.contents as ContainerRuntimeMessage;
+	message.type = innerContents.type;
+	message.contents = innerContents.contents;
 };
 
 /**
@@ -70,21 +86,21 @@ const unpack = (message: ISequencedDocumentMessage) => {
  * @internal
  */
 export function unpackRuntimeMessage(message: ISequencedDocumentMessage): boolean {
-    if (message.type !== MessageType.Operation) {
-        // Legacy format, but it's already "unpacked",
-        // i.e. message.type is actually ContainerMessageType.
-        // Or it's non-runtime message.
-        // Nothing to do in such case.
-        return false;
-    }
+	if (message.type !== MessageType.Operation) {
+		// Legacy format, but it's already "unpacked",
+		// i.e. message.type is actually ContainerMessageType.
+		// Or it's non-runtime message.
+		// Nothing to do in such case.
+		return false;
+	}
 
-    // legacy op format?
-    if (message.contents.address !== undefined && message.contents.type === undefined) {
-        message.type = ContainerMessageType.FluidDataStoreOp;
-    } else {
-        // new format
-        unpack(message);
-    }
+	// legacy op format?
+	if (message.contents.address !== undefined && message.contents.type === undefined) {
+		message.type = ContainerMessageType.FluidDataStoreOp;
+	} else {
+		// new format
+		unpack(message);
+	}
 
-    return true;
+	return true;
 }

package/src/opProperties.ts

@@ -3,17 +3,19 @@
  * Licensed under the MIT License.
  */
 
-import { ISequencedDocumentMessage, ISequencedDocumentSystemMessage } from "@fluidframework/protocol-definitions";
+import {
+	ISequencedDocumentMessage,
+	ISequencedDocumentSystemMessage,
+} from "@fluidframework/protocol-definitions";
 
 export const opSize = (op: ISequencedDocumentMessage): number => {
-    // Some messages may already have string contents,
-    // so stringifying them again will add inaccurate overhead.
-    const content = typeof op.contents === "string" ?
-        op.contents :
-        JSON.stringify(op.contents) ?? "";
-    const data = opHasData(op) ? op.data : "";
-    return content.length + data.length;
+	// Some messages may already have string contents,
+	// so stringifying them again will add inaccurate overhead.
+	const content =
+		typeof op.contents === "string" ? op.contents : JSON.stringify(op.contents) ?? "";
+	const data = opHasData(op) ? op.data : "";
+	return content.length + data.length;
 };
 
 const opHasData = (op: ISequencedDocumentMessage): op is ISequencedDocumentSystemMessage =>
-    (op as ISequencedDocumentSystemMessage).data !== undefined;
+	(op as ISequencedDocumentSystemMessage).data !== undefined;