@fluidframework/container-runtime 2.0.0-dev.4.2.0.153917 → 2.0.0-dev.4.3.0.158678

package/lib/containerRuntime.js

@@ -1,5 +1,5 @@
 import { AttachState, LoaderHeader, } from "@fluidframework/container-definitions";
-import { assert, LazyPromise, Trace, TypedEventEmitter, unreachableCase, } from "@fluidframework/common-utils";
+import { assert, delay, LazyPromise, Trace, TypedEventEmitter, unreachableCase, } from "@fluidframework/common-utils";
 import { ChildLogger, raiseConnectedEvent, PerformanceEvent, TaggedLoggerAdapter, loggerToMonitoringContext, wrapError, } from "@fluidframework/telemetry-utils";
 import { DriverHeader, FetchSource, } from "@fluidframework/driver-definitions";
 import { readAndParse } from "@fluidframework/driver-utils";
@@ -15,7 +15,7 @@ import { PendingStateManager } from "./pendingStateManager";
 import { pkgVersion } from "./packageVersion";
 import { BlobManager } from "./blobManager";
 import { DataStores, getSummaryForDatastores } from "./dataStores";
-import { aliasBlobName, blobsTreeName, chunksBlobName, createRootSummarizerNodeWithGC, electedSummarizerBlobName, extractSummaryMetadataMessage, metadataBlobName, Summarizer, SummaryManager, wrapSummaryInChannelsTree, SummaryCollection, OrderedClientCollection, OrderedClientElection, SummarizerClientElection, summarizerClientType, RunWhileConnectedCoordinator, } from "./summary";
+import { aliasBlobName, blobsTreeName, chunksBlobName, createRootSummarizerNodeWithGC, electedSummarizerBlobName, extractSummaryMetadataMessage, idCompressorBlobName, metadataBlobName, Summarizer, SummaryManager, wrapSummaryInChannelsTree, SummaryCollection, OrderedClientCollection, OrderedClientElection, SummarizerClientElection, summarizerClientType, RunWhileConnectedCoordinator, } from "./summary";
 import { formExponentialFn, Throttler } from "./throttler";
 import { GarbageCollector, GCNodeType, gcTombstoneGenerationOptionName, shouldAllowGcTombstoneEnforcement, trimLeadingAndTrailingSlashes, } from "./gc";
 import { channelToDataStore, isDataStoreAliasMessage } from "./dataStore";
@@ -37,6 +37,12 @@ export var ContainerMessageType;
     ContainerMessageType["Rejoin"] = "rejoin";
     // Sets the alias of a root data store
     ContainerMessageType["Alias"] = "alias";
+    /**
+     * An op containing an IdRange of Ids allocated using the runtime's IdCompressor since
+     * the last allocation op was sent.
+     * See the [IdCompressor README](./id-compressor/README.md) for more details.
+     */
+    ContainerMessageType["IdAllocation"] = "idAllocation";
 })(ContainerMessageType || (ContainerMessageType = {}));
 export const DefaultSummaryConfiguration = {
     state: "enabled",
@@ -92,6 +98,12 @@ const defaultCompressionConfig = {
     compressionAlgorithm: CompressionAlgorithms.lz4,
 };
 const defaultChunkSizeInBytes = 204800;
+/**
+ * Instead of refreshing from latest because we do not have 100% confidence in the state
+ * of the current system, we should close the summarizer and let it recover.
+ * This delay's goal is to prevent tight restart loops
+ */
+const defaultCloseSummarizerDelayMs = 10000; // 10 seconds
 /**
  * @deprecated - use ContainerRuntimeMessage instead
  */
@@ -138,8 +150,8 @@ export class ContainerRuntime extends TypedEventEmitter {
     /**
      * @internal
      */
-    constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, logger, existing, blobManagerSnapshot, _storage, requestHandler, summaryConfiguration, initializeEntryPoint) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+    constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, logger, existing, blobManagerSnapshot, _storage, idCompressor, requestHandler, summaryConfiguration, initializeEntryPoint) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         if (summaryConfiguration === void 0) { summaryConfiguration = Object.assign(Object.assign({}, DefaultSummaryConfiguration), (_a = runtimeOptions.summaryOptions) === null || _a === void 0 ? void 0 : _a.summaryConfigOverrides); }
         super();
         this.context = context;
