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

package/src/opLifecycle/outbox.ts

@@ -6,11 +6,16 @@
 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 { GenericError, UsageError } from "@fluidframework/container-utils";
 import { MessageType } from "@fluidframework/protocol-definitions";
+import {
+	ChildLogger,
+	loggerToMonitoringContext,
+	MonitoringContext,
+} from "@fluidframework/telemetry-utils";
 import { ICompressionRuntimeOptions } from "../containerRuntime";
 import { PendingStateManager } from "../pendingStateManager";
-import { BatchManager } from "./batchManager";
+import { BatchManager, estimateSocketSize } from "./batchManager";
 import { BatchMessage, IBatch } from "./definitions";
 import { OpCompressor } from "./opCompressor";
 import { OpSplitter } from "./opSplitter";
@@ -19,7 +24,7 @@ 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;
+	readonly disablePartialFlush: boolean;
 }
 
 export interface IOutboxParameters {
@@ -33,11 +38,22 @@ export interface IOutboxParameters {
 }
 
 export class Outbox {
+	private readonly mc: MonitoringContext;
 	private readonly attachFlowBatch: BatchManager;
 	private readonly mainBatch: BatchManager;
-	private readonly defaultAttachFlowSoftLimitInBytes = 64 * 1024;
+	private readonly defaultAttachFlowSoftLimitInBytes = 320 * 1024;
+
+	/**
+	 * Track the number of ops which were detected to have a mismatched
+	 * reference sequence number, in order to self-throttle the telemetry events.
+	 *
+	 * This should be removed as part of ADO:2322
+	 */
+	private readonly maxMismatchedOpsToReport = 3;
+	private mismatchedOpsReported = 0;
 
 	constructor(private readonly params: IOutboxParameters) {
+		this.mc = loggerToMonitoringContext(ChildLogger.create(params.logger, "Outbox"));
 		const isCompressionEnabled =
 			this.params.config.compressionOptions.minimumBatchSizeInBytes !==
 			Number.POSITIVE_INFINITY;
@@ -45,28 +61,63 @@ export class Outbox {
 		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,
-		);
+		this.attachFlowBatch = new BatchManager({ hardLimit, softLimit });
+		this.mainBatch = new BatchManager({ hardLimit });
 	}
 
 	public get isEmpty(): boolean {
 		return this.attachFlowBatch.length === 0 && this.mainBatch.length === 0;
 	}
 
+	/**
+	 * If we detect that the reference sequence number of the incoming message does not match
+	 * what was already in the batch managers, this means that batching has been interrupted so
+	 * we will flush the accumulated messages to account for that and create a new batch with the new
+	 * message as the first message.
+	 *
+	 * @param message - the incoming message
+	 */
+	private maybeFlushPartialBatch(message: BatchMessage) {
+		const mainBatchReference = this.mainBatch.referenceSequenceNumber;
+		const attachFlowBatchReference = this.attachFlowBatch.referenceSequenceNumber;
+		assert(
+			this.params.config.disablePartialFlush ||
+				mainBatchReference === undefined ||
+				attachFlowBatchReference === undefined ||
+				mainBatchReference === attachFlowBatchReference,
+			0x58d /* Reference sequence numbers from both batches must be in sync */,
+		);
+
+		if (
+			(mainBatchReference === undefined ||
+				mainBatchReference === message.referenceSequenceNumber) &&
+			(attachFlowBatchReference === undefined ||
+				attachFlowBatchReference === message.referenceSequenceNumber)
+		) {
+			// The reference sequence numbers are stable, there is nothing to do
+			return;
+		}
+
+		if (++this.mismatchedOpsReported <= this.maxMismatchedOpsToReport) {
+			this.mc.logger.sendErrorEvent(
+				{
+					eventName: "ReferenceSequenceNumberMismatch",
+					mainReferenceSequenceNumber: mainBatchReference,
+					attachReferenceSequenceNumber: attachFlowBatchReference,
+					messageReferenceSequenceNumber: message.referenceSequenceNumber,
+				},
+				new UsageError("Submission of an out of order message"),
+			);
+		}
+
+		if (!this.params.config.disablePartialFlush) {
+			this.flush();
+		}
+	}
+
 	public submit(message: BatchMessage) {
+		this.maybeFlushPartialBatch(message);
+
 		if (!this.mainBatch.push(message)) {
 			throw new GenericError("BatchTooLarge", /* error */ undefined, {
 				opSize: message.contents?.length ?? 0,
@@ -78,6 +129,8 @@ export class Outbox {
 	}
 
 	public submitAttach(message: BatchMessage) {
+		this.maybeFlushPartialBatch(message);
+
 		if (!this.attachFlowBatch.push(message)) {
 			// BatchManager has two limits - soft limit & hard limit. Soft limit is only engaged
 			// when queue is not empty.
@@ -113,69 +166,80 @@ export class Outbox {
 
 	private flushInternal(rawBatch: IBatch) {
 		const processedBatch = this.compressBatch(rawBatch);
-		const clientSequenceNumber = this.sendBatch(processedBatch);
+		this.sendBatch(processedBatch);
 
-		this.persistBatch(clientSequenceNumber, rawBatch.content);
+		this.persistBatch(rawBatch.content);
 	}
 
 	private compressBatch(batch: IBatch): IBatch {
 		if (
 			batch.content.length === 0 ||
 			this.params.config.compressionOptions === undefined ||
-			this.params.config.compressionOptions.minimumBatchSizeInBytes > batch.contentSizeInBytes
+			this.params.config.compressionOptions.minimumBatchSizeInBytes >
+				batch.contentSizeInBytes ||
+			this.params.containerContext.submitBatchFn === undefined
 		) {
-			// Nothing to do if the batch is empty or if compression is disabled or if we don't need to compress
+			// Nothing to do if the batch is empty or if compression is disabled or not supported, 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);
+			return compressedBatch.contentSizeInBytes <= this.params.splitter.chunkSizeInBytes
+				? compressedBatch
+				: this.params.splitter.splitCompressedBatch(compressedBatch);
+		}
+
+		if (compressedBatch.contentSizeInBytes >= this.params.config.maxBatchSizeInBytes) {
+			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),
+				socketSize: estimateSocketSize(batch),
+			});
 		}
 
-		// 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),
-		});
+		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;
+	private sendBatch(batch: IBatch) {
 		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;
+			return;
+		}
+
+		const socketSize = estimateSocketSize(batch);
+		if (socketSize >= this.params.config.maxBatchSizeInBytes) {
+			this.mc.logger.sendPerformanceEvent({
+				eventName: "LargeBatch",
+				length: batch.content.length,
+				sizeInBytes: batch.contentSizeInBytes,
+				socketSize,
+			});
 		}
 
 		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;
-				}
+			assert(
+				batch.content[0].compression === undefined,
+				0x5a6 /* Compression should not have happened if the loader does not support it */,
+			);
 
-				clientSequenceNumber = this.params.containerContext.submitFn(
+			for (const message of batch.content) {
+				this.params.containerContext.submitFn(
 					MessageType.Operation,
 					message.deserializedContent,
 					true, // batch
@@ -185,37 +249,33 @@ export class Outbox {
 
 			this.params.containerContext.deltaManager.flush();
 		} else {
-			// returns clientSequenceNumber of last message in a batch
-			clientSequenceNumber = this.params.containerContext.submitBatchFn(
+			assert(
+				batch.referenceSequenceNumber !== undefined,
+				0x58e /* Batch must not be empty */,
+			);
+			this.params.containerContext.submitBatchFn(
 				batch.content.map((message) => ({
 					contents: message.contents,
 					metadata: message.metadata,
 					compression: message.compression,
+					referenceSequenceNumber: message.referenceSequenceNumber,
 				})),
+				batch.referenceSequenceNumber,
 			);
 		}
-
-		// 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;
+	private persistBatch(batch: BatchMessage[]) {
 		// 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++;
 		}
 	}
 

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.0.0-dev.3.1.0.125672";
+export const pkgVersion = "2.0.0-dev.4.1.0.148229";

package/src/pendingStateManager.ts

@@ -29,12 +29,13 @@ 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)
+ * ! TODO: Remove in "2.0.0-internal.5.0.0" AB#2496
  */
 export interface IPendingFlush {
 	type: "flush";
 }
 
+/** ! TODO: Remove in "2.0.0-internal.5.0.0" AB#2496 */
 export type IPendingState = IPendingMessage | IPendingFlush;
 
 export interface IPendingLocalState {
@@ -107,17 +108,11 @@ export class PendingStateManager implements IDisposable {
 		);
 		if (!this.pendingMessages.isEmpty()) {
 			return {
-				pendingStates: this.pendingMessages.toArray().reduce((arr, message) => {
-					// delete localOpMetadata since it may not be serializable
-					// and will be regenerated by applyStashedOp()
-					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>()),
+				// delete localOpMetadata since it may not be serializable
+				// and will be regenerated by applyStashedOp()
+				pendingStates: this.pendingMessages
+					.toArray()
+					.map((message) => ({ ...message, localOpMetadata: undefined })),
 			};
 		}
 	}
@@ -130,7 +125,7 @@ export class PendingStateManager implements IDisposable {
 		 * 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
+		 * ! TODO: Remove this conversion in "2.0.0-internal.5.0.0" as version from "2.0.0-internal.4.0.0" will be new format
 		 * AB#2496 tracks removal
 		 */
 		if (initialLocalState?.pendingStates) {
@@ -168,13 +163,11 @@ export class PendingStateManager implements IDisposable {
 	 * Called when a message is submitted locally. Adds the message and the associated details to the pending state
 	 * queue.
 	 * @param type - The container message type.
-	 * @param clientSequenceNumber - The clientSequenceNumber associated with the message.
 	 * @param content - The message content.
 	 * @param localOpMetadata - The local metadata associated with the message.
 	 */
 	public onSubmitMessage(
 		type: ContainerMessageType,
-		clientSequenceNumber: number,
 		referenceSequenceNumber: number,
 		content: any,
 		localOpMetadata: unknown,
@@ -183,7 +176,7 @@ export class PendingStateManager implements IDisposable {
 		const pendingMessage: IPendingMessage = {
 			type: "message",
 			messageType: type,
-			clientSequenceNumber,
+			clientSequenceNumber: -1, // dummy value (not to be used anywhere)
 			referenceSequenceNumber,
 			content,
 			localOpMetadata,
@@ -241,18 +234,34 @@ export class PendingStateManager implements IDisposable {
 		);
 		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 (pendingMessage.clientSequenceNumber !== message.clientSequenceNumber) {
+		if (pendingMessage.messageType !== message.type) {
 			// Close the container because this could indicate data corruption.
-			const error = DataProcessingError.create(
-				"pending local message clientSequenceNumber mismatch",
-				"unexpectedAckReceived",
-				message,
-				{ expectedClientSequenceNumber: pendingMessage.clientSequenceNumber },
+			this.stateHandler.close(
+				DataProcessingError.create(
+					"pending local message type mismatch",
+					"unexpectedAckReceived",
+					message,
+					{
+						expectedMessageType: pendingMessage.messageType,
+					},
+				),
 			);
+			return;
+		}
 
-			this.stateHandler.close(error);
+		const pendingMessageContent = JSON.stringify(pendingMessage.content);
+		const messageContent = JSON.stringify(message.contents);
+
+		// Stringified content does not match
+		if (pendingMessageContent !== messageContent) {
+			// Close the container because this could indicate data corruption.
+			this.stateHandler.close(
+				DataProcessingError.create(
+					"pending local message content mismatch",
+					"unexpectedAckReceived",
+					message,
+				),
+			);
 			return;
 		}
 
@@ -322,8 +331,6 @@ export class PendingStateManager implements IDisposable {
 								hasBatchStart: batchBeginMetadata === true,
 								hasBatchEnd: batchEndMetadata === false,
 								messageType: message.type,
-								batchStartSequenceNumber:
-									this.pendingBatchBeginMessage.clientSequenceNumber,
 								pendingMessagesCount: this.pendingMessagesCount,
 							},
 						),

package/src/storageServiceWithAttachBlobs.ts

@@ -0,0 +1,38 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+	IDocumentStorageService,
+	IDocumentStorageServicePolicies,
+} from "@fluidframework/driver-definitions";
+import { DocumentStorageServiceProxy } from "@fluidframework/driver-utils";
+
+/**
+ * IDocumentStorageService proxy which intercepts requests if they can be satisfied by the blobs received in the
+ * attach message. We use this to avoid an unnecessary request to the storage service.
+ */
+export class StorageServiceWithAttachBlobs extends DocumentStorageServiceProxy {
+	constructor(
+		internalStorageService: IDocumentStorageService,
+		private readonly attachBlobs: Map<string, ArrayBufferLike>,
+	) {
+		super(internalStorageService);
+	}
+
+	public get policies(): IDocumentStorageServicePolicies | undefined {
+		return this.internalStorageService.policies;
+	}
+
+	public async readBlob(id: string): Promise<ArrayBufferLike> {
+		const blob = this.attachBlobs.get(id);
+		if (blob !== undefined) {
+			return blob;
+		}
+
+		// Note that it is intentional not to cache the result of this readBlob - we'll trust the real
+		// IDocumentStorageService to cache appropriately, no need to double-cache.
+		return this.internalStorageService.readBlob(id);
+	}
+}

package/src/summary/index.ts

@@ -0,0 +1,105 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export {
+	IOrderedClientCollection,
+	IOrderedClientElection,
+	ISerializedElection,
+	ITrackedClient,
+	OrderedClientCollection,
+	OrderedClientElection,
+} from "./orderedClientElection";
+export { RunningSummarizer } from "./runningSummarizer";
+export {
+	ICancellableSummarizerController,
+	neverCancelledSummaryToken,
+	RunWhileConnectedCoordinator,
+} from "./runWhileConnectedCoordinator";
+export { Summarizer } from "./summarizer";
+export {
+	ISummarizerClientElection,
+	ISummarizerClientElectionEvents,
+	SummarizerClientElection,
+	summarizerClientType,
+} from "./summarizerClientElection";
+export { SummarizeHeuristicData, SummarizeHeuristicRunner } from "./summarizerHeuristics";
+export {
+	createRootSummarizerNode,
+	createRootSummarizerNodeWithGC,
+	IFetchSnapshotResult,
+	IRootSummarizerNode,
+	IRootSummarizerNodeWithGC,
+	RefreshSummaryResult,
+} from "./summarizerNode";
+export {
+	IConnectableRuntime,
+	IGeneratedSummaryStats,
+	IRefreshSummaryAckOptions,
+	ISubmitSummaryOptions,
+	ISummarizeAttempt,
+	ISummarizeHeuristicData,
+	ISummarizer,
+	ISummarizeResults,
+	ISummarizerEvents,
+	ISummarizerInternalsProvider,
+	ISummarizerRuntime,
+	ISummaryCancellationToken,
+	SubmitSummaryResult,
+	SummarizerStopReason,
+	EnqueueSummarizeResult,
+	IAckSummaryResult,
+	IBaseSummarizeResult,
+	IBroadcastSummaryResult,
+	ICancellationToken,
+	IEnqueueSummarizeOptions,
+	IGenerateSummaryTreeResult,
+	INackSummaryResult,
+	IOnDemandSummarizeOptions,
+	ISubmitSummaryOpResult,
+	ISummarizeOptions,
+	ISummarizingWarning,
+	IUploadSummaryResult,
+	SummarizeResultPart,
+} from "./summarizerTypes";
+export {
+	IAckedSummary,
+	ISummaryCollectionOpEvents,
+	ISummaryOpMessage,
+	SummaryCollection,
+	IClientSummaryWatcher,
+	ISummary,
+	ISummaryAckMessage,
+	ISummaryNackMessage,
+	OpActionEventListener,
+	OpActionEventName,
+} from "./summaryCollection";
+export {
+	aliasBlobName,
+	blobsTreeName,
+	chunksBlobName,
+	dataStoreAttributesBlobName,
+	electedSummarizerBlobName,
+	extractSummaryMetadataMessage,
+	getAttributesFormatVersion,
+	getFluidDataStoreAttributes,
+	hasIsolatedChannels,
+	IContainerRuntimeMetadata,
+	ICreateContainerMetadata,
+	ISummaryMetadataMessage,
+	metadataBlobName,
+	nonDataStorePaths,
+	ReadFluidDataStoreAttributes,
+	rootHasIsolatedChannels,
+	WriteFluidDataStoreAttributes,
+	wrapSummaryInChannelsTree,
+} from "./summaryFormat";
+export { SummarizeReason } from "./summaryGenerator";
+export {
+	IConnectedEvents,
+	IConnectedState,
+	ISummaryManagerConfig,
+	SummaryManager,
+	SummaryManagerState,
+} from "./summaryManager";

package/src/{runWhileConnectedCoordinator.ts → summary/runWhileConnectedCoordinator.ts}

@@ -35,10 +35,7 @@ export class RunWhileConnectedCoordinator implements ICancellableSummarizerContr
 
 	public get cancelled() {
 		if (!this._cancelled) {
-			assert(
-				this.runtime.deltaManager.active,
-				0x25d /* "We should never connect as 'read'" */,
-			);
+			assert(this.active(), 0x25d /* "We should never connect as 'read'" */);
 
 			// This check can't be enabled in current design due to lastSummary flow, where
 			// summarizer for closed container stays around and can produce one more summary.
@@ -63,13 +60,16 @@ export class RunWhileConnectedCoordinator implements ICancellableSummarizerContr
 		return this.stopDeferred.promise;
 	}
 
-	public static async create(runtime: IConnectableRuntime) {
-		const obj = new RunWhileConnectedCoordinator(runtime);
+	public static async create(runtime: IConnectableRuntime, active: () => boolean) {
+		const obj = new RunWhileConnectedCoordinator(runtime, active);
 		await obj.waitStart();
 		return obj;
 	}
 
-	protected constructor(private readonly runtime: IConnectableRuntime) {}
+	protected constructor(
+		private readonly runtime: IConnectableRuntime,
+		private readonly active: () => boolean,
+	) {}
 
 	/**
 	 * Starts and waits for a promise which resolves when connected.