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

package/src/opLifecycle/outbox.ts

@@ -0,0 +1,228 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * 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";
+import { MessageType } from "@fluidframework/protocol-definitions";
+import { ICompressionRuntimeOptions } from "../containerRuntime";
+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 enableOpReentryCheck?: boolean;
+}
+
+export interface IOutboxParameters {
+	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,
+				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

@@ -0,0 +1,106 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
+import { ContainerMessageType, ContainerRuntimeMessage } from "../containerRuntime";
+import { OpDecompressor } from "./opDecompressor";
+import { OpSplitter } from "./opSplitter";
+
+export class RemoteMessageProcessor {
+	constructor(
+		private readonly opSplitter: OpSplitter,
+		private readonly opDecompressor: OpDecompressor,
+	) {}
+
+	public get partialMessages(): ReadonlyMap<string, string[]> {
+		return this.opSplitter.chunks;
+	}
+
+	public clearPartialMessagesFor(clientId: string) {
+		this.opSplitter.clearPartialChunks(clientId);
+	}
+
+	public process(remoteMessage: ISequencedDocumentMessage): ISequencedDocumentMessage {
+		let message = copy(remoteMessage);
+		message = this.opDecompressor.processMessage(message).message;
+		unpackRuntimeMessage(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;
+		}
+
+		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 };
+
+	// 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;
+};
+
+/**
+ * For a given message, it moves the nested contents and type on level up.
+ *
+ */
+const unpack = (message: ISequencedDocumentMessage) => {
+	const innerContents = message.contents as ContainerRuntimeMessage;
+	message.type = innerContents.type;
+	message.contents = innerContents.contents;
+};
+
+/**
+ * Unpacks runtime messages.
+ *
+ * @remarks This API makes no promises regarding backward-compatibility. This is internal API.
+ * @param message - message (as it observed in storage / service)
+ * @returns unpacked runtime message
+ *
+ * @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;
+	}
+
+	// legacy op format?
+	if (message.contents.address !== undefined && message.contents.type === undefined) {
+		message.type = ContainerMessageType.FluidDataStoreOp;
+	} else {
+		// new format
+		unpack(message);
+	}
+
+	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;