@fluidframework/container-runtime 2.0.0-dev.6.4.0.192049 → 2.0.0-dev.7.2.0.204906

package/src/opLifecycle/remoteMessageProcessor.ts

@@ -6,13 +6,21 @@
 import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
 import {
 	ContainerMessageType,
-	ContainerRuntimeMessage,
-	SequencedContainerRuntimeMessage,
-} from "../containerRuntime";
+	type InboundContainerRuntimeMessage,
+	type InboundSequencedContainerRuntimeMessage,
+	type InboundSequencedContainerRuntimeMessageOrSystemMessage,
+	type InboundSequencedRecentlyAddedContainerRuntimeMessage,
+} from "../messageTypes";
 import { OpDecompressor } from "./opDecompressor";
 import { OpGroupingManager } from "./opGroupingManager";
 import { OpSplitter } from "./opSplitter";
 
+/**
+ * Stateful class for processing incoming remote messages as the virtualization measures are unwrapped,
+ * potentially across numerous inbound ops.
+ *
+ * @internal
+ */
 export class RemoteMessageProcessor {
 	constructor(
 		private readonly opSplitter: OpSplitter,
@@ -30,14 +38,25 @@ export class RemoteMessageProcessor {
 
 	/**
 	 * Ungroups and Unchunks the runtime ops encapsulated by the single remoteMessage received over the wire
-	 * @param remoteMessage - A message from another client, likely a chunked/grouped op
-	 * @returns the ungrouped, unchunked, unpacked SequencedContainerRuntimeMessage encapsulated in the remote message
+	 * @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
+	 * depends on this object instance.
+	 * Note remoteMessageCopy.contents (and other object props) MUST not be modified,
+	 * but may be overwritten (as is the case with contents).
+	 * @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(remoteMessage: ISequencedDocumentMessage): ISequencedDocumentMessage[] {
-		const result: ISequencedDocumentMessage[] = [];
+	public process(
+		remoteMessageCopy: ISequencedDocumentMessage,
+	): InboundSequencedContainerRuntimeMessageOrSystemMessage[] {
+		const result: InboundSequencedContainerRuntimeMessageOrSystemMessage[] = [];
+
+		ensureContentsDeserialized(remoteMessageCopy);
 
 		// Ungroup before and after decompression for back-compat (cleanup tracked by AB#4371)
-		for (const ungroupedMessage of this.opGroupingManager.ungroupOp(copy(remoteMessage))) {
+		for (const ungroupedMessage of this.opGroupingManager.ungroupOp(remoteMessageCopy)) {
 			const message = this.opDecompressor.processMessage(ungroupedMessage).message;
 
 			for (let ungroupedMessage2 of this.opGroupingManager.ungroupOp(message)) {
@@ -50,7 +69,9 @@ export class RemoteMessageProcessor {
 				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
-					result.push(ungroupedMessage2);
+					result.push(
+						ungroupedMessage2 as InboundSequencedContainerRuntimeMessageOrSystemMessage,
+					);
 					continue;
 				}
 
@@ -68,7 +89,9 @@ export class RemoteMessageProcessor {
 						if (decompressionAfterChunking.state === "Skipped") {
 							// After chunking, if the original message was not compressed,
 							// there is no need to continue processing
-							result.push(ungroupedMessageAfterChunking2);
+							result.push(
+								ungroupedMessageAfterChunking2 as InboundSequencedContainerRuntimeMessageOrSystemMessage,
+							);
 							continue;
 						}
 
@@ -84,40 +107,38 @@ export class RemoteMessageProcessor {
 	}
 }
 
-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 };
-
+/** Takes an incoming message and if the contents is a string, JSON.parse's it in place */
+function ensureContentsDeserialized(mutableMessage: ISequencedDocumentMessage): 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).
-	if (typeof message.contents === "string" && message.contents !== "") {
-		message.contents = JSON.parse(message.contents);
+	if (typeof mutableMessage.contents === "string" && mutableMessage.contents !== "") {
+		mutableMessage.contents = JSON.parse(mutableMessage.contents);
 	}
-
-	return message;
-};
+}
 
 /**
- * For a given message, it moves the nested ContainerRuntimeMessage props one level up.
+ * For a given message, it moves the nested InboundContainerRuntimeMessage props one level up.
  *
  * The return type illustrates the assumption that the message param
- * becomes a ContainerRuntimeMessage by the time the function returns
- * (but there is no runtime validation of the 'type' or 'compatDetails' values)
+ * becomes a InboundSequencedContainerRuntimeMessage by the time the function returns
+ * (but there is no runtime validation of the 'type' or 'compatDetails' values).
  */
 function unpack(
 	message: ISequencedDocumentMessage,
-): asserts message is SequencedContainerRuntimeMessage {
-	const innerContents = message.contents as ContainerRuntimeMessage;
-
-	// We're going to turn message into a SequencedContainerRuntimeMessage in-place
-	const sequencedContainerRuntimeMessage = message as SequencedContainerRuntimeMessage;
-	sequencedContainerRuntimeMessage.type = innerContents.type;
-	sequencedContainerRuntimeMessage.contents = innerContents.contents;
-	sequencedContainerRuntimeMessage.compatDetails = innerContents.compatDetails;
+): asserts message is InboundSequencedContainerRuntimeMessage {
+	// We assume the contents is an InboundContainerRuntimeMessage (the message is "packed")
+	const contents = message.contents as InboundContainerRuntimeMessage;
+
+	// We're going to unpack message in-place (promoting those properties of contents up to message itself)
+	const messageUnpacked = message as InboundSequencedContainerRuntimeMessage;
+
+	messageUnpacked.type = contents.type;
+	messageUnpacked.contents = contents.contents;
+	if ("compatDetails" in contents) {
+		(messageUnpacked as InboundSequencedRecentlyAddedContainerRuntimeMessage).compatDetails =
+			contents.compatDetails;
+	}
 }
 
 /**

package/src/packageVersion.ts

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

package/src/pendingStateManager.ts

@@ -11,28 +11,15 @@ import { ICriticalContainerError } from "@fluidframework/container-definitions";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { DataProcessingError, ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 
-import { ContainerMessageType, SequencedContainerRuntimeMessage } from "./containerRuntime";
+import { ContainerMessageType, InboundSequencedContainerRuntimeMessage } from "./messageTypes";
 import { pkgVersion } from "./packageVersion";
 import { IBatchMetadata } from "./metadata";
 
-/**
- * ! TODO: Remove this interface in "2.0.0-internal.7.0.0" once we only read IPendingMessageNew (AB#4763)
- */
-export interface IPendingMessageOld {
-	type: "message";
-	messageType: ContainerMessageType;
-	clientSequenceNumber: number;
-	referenceSequenceNumber: number;
-	content: any;
-	localOpMetadata: unknown;
-	opMetadata: Record<string, unknown> | undefined;
-}
-
 /**
  * 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.
  */
-export interface IPendingMessageNew {
+export interface IPendingMessage {
 	type: "message";
 	clientSequenceNumber: number;
 	referenceSequenceNumber: number;
@@ -41,16 +28,11 @@ export interface IPendingMessageNew {
 	opMetadata: Record<string, unknown> | undefined;
 }
 
-/**
- * ! TODO: Remove this type in "2.0.0-internal.7.0.0" (AB#4763)
- */
-export type IPendingState = IPendingMessageOld | IPendingMessageNew;
-
 export interface IPendingLocalState {
 	/**
 	 * list of pending states, including ops and batch information
 	 */
-	pendingStates: IPendingState[];
+	pendingStates: IPendingMessage[];
 }
 
 export interface IPendingBatchMessage {
@@ -69,6 +51,26 @@ export interface IRuntimeStateHandler {
 	isActiveConnection: () => boolean;
 }
 
+/** Union of keys of T */
+type KeysOfUnion<T extends object> = T extends T ? keyof T : never;
+/** *Partial* type all possible combinations of properties and values of union T.
+ * This loosens typing allowing access to all possible properties without
+ * narrowing.
+ */
+type AnyComboFromUnion<T extends object> = { [P in KeysOfUnion<T>]?: T[P] };
+
+function buildPendingMessageContent(
+	// AnyComboFromUnion is needed need to gain access to compatDetails that
+	// is only defined for some cases.
+	message: AnyComboFromUnion<InboundSequencedContainerRuntimeMessage>,
+): string {
+	// 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 });
+}
+
 /**
  * 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
@@ -79,13 +81,13 @@ export interface IRuntimeStateHandler {
  * It verifies that all the ops are acked, are received in the right order and batch information is correct.
  */
 export class PendingStateManager implements IDisposable {
-	private readonly pendingMessages = new Deque<IPendingMessageNew>();
-	private readonly initialMessages = new Deque<IPendingMessageNew>();
+	private readonly pendingMessages = new Deque<IPendingMessage>();
+	private readonly initialMessages = new Deque<IPendingMessage>();
 
 	/**
 	 * Sequenced local ops that are saved when stashing since pending ops may depend on them
 	 */
-	private savedOps: IPendingMessageNew[] = [];
+	private savedOps: IPendingMessage[] = [];
 
 	private readonly disposeOnce = new Lazy<void>(() => {
 		this.initialMessages.clear();
@@ -149,29 +151,8 @@ export class PendingStateManager implements IDisposable {
 		initialLocalState: IPendingLocalState | undefined,
 		private readonly logger: ITelemetryLoggerExt | undefined,
 	) {
-		/**
-		 * Convert old local state format to the new format (IPendingMessageOld to IPendingMessageNew)
-		 * ! TODO: Remove this conversion in "2.0.0-internal.7.0.0" (AB#4763)
-		 */
 		if (initialLocalState?.pendingStates) {
-			for (const initialState of initialLocalState.pendingStates) {
-				let messageContent = initialState.content;
-				if (
-					(initialState as IPendingMessageOld).messageType !== undefined &&
-					typeof initialState.content !== "string"
-				) {
-					// Convert IPendingMessageOld to IPendingMessageNew
-					messageContent = JSON.stringify({
-						type: (initialState as IPendingMessageOld).messageType,
-						contents: initialState.content,
-					});
-				}
-				// Note: this object may contain "messageType" prop, but it should not be easily accesible due to interface being used
-				this.initialMessages.push({
-					...initialState,
-					content: messageContent,
-				});
-			}
+			this.initialMessages.push(...initialLocalState.pendingStates);
 		}
 	}
 
@@ -193,7 +174,7 @@ export class PendingStateManager implements IDisposable {
 		localOpMetadata: unknown,
 		opMetadata: Record<string, unknown> | undefined,
 	) {
-		const pendingMessage: IPendingMessageNew = {
+		const pendingMessage: IPendingMessage = {
 			type: "message",
 			clientSequenceNumber: -1, // dummy value (not to be used anywhere)
 			referenceSequenceNumber,
@@ -242,7 +223,7 @@ export class PendingStateManager implements IDisposable {
 	 * the batch information was preserved for batch messages.
 	 * @param message - The message that got ack'd and needs to be processed.
 	 */
-	public processPendingLocalMessage(message: SequencedContainerRuntimeMessage): unknown {
+	public processPendingLocalMessage(message: InboundSequencedContainerRuntimeMessage): unknown {
 		// Pre-processing part - This may be the start of a batch.
 		this.maybeProcessBatchBegin(message);
 
@@ -256,10 +237,7 @@ export class PendingStateManager implements IDisposable {
 
 		this.pendingMessages.shift();
 
-		// IMPORTANT: Order matters here, this must match the order of the properties used
-		// when submitting the message.
-		const { type, contents, compatDetails } = message;
-		const messageContent = JSON.stringify({ type, contents, compatDetails });
+		const messageContent = buildPendingMessageContent(message);
 
 		// Stringified content should match
 		if (pendingMessage.content !== messageContent) {
@@ -340,6 +318,7 @@ export class PendingStateManager implements IDisposable {
 							{
 								runtimeVersion: pkgVersion,
 								batchClientId:
+									// eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
 									this.pendingBatchBeginMessage.clientId === null
 										? "null"
 										: this.pendingBatchBeginMessage.clientId,

package/src/scheduleManager.ts

@@ -271,6 +271,7 @@ class ScheduleManagerCore {
 					{
 						runtimeVersion: pkgVersion,
 						batchClientId:
+							// eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
 							this.currentBatchClientId === null ? "null" : this.currentBatchClientId,
 						pauseSequenceNumber: this.pauseSequenceNumber,
 						localBatch: this.currentBatchClientId === this.getClientId(),
@@ -306,6 +307,7 @@ class ScheduleManagerCore {
 			throw new DataCorruptionError("OpBatchIncomplete", {
 				runtimeVersion: pkgVersion,
 				batchClientId:
+					// eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
 					this.currentBatchClientId === null ? "null" : this.currentBatchClientId,
 				pauseSequenceNumber: this.pauseSequenceNumber,
 				localBatch: this.currentBatchClientId === this.getClientId(),

package/src/summary/orderedClientElection.ts

@@ -225,7 +225,10 @@ export interface IOrderedClientElectionEvents extends IEvent {
 	);
 }
 
-/** Serialized state of IOrderedClientElection. */
+/**
+ * Serialized state of IOrderedClientElection.
+ * @public
+ */
 export interface ISerializedElection {
 	/** Sequence number at the time of the latest election. */
 	readonly electionSequenceNumber: number;

package/src/summary/runWhileConnectedCoordinator.ts

@@ -10,7 +10,10 @@ import {
 	ISummaryCancellationToken,
 } from "./summarizerTypes";
 
-/* Similar to AbortController, but using promise instead of events */
+/**
+ * Similar to AbortController, but using promise instead of events
+ * @public
+ */
 export interface ICancellableSummarizerController extends ISummaryCancellationToken {
 	stop(reason: SummarizerStopReason): void;
 }
@@ -18,6 +21,7 @@ export interface ICancellableSummarizerController extends ISummaryCancellationTo
 /**
  * Can be useful in testing as well as in places where caller does not use cancellation.
  * This object implements ISummaryCancellationToken interface but cancellation is never leveraged.
+ * @public
  */
 export const neverCancelledSummaryToken: ISummaryCancellationToken = {
 	cancelled: false,

package/src/summary/runningSummarizer.ts

@@ -308,7 +308,8 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 						// latest version with which we will refresh the state. However in case of single commit
 						// summary, we might me missing a summary ack, so in that case we are still fine as the
 						// code in `submitSummary` function in container runtime, will refresh the latest state
-						// by calling `refreshLatestSummaryAckFromServer` and we will be fine.
+						// by calling `prefetchLatestSummaryThenClose`. We will load the next summarizer from the
+						// updated state and be fine.
 						const isIgnoredError =
 							isFluidError(error) &&
 							error.errorType === DriverErrorTypes.fileNotFoundOrAccessDeniedError;
@@ -407,6 +408,7 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 			!this.heuristicRunnerMicroTaskExists
 		) {
 			this.heuristicRunnerMicroTaskExists = true;
+			// eslint-disable-next-line @typescript-eslint/no-floating-promises
 			Promise.resolve()
 				.then(() => {
 					this.heuristicRunner?.run();

package/src/summary/summarizer.ts

@@ -15,8 +15,8 @@ import {
 } from "@fluidframework/telemetry-utils";
 import { ILoader, LoaderHeader } from "@fluidframework/container-definitions";
 import { DriverHeader } from "@fluidframework/driver-definitions";
-import { requestFluidObject } from "@fluidframework/runtime-utils";
 import { FluidObject, IFluidHandleContext, IRequest } from "@fluidframework/core-interfaces";
+import { responseToException } from "@fluidframework/runtime-utils";
 import { ISummaryConfiguration } from "../containerRuntime";
 import { ICancellableSummarizerController } from "./runWhileConnectedCoordinator";
 import { summarizerClientType } from "./summarizerClientElection";
@@ -49,7 +49,10 @@ export class SummarizingWarning
 	readonly errorType = summarizingError;
 	readonly canRetry = true;
 
-	constructor(errorMessage: string, readonly logged: boolean = false) {
+	constructor(
+		errorMessage: string,
+		readonly logged: boolean = false,
+	) {
 		super(errorMessage);
 	}
 
@@ -66,6 +69,7 @@ export const createSummarizingWarning = (errorMessage: string, logged: boolean)
  * Summarizer is responsible for coordinating when to generate and send summaries.
  * It is the main entry point for summary work.
  * It is created only by summarizing container (i.e. one with clientType === "summarizer")
+ * @public
  */
 export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements ISummarizer {
 	public get ISummarizer() {
@@ -107,6 +111,7 @@ export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements
 	 * interface will expect an absolute URL and will not handle "/".
 	 * @param loader - the loader that resolves the request
 	 * @param url - the URL used to resolve the container
+	 * @deprecated Creating a summarizer is not a publicly supported API. Please remove all usage of this static method.
 	 */
 	public static async create(loader: ILoader, url: string): Promise<ISummarizer> {
 		const request: IRequest = {
@@ -123,11 +128,20 @@ export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements
 		};
 
 		const resolvedContainer = await loader.resolve(request);
-		const fluidObject: FluidObject<ISummarizer> | undefined = resolvedContainer.getEntryPoint
-			? await resolvedContainer.getEntryPoint?.()
-			: await requestFluidObject<FluidObject<ISummarizer>>(resolvedContainer, {
-					url: "_summarizer",
-			  });
+		let fluidObject: FluidObject<ISummarizer> | undefined;
+
+		// Older containers may not have the "getEntryPoint" API
+		// ! This check will need to stay until LTS of loader moves past 2.0.0-internal.7.0.0
+		if (resolvedContainer.getEntryPoint !== undefined) {
+			fluidObject = await resolvedContainer.getEntryPoint();
+		} else {
+			const response = await resolvedContainer.request({ url: "_summarizer" });
+			if (response.status !== 200 || response.mimeType !== "fluid/object") {
+				throw responseToException(response, request);
+			}
+			fluidObject = response.value;
+		}
+
 		if (fluidObject?.ISummarizer === undefined) {
 			throw new UsageError("Fluid object does not implement ISummarizer");
 		}

package/src/summary/summarizerNode/summarizerNode.ts

@@ -424,7 +424,7 @@ export class SummarizerNode implements IRootSummarizerNode {
 	 * Called when we get an ack from the server for a summary we've just sent. Updates the reference state of this node
 	 * from the state in the pending summary queue.
 	 * @param proposalHandle - Handle for the current proposal.
-	 * @param referenceSequenceNumber -  reference sequence number of sent summary.
+	 * @param referenceSequenceNumber - Reference sequence number of sent summary.
 	 */
 	protected refreshLatestSummaryFromPending(
 		proposalHandle: string,