@@ -201,6 +213,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         };
         this.innerDeltaManager = context.deltaManager;
         this.deltaManager = new DeltaManagerSummarizerProxy(context.deltaManager);
+        this.mc = loggerToMonitoringContext(ChildLogger.create(this.logger, "ContainerRuntime"));
         let loadSummaryNumber;
         // Get the container creation metadata. For new container, we initialize these. For existing containers,
         // get the values from the metadata blob.
@@ -212,6 +225,9 @@ export class ContainerRuntime extends TypedEventEmitter {
             // summaryNumber was renamed from summaryCount. For older docs that haven't been opened for a long time,
             // the count is reset to 0.
             loadSummaryNumber = (_b = metadata === null || metadata === void 0 ? void 0 : metadata.summaryNumber) !== null && _b !== void 0 ? _b : 0;
+            // Enabling the IdCompressor is a one-way operation and we only want to
+            // allow new containers to turn it on
+            this.idCompressorEnabled = (_c = metadata === null || metadata === void 0 ? void 0 : metadata.idCompressorEnabled) !== null && _c !== void 0 ? _c : false;
         }
         else {
             this.createContainerMetadata = {
@@ -219,12 +235,13 @@ export class ContainerRuntime extends TypedEventEmitter {
                 createContainerTimestamp: Date.now(),
             };
             loadSummaryNumber = 0;
+            this.idCompressorEnabled =
+                (_d = this.mc.config.getBoolean("Fluid.ContainerRuntime.IdCompressorEnabled")) !== null && _d !== void 0 ? _d : idCompressor !== undefined;
         }
         this.nextSummaryNumber = loadSummaryNumber + 1;
         this.messageAtLastSummary = metadata === null || metadata === void 0 ? void 0 : metadata.message;
         this._connected = this.context.connected;
-        this.gcTombstoneEnforcementAllowed = shouldAllowGcTombstoneEnforcement((_c = metadata === null || metadata === void 0 ? void 0 : metadata.gcFeatureMatrix) === null || _c === void 0 ? void 0 : _c.tombstoneGeneration /* persisted */, this.runtimeOptions.gcOptions[gcTombstoneGenerationOptionName] /* current */);
-        this.mc = loggerToMonitoringContext(ChildLogger.create(this.logger, "ContainerRuntime"));
+        this.gcTombstoneEnforcementAllowed = shouldAllowGcTombstoneEnforcement((_e = metadata === null || metadata === void 0 ? void 0 : metadata.gcFeatureMatrix) === null || _e === void 0 ? void 0 : _e.tombstoneGeneration /* persisted */, this.runtimeOptions.gcOptions[gcTombstoneGenerationOptionName] /* current */);
         this.mc.logger.sendTelemetryEvent({
             eventName: "GCFeatureMatrix",
             metadataValue: JSON.stringify(metadata === null || metadata === void 0 ? void 0 : metadata.gcFeatureMatrix),
@@ -232,7 +249,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 gcOptions_gcTombstoneGeneration: this.runtimeOptions.gcOptions[gcTombstoneGenerationOptionName],
             }),
         });
-        this.telemetryDocumentId = (_d = metadata === null || metadata === void 0 ? void 0 : metadata.telemetryDocumentId) !== null && _d !== void 0 ? _d : uuid();
+        this.telemetryDocumentId = (_f = metadata === null || metadata === void 0 ? void 0 : metadata.telemetryDocumentId) !== null && _f !== void 0 ? _f : uuid();
         this.disableAttachReorder = this.mc.config.getBoolean("Fluid.ContainerRuntime.disableAttachOpReorder");
         const disableChunking = this.mc.config.getBoolean("Fluid.ContainerRuntime.CompressionChunkingDisabled");
         const opGroupingManager = new OpGroupingManager(this.groupedBatchingEnabled);
