@fluidframework/container-runtime 2.91.0 → 2.92.0

package/src/pendingStateManager.ts

@@ -335,7 +335,9 @@ export class PendingStateManager implements IDisposable {
 		return this.pendingMessagesCount !== 0;
 	}
 
-	public getLocalState(snapshotSequenceNumber?: number): IPendingLocalState {
+	public getLocalState(snapshotSequenceNumber?: number): {
+		pending: IPendingLocalState;
+	} {
 		assert(
 			this.initialMessages.isEmpty(),
 			0x2e9 /* "Must call getLocalState() after applying initial states" */,
@@ -359,10 +361,12 @@ export class PendingStateManager implements IDisposable {
 			}
 		}
 		return {
-			pendingStates: [
-				...newSavedOps,
-				...this.pendingMessages.toArray().map((message) => toSerializableForm(message)),
-			],
+			pending: {
+				pendingStates: [
+					...newSavedOps,
+					...this.pendingMessages.toArray().map((message) => toSerializableForm(message)),
+				],
+			},
 		};
 	}
 
@@ -427,7 +431,7 @@ export class PendingStateManager implements IDisposable {
 			clientId !== undefined,
 			0xa33 /* clientId (from stateHandler) could only be undefined if we've never connected, but we have a CSN so we know that's not the case */,
 		);
-
+		const batchInfo = { clientId, batchStartCsn, length: batch.length, ignoreBatchId, staged };
 		for (const message of batch) {
 			const {
 				runtimeOp,
@@ -438,12 +442,11 @@ export class PendingStateManager implements IDisposable {
 			const pendingMessage: IPendingMessage = {
 				type: "message",
 				referenceSequenceNumber,
-				content: serializeOp(runtimeOp),
+				content: serializeOp(runtimeOp).content,
 				runtimeOp,
 				localOpMetadata,
 				opMetadata,
-				// Note: We only will read this off the first message, but put it on all for simplicity
-				batchInfo: { clientId, batchStartCsn, length: batch.length, ignoreBatchId, staged },
+				batchInfo,
 			};
 			this.pendingMessages.push(pendingMessage);
 		}
@@ -747,8 +750,12 @@ export class PendingStateManager implements IDisposable {
 	 * Called when the Container's connection state changes. If the Container gets connected, it replays all the pending
 	 * states in its queue. This includes triggering resubmission of unacked ops.
 	 * ! Note: successfully resubmitting an op that has been successfully sequenced is not possible due to checks in the ConnectionStateHandler (Loader layer)
+	 *
+	 * @returns The unique batch infos for all batches that were replayed.
 	 */
-	public replayPendingStates(options?: ReplayPendingStateOptions): void {
+	public replayPendingStates(
+		options?: ReplayPendingStateOptions,
+	): IPendingMessage["batchInfo"][] {
 		const { committingStagedBatches, squash } = {
 			...defaultReplayPendingStatesOptions,
 			...options,
@@ -775,6 +782,7 @@ export class PendingStateManager implements IDisposable {
 
 		const initialPendingMessagesCount = this.pendingMessages.length;
 		let remainingPendingMessagesCount = this.pendingMessages.length;
+		const replayedBatchSet = new Set<IPendingMessage["batchInfo"]>();
 
 		let seenStagedBatch = false;
 
@@ -812,6 +820,7 @@ export class PendingStateManager implements IDisposable {
 			if (asEmptyBatchLocalOpMetadata(pendingMessage.localOpMetadata)?.emptyBatch === true) {
 				// Resubmit no messages, with the batchId. Will result in another empty batch marker.
 				this.stateHandler.reSubmitBatch([], { batchId, staged, squash });
+				replayedBatchSet.add(pendingMessage.batchInfo);
 				continue;
 			}
 
@@ -838,6 +847,7 @@ export class PendingStateManager implements IDisposable {
 					],
 					{ batchId, staged, squash },
 				);
+				replayedBatchSet.add(pendingMessage.batchInfo);
 				continue;
 			}
 			// else: batchMetadataFlag === true  (It's a typical multi-message batch)
@@ -877,6 +887,7 @@ export class PendingStateManager implements IDisposable {
 			}
 
 			this.stateHandler.reSubmitBatch(batch, { batchId, staged, squash });
+			replayedBatchSet.add(pendingMessage.batchInfo);
 		}
 
 		if (!committingStagedBatches) {
@@ -894,6 +905,8 @@ export class PendingStateManager implements IDisposable {
 				clientId: this.stateHandler.clientId(),
 			});
 		}
+
+		return [...replayedBatchSet];
 	}
 
 	/**
@@ -904,11 +917,13 @@ export class PendingStateManager implements IDisposable {
 			// callback will only be given staged messages with a valid runtime op (i.e. not empty batch and not an initial message with only serialized content)
 			stagedMessage: IPendingMessage & { runtimeOp: LocalContainerRuntimeMessage },
 		) => void,
-	): void {
+	): IPendingMessage["batchInfo"][] {
+		const batchSet = new Set<IPendingMessage["batchInfo"]>();
 		while (!this.pendingMessages.isEmpty()) {
 			const stagedMessage = this.pendingMessages.peekBack();
 			if (stagedMessage?.batchInfo.staged === true) {
 				this.pendingMessages.pop();
+				batchSet.add(stagedMessage.batchInfo);
 
 				if (hasTypicalRuntimeOp(stagedMessage)) {
 					callback(stagedMessage);
@@ -921,6 +936,7 @@ export class PendingStateManager implements IDisposable {
 			this.pendingMessages.toArray().every((m) => m.batchInfo.staged !== true),
 			0xb89 /* Shouldn't be any more staged messages */,
 		);
+		return [...batchSet];
 	}
 }
 

package/src/summary/documentSchema.ts

@@ -512,7 +512,7 @@ function arrayToProp(arr: string[]): string[] | undefined {
  *
  * Users of this class need to use DocumentsSchemaController.sessionSchema to determine what features can be used.
  *
- * There are two modes this class can operate:
+ * There are three modes this class can operate:
  * 1) Legacy mode. In such mode it does not issue any ops to change document schema. Any changes happen implicitly,
  *    right away, and new features are available right away
  * 2) Non-legacy mode. In such mode any changes to schema require an op roundtrip. This class will manage such transitions.
