@fluidframework/container-runtime 2.0.0-internal.1.4.2 → 2.0.0-internal.2.0.0

package/src/pendingStateManager.ts

@@ -10,7 +10,6 @@ import { DataProcessingError } from "@fluidframework/container-utils";
 import {
     ISequencedDocumentMessage,
 } from "@fluidframework/protocol-definitions";
-import { FlushMode } from "@fluidframework/runtime-definitions";
 import Deque from "double-ended-queue";
 import { ContainerMessageType } from "./containerRuntime";
 import { pkgVersion } from "./packageVersion";
@@ -29,15 +28,6 @@ export interface IPendingMessage {
     opMetadata: Record<string, unknown> | undefined;
 }
 
-/**
- * This represents a FlushMode update and is added to the pending queue when `setFlushMode` is called on the
- * ContainerRuntime and the FlushMode changes.
- */
-export interface IPendingFlushMode {
-    type: "flushMode";
-    flushMode: FlushMode;
-}
-
 /**
  * This represents an explicit flush call and is added to the pending queue when flush is called on the ContainerRuntime
  * to flush pending messages.
@@ -46,7 +36,7 @@ export interface IPendingFlush {
     type: "flush";
 }
 
-export type IPendingState = IPendingMessage | IPendingFlushMode | IPendingFlush;
+export type IPendingState = IPendingMessage | IPendingFlush;
 
 export interface IPendingLocalState {
     /**
@@ -58,8 +48,6 @@ export interface IPendingLocalState {
 export interface IRuntimeStateHandler{
     connected(): boolean;
     clientId(): string | undefined;
-    flushMode(): FlushMode;
-    setFlushMode(mode: FlushMode): void;
     close(error?: ICriticalContainerError): void;
     applyStashedOp: (type: ContainerMessageType, content: ISequencedDocumentMessage) => Promise<unknown>;
     flush(): void;
@@ -68,13 +56,18 @@ export interface IRuntimeStateHandler{
         content: any,
         localOpMetadata: unknown,
         opMetadata: Record<string, unknown> | undefined): void;
+    rollback(
+        type: ContainerMessageType,
+        content: any,
+        localOpMetadata: unknown): void;
+    orderSequentially(callback: () => void): void;
 }
 
 /**
  * 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
  * batches along with the messages.
- * When the Container reconnects, it replays the pending states, which includes setting the FlushMode, manual flushing
+ * When the Container reconnects, it replays the pending states, which includes manual flushing
  * of messages and triggering resubmission of unacked ops.
  *
  * It verifies that all the ops are acked, are received in the right order and batch information is correct.
@@ -100,13 +93,6 @@ export class PendingStateManager implements IDisposable {
     // the correct batch metadata.
     private pendingBatchBeginMessage: ISequencedDocumentMessage | undefined;
 
-    /**
-     * This tracks the flush mode for the next message in the pending state queue. When replaying messages, we need to
-     * first set the flush mode to this value and then send ops. It is important to do this info because the flush
-     * mode could have been updated.
-     */
-    private flushModeForNextMessage: FlushMode;
-
     private clientId: string | undefined;
 
     /**
@@ -131,13 +117,9 @@ export class PendingStateManager implements IDisposable {
 
     constructor(
         private readonly stateHandler: IRuntimeStateHandler,
-        initialFlushMode: FlushMode,
         initialLocalState: IPendingLocalState | undefined,
     ) {
         this.initialStates = new Deque<IPendingState>(initialLocalState?.pendingStates ?? []);
-
-        this.flushModeForNextMessage = initialFlushMode;
-        this.onFlushModeUpdated(initialFlushMode);
     }
 
     public get disposed() { return this.disposeOnce.evaluated; }
@@ -174,24 +156,10 @@ export class PendingStateManager implements IDisposable {
         this._pendingMessagesCount++;
     }
 
-    /**
-     * Called when the FlushMode is updated. Adds the FlushMode to the pending state queue.
-     * @param flushMode - The flushMode that was updated.
-     */
-    public onFlushModeUpdated(flushMode: FlushMode) {
-        this.pendingStates.push({ type: "flushMode", flushMode });
-    }
-
     /**
      * Called when flush() is called on the ContainerRuntime to manually flush messages.
      */
     public onFlush() {
-        // If the FlushMode is Immediate, we don't need to track an explicit flush call because every message is
-        // automatically flushed. So, flush is a no-op.
-        if (this.stateHandler.flushMode() === FlushMode.Immediate) {
-            return;
-        }
-
         // If the previous state is not a message, flush is a no-op.
         const previousState = this.pendingStates.peekBack();
         if (previousState?.type !== "message") {
@@ -279,11 +247,6 @@ export class PendingStateManager implements IDisposable {
      * @param message - The message that is being processed.
      */
     private maybeProcessBatchBegin(message: ISequencedDocumentMessage) {
-        // Tracks the last FlushMode that was set before this message was sent.
-        let pendingFlushMode: FlushMode | undefined;
-        // Tracks whether a flush was called before this message was sent.
-        let pendingFlush: boolean = false;
-
         /**
          * We are checking if the next message is the start of a batch. It can happen in the following scenarios:
          *
@@ -295,34 +258,12 @@ export class PendingStateManager implements IDisposable {
          * Keep reading pending states from the queue until we encounter a message. It's possible that the FlushMode was
          * updated a bunch of times without sending any messages.
          */
-        let nextPendingState = this.peekNextPendingState();
-        while (nextPendingState.type !== "message") {
-            if (nextPendingState.type === "flushMode") {
-                pendingFlushMode = nextPendingState.flushMode;
-            }
-            if (nextPendingState.type === "flush") {
-                pendingFlush = true;
-            }
+        while (this.peekNextPendingState().type !== "message") {
             this.pendingStates.shift();
-            nextPendingState = this.peekNextPendingState();
         }
 
-        if (pendingFlushMode !== undefined) {
-            this.flushModeForNextMessage = pendingFlushMode;
-        }
-
-        // If the FlushMode was set to Immediate before this message was sent, this message won't be a batch message
-        // because in Immediate mode, every message is flushed individually.
-        if (pendingFlushMode === FlushMode.Immediate) {
-            return;
-        }
-
-        /**
-         * This message is the first in a batch if before it was sent either the FlushMode was set to TurnBased or there
-         * was an explicit flush call. Note that a flush call is tracked only in TurnBased mode and it indicates the end
-         * of one batch and beginning of another.
-         */
-        if (pendingFlushMode === FlushMode.TurnBased || pendingFlush) {
+        // This message is the first in a batch if the "batch" property on the metadata is set to true
+        if (message.metadata?.batch) {
             // We should not already be processing a batch and there should be no pending batch begin message.
             assert(!this.isProcessingBatch && this.pendingBatchBeginMessage === undefined,
                 0x16b /* "The pending batch state indicates we are already processing a batch" */);
@@ -347,16 +288,6 @@ export class PendingStateManager implements IDisposable {
             return;
         }
 
-        /**
-         * We are in the middle of processing a batch. The batch ends when we see an explicit flush. We should never see
-         * a FlushMode before flush. This is true because we track batches only when FlushMode is TurnBased and in this
-         * mode, a batch ends either by calling flush or by changing the mode to Immediate which also triggers a flush.
-         */
-        assert(
-            nextPendingState.type !== "flushMode",
-            0x2bd /* "We should not see a pending FlushMode until we see a flush when processing a batch" */,
-        );
-
         // There should be a pending batch begin message.
         assert(this.pendingBatchBeginMessage !== undefined, 0x16d /* "There is no pending batch begin message" */);
 
@@ -406,7 +337,7 @@ 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 setting the FlushMode and triggering resubmission of unacked ops.
+     * states in its queue. This includes triggering resubmission of unacked ops.
      */
     public replayPendingStates() {
         assert(this.stateHandler.connected(), 0x172 /* "The connection state is not consistent with the runtime" */);
@@ -426,12 +357,7 @@ export class PendingStateManager implements IDisposable {
         // Reset the pending message count because all these messages will be removed from the queue.
         this._pendingMessagesCount = 0;
 
-        // Save the current FlushMode so that we can revert it back after replaying the states.
-        const savedFlushMode = this.stateHandler.flushMode();
-
-        // Set the flush mode for the next message. This step is important because the flush mode may have been changed
-        // after the next pending message was sent.
-        this.stateHandler.setFlushMode(this.flushModeForNextMessage);
+        const messageBatchQueue = new Deque<IPendingMessage>();
 
         // Process exactly `pendingStatesCount` items in the queue as it represents the number of states that were
         // pending when we connected. This is important because the `reSubmitFn` might add more items in the queue
@@ -441,16 +367,43 @@ export class PendingStateManager implements IDisposable {
             const pendingState = this.pendingStates.shift()!;
             switch (pendingState.type) {
                 case "message":
-                    this.stateHandler.reSubmit(
-                        pendingState.messageType,
-                        pendingState.content,
-                        pendingState.localOpMetadata,
-                        pendingState.opMetadata);
-                    break;
-                case "flushMode":
-                    this.stateHandler.setFlushMode(pendingState.flushMode);
+                    assert(pendingState.opMetadata?.batch !== false || messageBatchQueue.length > 0,
+                        0x41b /* We cannot process batches in chunks */);
+                    /**
+                     * We want to ensure grouped messages get processed in a batch.
+                     * Note: It is not possible for the PendingStateManager to receive a partially acked batch. It will
+                     * either receive the whole batch ack or nothing at all.
+                     */
+                    if (messageBatchQueue.length > 0 || pendingState.opMetadata?.batch) {
+                        messageBatchQueue.enqueue(pendingState);
+                    } else {
+                        this.stateHandler.reSubmit(
+                            pendingState.messageType,
+                            pendingState.content,
+                            pendingState.localOpMetadata,
+                            pendingState.opMetadata);
+                    }
                     break;
                 case "flush":
+                    /**
+                     * A "flush" call can indicate the end of a batch.
+                     * We can't rely on the "batch" property in the message metadata as it gets
+                     * updated elsewhere and it is not the same object instance that gets updated.
+                     */
+                    if (messageBatchQueue.length > 0) {
+                        this.stateHandler.orderSequentially(() => {
+                            while (messageBatchQueue.length > 0) {
+                                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                                const message = messageBatchQueue.dequeue()!;
+                                this.stateHandler.reSubmit(
+                                    message.messageType,
+                                    message.content,
+                                    message.localOpMetadata,
+                                    message.opMetadata);
+                            }
+                        });
+                    }
+                    assert(messageBatchQueue.length === 0, 0x41c /* cannot flush in the middle of a batch */);
                     this.stateHandler.flush();
                     break;
                 default:
@@ -459,7 +412,15 @@ export class PendingStateManager implements IDisposable {
             pendingStatesCount--;
         }
 
-        // Revert the FlushMode.
-        this.stateHandler.setFlushMode(savedFlushMode);
+        // There are some cases where ops are stashed but not flushed. We need to ensure they are resubmitted
+        while (messageBatchQueue.length > 0) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const message = messageBatchQueue.dequeue()!;
+            this.stateHandler.reSubmit(
+                message.messageType,
+                message.content,
+                message.localOpMetadata,
+                message.opMetadata);
+        }
     }
 }

package/src/scheduleManager.ts

@@ -221,6 +221,7 @@ class ScheduleManagerCore {
                 length: endBatch - startBatch,
             });
         }
+
         this.deltaManager.inbound.resume();
     }
 

package/src/summarizer.ts

@@ -334,7 +334,7 @@ export class Summarizer extends EventEmitter implements ISummarizer {
             const coordinatorCreateP = this.runCoordinatorCreateFn(this.runtime);
 
             coordinatorCreateP.then((runCoordinator) => {
-                // Successully created the cancellation token. Start the summarizer.
+                // Successfully created the cancellation token. Start the summarizer.
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 const startP = this.start(this.runtime.clientId!, runCoordinator);
                 startP.then(async (runningSummarizer) => {
@@ -382,11 +382,11 @@ export class Summarizer extends EventEmitter implements ISummarizer {
                 // executing the refreshLatestSummaryAck.
                 // https://dev.azure.com/fluidframework/internal/_workitems/edit/779
                 await this.runningSummarizer.lockedRefreshSummaryAckAction(async () =>
-                    this.internalsProvider.refreshLatestSummaryAck(
-                        summaryOpHandle,
-                        summaryAckHandle,
-                        refSequenceNumber,
-                        summaryLogger,
+                    this.internalsProvider.refreshLatestSummaryAck({
+                        proposalHandle: summaryOpHandle,
+                        ackHandle: summaryAckHandle,
+                        summaryRefSeq: refSequenceNumber,
+                        summaryLogger },
                     ).catch(async (error) => {
                         // If the error is 404, so maybe the fetched version no longer exists on server. We just
                         // ignore this error in that case, as that means we will have another summaryAck for the

package/src/summarizerTypes.ts

@@ -61,12 +61,7 @@ export interface ISummarizerInternalsProvider {
     submitSummary(options: ISubmitSummaryOptions): Promise<SubmitSummaryResult>;
 
     /** Callback whenever a new SummaryAck is received, to update internal tracking state */
-    refreshLatestSummaryAck(
-        proposalHandle: string,
-        ackHandle: string,
-        summaryRefSeq: number,
-        summaryLogger: ITelemetryLogger,
-    ): Promise<void>;
+    refreshLatestSummaryAck(options: IRefreshSummaryAckOptions): Promise<void>;
 }
 
 /**
@@ -114,6 +109,20 @@ export interface ISummarizeOptions {
     readonly refreshLatestAck?: boolean;
 }
 
+/**
+ * Data required to update internal tracking state after receiving a Summary Ack.
+ */
+ export interface IRefreshSummaryAckOptions {
+    /** Handle from the ack's summary op. */
+    readonly proposalHandle: string | undefined;
+    /** Handle from the summary ack just received */
+    readonly ackHandle: string;
+    /** Reference sequence number from the ack's summary op */
+    readonly summaryRefSeq: number;
+    /** Telemetry logger to which telemetry events will be forwarded. */
+    readonly summaryLogger: ITelemetryLogger;
+}
+
 export interface ISubmitSummaryOptions extends ISummarizeOptions {
     /** Logger to use for correlated summary events */
     readonly summaryLogger: ITelemetryLogger;
@@ -292,7 +301,11 @@ export type SummarizerStopReason =
      * client to no longer be elected as responsible for summaries. Then it
      * tries to stop its spawned summarizer client.
      */
-    | "parentShouldNotSummarize"
+    | "notElectedParent"
+    /**
+     * We are not already running the summarizer and we are not the current elected client id.
+     */
+    | "notElectedClient"
     /** Summarizer client was disconnected */
     | "summarizerClientDisconnected"
     /* running summarizer threw an exception */

package/src/summaryFormat.ts

@@ -99,14 +99,16 @@ export interface IGCMetadata {
      * - A value greater than 0 means GC is enabled.
      */
     readonly gcFeature?: GCVersion;
-    /** If this is present, the session for this container will expire after this time and the container will close */
-    readonly sessionExpiryTimeoutMs?: number;
     /**
      * Tells whether the GC sweep phase is enabled for this container.
      * - True means sweep phase is enabled.
      * - False means sweep phase is disabled. If GC is disabled as per gcFeature, sweep is also disabled.
      */
     readonly sweepEnabled?: boolean;
+    /** If this is present, the session for this container will expire after this time and the container will close */
+    readonly sessionExpiryTimeoutMs?: number;
+    /** How long to wait after an object is unreferenced before deleting it via GC Sweep */
+    readonly sweepTimeoutMs?: number;
 }
 
 /** The properties of an ISequencedDocumentMessage to be stored in the metadata blob in summary. */

package/src/summaryManager.ts

@@ -29,7 +29,8 @@ export enum SummaryManagerState {
 // Please note that all reasons in this list are not errors,
 // and thus they are not raised today to parent container as error.
 // If this needs to be changed in future, we should re-evaluate what and how we raise to summarizer
-type StopReason = Extract<SummarizerStopReason, "parentNotConnected" | "parentShouldNotSummarize">;
+type StopReason = Extract<SummarizerStopReason,
+    "parentNotConnected" | "notElectedParent" | "notElectedClient">;
 type ShouldSummarizeState =
     | { shouldSummarize: true; }
     | { shouldSummarize: false; stopReason: StopReason; };
@@ -141,13 +142,23 @@ export class SummaryManager implements IDisposable {
         // enforce connectedState.clientId === clientElection.electedClientId. But once we're Running, we should
         // only transition to Stopping when the electedParentId changes. Stopping the summarizer without
         // changing the electedParent will just cause us to transition to Starting again.
-        if (this.connectedState.clientId !== this.clientElection.electedParentId ||
-            (this.state !== SummaryManagerState.Running &&
-                this.connectedState.clientId !== this.clientElection.electedClientId)) {
-            return { shouldSummarize: false, stopReason: "parentShouldNotSummarize" };
-        } else if (!this.connectedState.connected) {
+
+        // New Parent has been elected and it is not the current client, or
+        if (this.connectedState.clientId !== this.clientElection.electedParentId) {
+            return { shouldSummarize: false, stopReason: "notElectedParent" };
+        }
+
+        // We are not already running the summarizer and we are not the current elected client id.
+        if (this.state !== SummaryManagerState.Running &&
+                this.connectedState.clientId !== this.clientElection.electedClientId) {
+            return { shouldSummarize: false, stopReason: "notElectedClient" };
+        }
+
+        if (!this.connectedState.connected) {
             return { shouldSummarize: false, stopReason: "parentNotConnected" };
-        } else if (this.disposed) {
+        }
+
+        if (this.disposed) {
             assert(false, 0x260 /* "Disposed should mean disconnected!" */);
         } else {
             return { shouldSummarize: true };