@@ -251,10 +268,13 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.heuristicsDisabled = this.isHeuristicsDisabled();
         this.maxOpsSinceLastSummary = this.getMaxOpsSinceLastSummary();
         this.initialSummarizerDelayMs = this.getInitialSummarizerDelayMs();
+        if (this.idCompressorEnabled) {
+            this.idCompressor = idCompressor;
+        }
         this.maxConsecutiveReconnects =
-            (_e = this.mc.config.getNumber(maxConsecutiveReconnectsKey)) !== null && _e !== void 0 ? _e : this.defaultMaxConsecutiveReconnects;
+            (_g = this.mc.config.getNumber(maxConsecutiveReconnectsKey)) !== null && _g !== void 0 ? _g : this.defaultMaxConsecutiveReconnects;
         if (runtimeOptions.flushMode === FlushModeExperimental.Async &&
-            ((_f = context.supportedFeatures) === null || _f === void 0 ? void 0 : _f.get("referenceSequenceNumbers")) !== true) {
+            ((_h = context.supportedFeatures) === null || _h === void 0 ? void 0 : _h.get("referenceSequenceNumbers")) !== true) {
             // The loader does not support reference sequence numbers, falling back on FlushMode.TurnBased
             this.mc.logger.sendErrorEvent({ eventName: "FlushModeFallback" });
             this._flushMode = FlushMode.TurnBased;
@@ -263,7 +283,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             this._flushMode = runtimeOptions.flushMode;
         }
         const pendingRuntimeState = context.pendingLocalState;
-        const maxSnapshotCacheDurationMs = (_h = (_g = this._storage) === null || _g === void 0 ? void 0 : _g.policies) === null || _h === void 0 ? void 0 : _h.maximumCacheDurationMs;
+        const maxSnapshotCacheDurationMs = (_k = (_j = this._storage) === null || _j === void 0 ? void 0 : _j.policies) === null || _k === void 0 ? void 0 : _k.maximumCacheDurationMs;
         if (maxSnapshotCacheDurationMs !== undefined &&
             maxSnapshotCacheDurationMs > 5 * 24 * 60 * 60 * 1000) {
             // This is a runtime enforcement of what's already explicit in the policy's type itself,
@@ -315,15 +335,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.dataStores = new DataStores(getSummaryForDatastores(context.baseSnapshot, metadata), this, (attachMsg) => this.submit(ContainerMessageType.Attach, attachMsg), (id, createParam) => (summarizeInternal, getGCDataFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, undefined, getGCDataFn), (id) => this.summarizerNode.deleteChild(id), this.mc.logger, (path, timestampMs, packagePath) => this.garbageCollector.nodeUpdated(path, "Changed", timestampMs, packagePath), (path) => this.garbageCollector.isNodeDeleted(path), new Map(dataStoreAliasMap));
         this.blobManager = new BlobManager(this.handleContext, blobManagerSnapshot, () => this.storage, (localId, blobId) => {
             if (!this.disposed) {
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                Promise.resolve().then(() => {
-                    // Blob attaches need to be in their own batch (grouped batching would hide metadata)
-                    this.flush();
-                    this.submit(ContainerMessageType.BlobAttach, undefined, undefined, {
-                        localId,
-                        blobId,
-                    });
-                    this.flush();
+                this.submit(ContainerMessageType.BlobAttach, undefined, undefined, {
+                    localId,
+                    blobId,
                 });
             }
         }, (blobPath) => this.garbageCollector.nodeUpdated(blobPath, "Loaded"), (blobPath) => this.garbageCollector.isNodeDeleted(blobPath), this, pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.pendingAttachmentBlobs, (error) => this.closeFn(error));
@@ -358,10 +372,17 @@ export class ContainerRuntime extends TypedEventEmitter {
             },
             logger: this.mc.logger,
             groupingManager: opGroupingManager,
+            getCurrentSequenceNumbers: () => ({
+                referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
+                clientSequenceNumber: this._processedClientSequenceNumber,
+            }),
         });
         this.context.quorum.on("removeMember", (clientId) => {
             this.remoteMessageProcessor.clearPartialMessagesFor(clientId);
         });
+        this.summaryStateUpdateMethod = this.mc.config.getString("Fluid.ContainerRuntime.Test.SummaryStateUpdateMethod");
+        const closeSummarizerDelayOverride = this.mc.config.getNumber("Fluid.ContainerRuntime.Test.CloseSummarizerDelayOverrideMs");
+        this.closeSummarizerDelayMs = closeSummarizerDelayOverride !== null && closeSummarizerDelayOverride !== void 0 ? closeSummarizerDelayOverride : defaultCloseSummarizerDelayMs;
         this.summaryCollection = new SummaryCollection(this.deltaManager, this.logger);
         this.dirtyContainer =
             this.context.attachState !== AttachState.Attached ||
@@ -439,6 +460,9 @@ export class ContainerRuntime extends TypedEventEmitter {
                 disableChunking,
                 disableAttachReorder: this.disableAttachReorder,
                 disablePartialFlush,
+                idCompressorEnabled: this.idCompressorEnabled,
+                summaryStateUpdateMethod: this.summaryStateUpdateMethod,
+                closeSummarizerDelayOverride,
             }), telemetryDocumentId: this.telemetryDocumentId, groupedBatchingEnabled: this.groupedBatchingEnabled }));
         ReportOpPerfTelemetry(this.context.clientId, this.deltaManager, this.logger);
         BindBatchTracker(this, this.logger);