@@ -523,6 +523,9 @@ function arrayToProp(arr: string[]): string[] | undefined {
  *    then eventually all documents that are modified will have that feature reflected in their schema. It could require
  *    multiple reloads / new sessions to get there (depends on if code reacts to schema changes right away, or only consults
  *    schema on document load).
+ * 3) Schema upgrade disabled mode (disableSchemaUpgrade = true). In this mode the controller will never send DocumentSchemaChange ops
+ *    and will throw an error if any incoming schema change ops are received. The document schema is effectively frozen at the schema
+ *    loaded for this session (snapshot) and will not accept further schema-change ops.
  *
  * How schemas are changed (in non-legacy mode):
  * If a client needs to change a schema, it will attempt to do so as part of normal ops sending process.
@@ -569,6 +572,7 @@ export class DocumentsSchemaController {
 	 * @param onSchemaChange - callback that is called whenever schema is changed (not called on creation / load, only when processing document schema change ops)
 	 * @param info - Informational properties of the document that are not subject to strict schema enforcement
 	 * @param logger - telemetry logger from the runtime
+	 * @param disableSchemaUpgrade - when true, the controller will never send or accept DocumentSchemaChange ops
 	 */
 	constructor(
 		existing: boolean,
@@ -578,6 +582,7 @@ export class DocumentsSchemaController {
 		private readonly onSchemaChange: (schema: IDocumentSchemaCurrent) => void,
 		info: IDocumentSchemaInfo,
 		logger: ITelemetryLoggerExt,
+		private readonly disableSchemaUpgrade: boolean,
 	) {
 		// For simplicity, let's only support new schema features for explicit schema control mode
 		assert(
@@ -704,9 +709,12 @@ export class DocumentsSchemaController {
 	 * Called by Container runtime whenever it is about to send some op.
 	 * It gives opportunity for controller to issue its own ops - we do not want to send ops if there are no local changes in document.
 	 * Please consider note above constructor about race conditions - current design is to generate op only once in a session lifetime.
-	 * @returns Optional message to send.
+	 * @returns Optional message to send. Always returns undefined when disableSchemaUpgrade is true.
 	 */
 	public maybeGenerateSchemaMessage(): IDocumentSchemaChangeMessageOutgoing | undefined {
+		if (this.disableSchemaUpgrade) {
+			return undefined;
+		}
 		if (this.futureSchema !== undefined && !this.opPending) {
 			this.opPending = true;
 			assert(
@@ -739,6 +747,7 @@ export class DocumentsSchemaController {
 	/**
 	 * Process document schema change messages
 	 * Called by ContainerRuntime whenever it sees document schema messages.
+	 * When disableSchemaUpgrade is true, an error is thrown if any incoming schema change ops are received.
 	 * @param contents - contents of the messages
 	 * @param local - whether op is local
 	 * @param sequenceNumber - sequence number of the op
@@ -749,6 +758,20 @@ export class DocumentsSchemaController {
 		local: boolean,
 		sequenceNumber: number,
 	): boolean {
+		if (this.disableSchemaUpgrade) {
+			assert(
+				!local,
+				0xceb /* local schema change messages should never be generated when disableSchemaUpgrade is enabled */,
+			);
+			// Clients with disableSchemaUpgrade enabled should never generate schema change messages, but they
+			// may receive them from misconfigured clients. In such case, throw on any incoming schema change ops
+			// to prevent unexpected schema upgrades.
+			throw DataProcessingError.create(
+				"DocSchema: Received schema change op while disableSchemaUpgrade is enabled",
+				"processDocumentSchemaMessages",
+				undefined,
+			);
+		}
 		for (const content of contents) {
 			this.validateSeqNumber(content.refSeq, this.documentSchema.refSeq, "content.refSeq");
 			this.validateSeqNumber(this.documentSchema.refSeq, sequenceNumber, "refSeq");

package/src/summary/orderedClientElection.ts

@@ -515,7 +515,7 @@ export class OrderedClientElection
 				"InteractiveClientElected",
 				client,
 				sequenceNumber,
-				true /* forceSend */,
+				false /* forceSend */,
 				reason,
 			);
 			// Changing the elected parent as well.
@@ -544,7 +544,7 @@ export class OrderedClientElection
 				"ParentElected",
 				client,
 				sequenceNumber,
-				true /* forceSend */,
+				false /* forceSend */,
 				reason,
 			);
 			this._electedParent = client;

package/src/summary/summaryManager.ts

@@ -102,6 +102,7 @@ export class SummaryManager
 	private latestClientId: string | undefined;
 	private state = SummaryManagerState.Off;
 	private summarizer?: ISummarizer;
+	private pendingStopReason?: SummarizerStopReason;
 	private _disposed = false;
 	private summarizerStopTimeout?: ReturnType<typeof setTimeout>;
 	/**
@@ -287,6 +288,13 @@ export class SummaryManager
 				this.summarizer = summarizer;
 				this.setupForwardedEvents(summarizer);
 
+				// A stop may have been requested while we were awaiting summarizer creation.
+				// Replay it now so the summarizer can observe the stop intent and move to exit.
+				if (this.pendingStopReason !== undefined) {
+					summarizer.stop(this.pendingStopReason);
+					this.pendingStopReason = undefined;
+				}
+
 				// Re-validate that it need to be running. Due to asynchrony, it may be not the case anymore
 				// If we can't run the LastSummary, simply return as to avoid paying the cost of launching
 				// the summarizer at all.
@@ -375,6 +383,7 @@ export class SummaryManager
 	private cleanupAfterSummarizerStop(): void {
 		this.summarizerGeneration++;
 		this.state = SummaryManagerState.Off;
+		this.pendingStopReason = undefined;
 
 		// Clear any pending stop timeout to avoid it firing for a different summarizer
 		if (this.summarizerStopTimeout !== undefined) {
@@ -396,6 +405,7 @@ export class SummaryManager
 			return;
 		}
 		this.state = SummaryManagerState.Stopping;
+		this.pendingStopReason = reason;
 
 		// Stopping the running summarizer client should trigger a change
 		// in states when the running summarizer closes
@@ -502,6 +512,7 @@ export class SummaryManager
 		this.connectedState.off("connected", this.handleConnected);
 		this.connectedState.off("disconnected", this.handleDisconnected);
 		this.cleanupForwardedEvents();
+		this.pendingStopReason = undefined;
 		if (this.summarizerStopTimeout !== undefined) {
 			clearTimeout(this.summarizerStopTimeout);
 		}