@@ -498,7 +522,7 @@ export class ContainerRuntime extends TypedEventEmitter {
      * This object should provide all the functionality that the Container is expected to provide to the loader layer.
      */
     static async loadRuntime(params) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e, _f;
         const { context, registryEntries, existing, requestHandler, runtimeOptions = {}, containerScope = {}, containerRuntimeCtor = ContainerRuntime, initializeEntryPoint, } = params;
         // If taggedLogger exists, use it. Otherwise, wrap the vanilla logger:
         // back-compat: Remove the TaggedLoggerAdapter fallback once all the host are using loader > 0.45
@@ -509,7 +533,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 runtimeVersion: pkgVersion,
             },
         });
-        const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, compressionOptions = defaultCompressionConfig, maxBatchSizeInBytes = defaultMaxBatchSizeInBytes, chunkSizeInBytes = defaultChunkSizeInBytes, enableOpReentryCheck = false, enableGroupedBatching = false, } = runtimeOptions;
+        const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, compressionOptions = defaultCompressionConfig, maxBatchSizeInBytes = defaultMaxBatchSizeInBytes, enableRuntimeIdCompressor = false, chunkSizeInBytes = defaultChunkSizeInBytes, enableOpReentryCheck = false, enableGroupedBatching = false, } = runtimeOptions;
         const registry = new FluidDataStoreRegistry(registryEntries);
         const tryFetchBlob = async (blobName) => {
             var _a;
@@ -521,11 +545,12 @@ export class ContainerRuntime extends TypedEventEmitter {
                 return readAndParse(context.storage, blobId);
             }
         };
-        const [chunks, metadata, electedSummarizerData, aliases] = await Promise.all([
+        const [chunks, metadata, electedSummarizerData, aliases, serializedIdCompressor] = await Promise.all([
             tryFetchBlob(chunksBlobName),
             tryFetchBlob(metadataBlobName),
             tryFetchBlob(electedSummarizerBlobName),
             tryFetchBlob(aliasBlobName),
+            tryFetchBlob(idCompressorBlobName),
         ]);
         const loadExisting = existing === true || context.existing === true;
         // read snapshot blobs needed for BlobManager to load
@@ -557,6 +582,15 @@ export class ContainerRuntime extends TypedEventEmitter {
                 }
             }
         }
+        const idCompressorEnabled = (_f = (_e = metadata === null || metadata === void 0 ? void 0 : metadata.idCompressorEnabled) !== null && _e !== void 0 ? _e : runtimeOptions.enableRuntimeIdCompressor) !== null && _f !== void 0 ? _f : false;
+        let idCompressor;
+        if (idCompressorEnabled) {
+            const { IdCompressor, createSessionId } = await import("./id-compressor");
+            idCompressor =
+                serializedIdCompressor !== undefined
+                    ? IdCompressor.deserialize(serializedIdCompressor, createSessionId())
+                    : new IdCompressor(createSessionId(), logger);
+        }
         const runtime = new containerRuntimeCtor(context, registry, metadata, electedSummarizerData, chunks !== null && chunks !== void 0 ? chunks : [], aliases !== null && aliases !== void 0 ? aliases : [], {
             summaryOptions,
             gcOptions,
@@ -565,9 +599,10 @@ export class ContainerRuntime extends TypedEventEmitter {
             compressionOptions,
             maxBatchSizeInBytes,
             chunkSizeInBytes,
+            enableRuntimeIdCompressor,
             enableOpReentryCheck,
             enableGroupedBatching,
-        }, containerScope, logger, loadExisting, blobManagerSnapshot, context.storage, requestHandler, undefined, // summaryConfiguration
+        }, containerScope, logger, loadExisting, blobManagerSnapshot, context.storage, idCompressor, requestHandler, undefined, // summaryConfiguration
         initializeEntryPoint);
         // It's possible to have ops with a reference sequence number of 0. Op sequence numbers start
         // at 1, so we won't see a replayed saved op with a sequence number of 0.
@@ -803,12 +838,17 @@ export class ContainerRuntime extends TypedEventEmitter {
             summaryNumber: this.nextSummaryNumber++, summaryFormatVersion: 1 }), this.garbageCollector.getMetadata()), { 
             // The last message processed at the time of summary. If there are no new messages, use the message from the
             // last summary.
-            message: (_a = extractSummaryMetadataMessage(this.deltaManager.lastMessage)) !== null && _a !== void 0 ? _a : this.messageAtLastSummary, telemetryDocumentId: this.telemetryDocumentId });
+            message: (_a = extractSummaryMetadataMessage(this.deltaManager.lastMessage)) !== null && _a !== void 0 ? _a : this.messageAtLastSummary, telemetryDocumentId: this.telemetryDocumentId, idCompressorEnabled: this.idCompressorEnabled ? true : undefined });
         addBlobToSummary(summaryTree, metadataBlobName, JSON.stringify(metadata));
     }
     addContainerStateToSummary(summaryTree, fullTree, trackState, telemetryContext) {
         var _a;
         this.addMetadataToSummary(summaryTree);
+        if (this.idCompressorEnabled) {
+            assert(this.idCompressor !== undefined, 0x67a /* IdCompressor should be defined if enabled */);
+            const idCompressorState = JSON.stringify(this.idCompressor.serialize(false));
+            addBlobToSummary(summaryTree, idCompressorBlobName, idCompressorState);
+        }
         if (this.remoteMessageProcessor.partialMessages.size > 0) {
             const content = JSON.stringify([...this.remoteMessageProcessor.partialMessages]);
             addBlobToSummary(summaryTree, chunksBlobName, content);
@@ -890,12 +930,28 @@ export class ContainerRuntime extends TypedEventEmitter {
         // Officially transition from the old state to the new state.
         this.updateDocumentDirtyState(newState);
     }
-    async applyStashedOp(type, op) {
+    /**
+     * Updates the runtime's IdCompressor with the stashed state present in the given op. This is a bit of a
+     * hack and is unnecessarily expensive. As it stands, every locally stashed op (all ops that get stored in
+     * the PendingStateManager) will store their serialized representation locally until ack'd. Upon receiving
+     * this stashed state, the IdCompressor blindly deserializes to the stashed state and assumes the session.
+     * Technically only the last stashed state is needed to do this correctly, but we would have to write some
+     * more hacky code to modify the batch before it gets sent out.
+     * @param content - An IdAllocationOp with "stashedState", which is a representation of un-ack'd local state.
+     */
+    async applyStashedIdAllocationOp(op) {
+        const { IdCompressor } = await import("./id-compressor");
+        this.idCompressor = IdCompressor.deserialize(op.stashedState);
+    }
+    async applyStashedOp(type, contents) {
         switch (type) {
             case ContainerMessageType.FluidDataStoreOp:
-                return this.dataStores.applyStashedOp(op);
+                return this.dataStores.applyStashedOp(contents);
             case ContainerMessageType.Attach:
-                return this.dataStores.applyStashedAttachOp(op);
+                return this.dataStores.applyStashedAttachOp(contents);
+            case ContainerMessageType.IdAllocation:
+                assert(this.idCompressor !== undefined, 0x67b /* IdCompressor should be defined if enabled */);
+                return this.applyStashedIdAllocationOp(contents);
             case ContainerMessageType.Alias:
             case ContainerMessageType.BlobAttach:
                 return;
@@ -991,6 +1047,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         // the beginning and end. This allows it to emit appropriate events and/or pause the processing of new
         // messages once a batch has been fully processed.
         this.scheduleManager.beforeOpProcessing(message);
+        this._processedClientSequenceNumber = message.clientSequenceNumber;
         try {
             let localOpMetadata;
             if (local && runtimeMessage && message.type !== ContainerMessageType.ChunkedOp) {
@@ -1015,6 +1072,10 @@ export class ContainerRuntime extends TypedEventEmitter {
                 case ContainerMessageType.BlobAttach:
                     this.blobManager.processBlobAttachOp(message, local);
                     break;
+                case ContainerMessageType.IdAllocation:
+                    assert(this.idCompressor !== undefined, 0x67c /* IdCompressor should be defined if enabled */);
+                    this.idCompressor.finalizeCreationRange(message.contents);
+                    break;
                 case ContainerMessageType.ChunkedOp:
                 case ContainerMessageType.Rejoin:
                     break;
@@ -1324,17 +1385,21 @@ export class ContainerRuntime extends TypedEventEmitter {
             fullGC,
             runSweep,
         });
-        let gcStats;
-        if (runGC) {
-            gcStats = await this.collectGarbage({ logger: summaryLogger, runSweep, fullGC }, telemetryContext);
+        try {
+            let gcStats;
+            if (runGC) {
+                gcStats = await this.collectGarbage({ logger: summaryLogger, runSweep, fullGC }, telemetryContext);
+            }
+            const { stats, summary } = await this.summarizerNode.summarize(fullTree, trackState, telemetryContext);
+            assert(summary.type === SummaryType.Tree, 0x12f /* "Container Runtime's summarize should always return a tree" */);
+            return { stats, summary, gcStats };
+        }
+        finally {
+            this.logger.sendTelemetryEvent({
+                eventName: "SummarizeTelemetry",
+                details: telemetryContext.serialize(),
+            });
         }
-        const { stats, summary } = await this.summarizerNode.summarize(fullTree, trackState, telemetryContext);
-        this.logger.sendTelemetryEvent({
-            eventName: "SummarizeTelemetry",
-            details: telemetryContext.serialize(),
-        });
-        assert(summary.type === SummaryType.Tree, 0x12f /* "Container Runtime's summarize should always return a tree" */);
-        return { stats, summary, gcStats };
     }
     /**
      * Before GC runs, called by the garbage collector to update any pending GC state. This is mainly used to notify
@@ -1721,6 +1786,35 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.verifyNotClosed();
         return this.blobManager.createBlob(blob);
     }
+    maybeSubmitIdAllocationOp(type) {
+        var _a, _b;
+        if (type !== ContainerMessageType.IdAllocation) {
+            let idAllocationBatchMessage;
+            let idRange;
+            if (this.idCompressorEnabled) {
+                assert(this.idCompressor !== undefined, 0x67d /* IdCompressor should be defined if enabled */);
+                idRange = this.idCompressor.takeNextCreationRange();
+                // Don't include the idRange if there weren't any Ids allocated
+                idRange = ((_a = idRange === null || idRange === void 0 ? void 0 : idRange.ids) === null || _a === void 0 ? void 0 : _a.first) !== undefined ? idRange : undefined;
+            }
+            if (idRange !== undefined) {
+                const idAllocationMessage = {
+                    type: ContainerMessageType.IdAllocation,
+                    contents: idRange,
+                };
+                idAllocationBatchMessage = {
+                    contents: JSON.stringify(idAllocationMessage),
+                    deserializedContent: idAllocationMessage,
+                    referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
+                    metadata: undefined,
+                    localOpMetadata: (_b = this.idCompressor) === null || _b === void 0 ? void 0 : _b.serialize(true),
+                };
+            }
+            if (idAllocationBatchMessage !== undefined) {
+                this.outbox.submit(idAllocationBatchMessage);
+            }
+        }
+    }
     submit(type, contents, localOpMetadata = undefined, metadata = undefined) {
         this.verifyNotClosed();
         this.verifyCanSubmitOps();
@@ -1743,6 +1837,11 @@ export class ContainerRuntime extends TypedEventEmitter {
             referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
         };
         try {
+            // Submit an IdAllocation op if any Ids have been generated since
+            // the last op was submitted. Don't submit another if it's an IdAllocation
+            // op as that means we're in resubmission flow and we don't want to send
+            // IdRanges out of order.
+            this.maybeSubmitIdAllocationOp(type);
             // If this is attach message for new data store, and we are in a batch, send this op out of order
             // Is it safe:
             //    Yes, this should be safe reordering. Newly created data stores are not visible through API surface.
@@ -1879,6 +1978,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 break;
             case ContainerMessageType.Attach:
             case ContainerMessageType.Alias:
+            case ContainerMessageType.IdAllocation:
                 this.submit(type, content, localOpMetadata);
                 break;
             case ContainerMessageType.ChunkedOp:
@@ -1928,6 +2028,19 @@ export class ContainerRuntime extends TypedEventEmitter {
                 ackHandle,
                 targetSequenceNumber: summaryRefSeq,
             }, readAndParseBlob);
+            /**
+             * back-compat - Older loaders and drivers (pre 2.0.0-internal.1.4) don't have fetchSource as a param in the
+             * getVersions API. So, they will not fetch the latest snapshot from network in the previous fetch call. For
+             * these scenarios, fetch the snapshot corresponding to the ack handle to have the same behavior before the
+             * change that started fetching latest snapshot always.
+             */
+            if (fetchResult.latestSnapshotRefSeq < summaryRefSeq) {
+                fetchResult = await this.fetchSnapshotFromStorage(summaryLogger, {
+                    eventName: "RefreshLatestSummaryAckFetchBackCompat",
+                    ackHandle,
+                    targetSequenceNumber: summaryRefSeq,
+                }, readAndParseBlob, ackHandle);
+            }
             /**
              * If the fetched snapshot is older than the one for which the ack was received, close the container.
              * This should never happen because an ack should be sent after the latest summary is updated in the server.
@@ -1939,21 +2052,13 @@ export class ContainerRuntime extends TypedEventEmitter {
              * state.
              */
             if (fetchResult.latestSnapshotRefSeq < summaryRefSeq) {
-                /* before failing, let's try to retrieve the latest snapshot for that specific ackHandle */
-                fetchResult = await this.fetchSnapshotFromStorage(summaryLogger, {
-                    eventName: "RefreshLatestSummaryAckFetch",
+                const error = DataProcessingError.create("Fetched snapshot is older than the received ack", "RefreshLatestSummaryAck", undefined /* sequencedMessage */, {
                     ackHandle,
-                    targetSequenceNumber: summaryRefSeq,
-                }, readAndParseBlob, ackHandle);
-                if (fetchResult.latestSnapshotRefSeq < summaryRefSeq) {
-                    const error = DataProcessingError.create("Fetched snapshot is older than the received ack", "RefreshLatestSummaryAck", undefined /* sequencedMessage */, {
-                        ackHandle,
-                        summaryRefSeq,
-                        fetchedSnapshotRefSeq: fetchResult.latestSnapshotRefSeq,
-                    });
-                    this.closeFn(error);
-                    throw error;
-                }
+                    summaryRefSeq,
+                    fetchedSnapshotRefSeq: fetchResult.latestSnapshotRefSeq,
+                });
+                this.closeFn(error);
+                throw error;
             }
             // In case we had to retrieve the latest snapshot and it is different than summaryRefSeq,
             // wait for the delta manager to catch up before refreshing the latest Summary.
@@ -1992,15 +2097,7 @@ export class ContainerRuntime extends TypedEventEmitter {
     }
     async fetchSnapshotFromStorage(logger, event, readAndParseBlob, versionId) {
         var _a;
-        const recoveryMethod = this.mc.config.getString("Fluid.ContainerRuntime.Test.SummarizationRecoveryMethod");
-        if (recoveryMethod === "restart") {
-            const error = new GenericError("Restarting summarizer instead of refreshing");
-            this.mc.logger.sendTelemetryEvent(Object.assign(Object.assign({}, event), { eventName: "ClosingSummarizerOnSummaryStale", codePath: event.eventName, message: "Stopping fetch from storage", versionId: versionId != null ? versionId : undefined }), error);
-            (_a = this._summarizer) === null || _a === void 0 ? void 0 : _a.stop("latestSummaryStateStale");
-            this.closeFn();
-            throw error;
-        }
-        return PerformanceEvent.timedExecAsync(logger, event, async (perfEvent) => {
+        const snapshotResults = await PerformanceEvent.timedExecAsync(logger, event, async (perfEvent) => {
             const stats = {};
             const trace = Trace.start();
             const versions = await this.storage.getVersions(versionId, 1, "refreshLatestSummaryAckFromServer", versionId === null ? FetchSource.noCache : undefined);
@@ -2019,6 +2116,19 @@ export class ContainerRuntime extends TypedEventEmitter {
                 latestSnapshotRefSeq,
             };
         });
+        // We choose to close the summarizer after the snapshot cache is updated to avoid
+        // situations which the main client (which is likely to be re-elected as the leader again)
+        // loads the summarizer from cache.
+        if (this.summaryStateUpdateMethod === "restart") {
+            const error = new GenericError("Restarting summarizer instead of refreshing");
+            this.mc.logger.sendTelemetryEvent(Object.assign(Object.assign({}, event), { eventName: "ClosingSummarizerOnSummaryStale", codePath: event.eventName, message: "Stopping fetch from storage", versionId: versionId != null ? versionId : undefined, closeSummarizerDelayMs: this.closeSummarizerDelayMs }), error);
+            // Delay 10 seconds before restarting summarizer to prevent the summarizer from restarting too frequently.
+            await delay(this.closeSummarizerDelayMs);
+            (_a = this._summarizer) === null || _a === void 0 ? void 0 : _a.stop("latestSummaryStateStale");
+            this.closeFn();
+            throw error;
+        }
+        return snapshotResults;
     }
     notifyAttaching() { } // do nothing (deprecated method)
     getPendingLocalState() {