@fluidframework/container-runtime 2.0.0-internal.2.2.1 → 2.0.0-internal.2.3.0

package/dist/containerRuntime.js

@@ -28,7 +28,6 @@ const summarizerClientElection_1 = require("./summarizerClientElection");
 const throttler_1 = require("./throttler");
 const runWhileConnectedCoordinator_1 = require("./runWhileConnectedCoordinator");
 const garbageCollection_1 = require("./garbageCollection");
-const garbageCollectionConstants_1 = require("./garbageCollectionConstants");
 const dataStore_1 = require("./dataStore");
 const batchTracker_1 = require("./batchTracker");
 const serializedSnapshotStorage_1 = require("./serializedSnapshotStorage");
@@ -218,12 +217,17 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         this.nextSummaryNumber = loadSummaryNumber + 1;
         this.messageAtLastSummary = metadata === null || metadata === void 0 ? void 0 : metadata.message;
         this._connected = this.context.connected;
-        this.remoteMessageProcessor = new opLifecycle_1.RemoteMessageProcessor(new opLifecycle_1.OpSplitter(chunks), new opLifecycle_1.OpDecompressor());
-        this.handleContext = new containerHandleContext_1.ContainerFluidHandleContext("", this);
         this.mc = (0, telemetry_utils_1.loggerToMonitoringContext)(telemetry_utils_1.ChildLogger.create(this.logger, "ContainerRuntime"));
+        const opSplitter = new opLifecycle_1.OpSplitter(chunks, this.context.submitBatchFn, this.mc.config.getBoolean("Fluid.ContainerRuntime.DisableCompressionChunking") === true ?
+            Number.POSITIVE_INFINITY : runtimeOptions.chunkSizeInBytes, runtimeOptions.maxBatchSizeInBytes, this.mc.logger);
+        this.remoteMessageProcessor = new opLifecycle_1.RemoteMessageProcessor(opSplitter, new opLifecycle_1.OpDecompressor());
+        this.handleContext = new containerHandleContext_1.ContainerFluidHandleContext("", this);
         if (this.summaryConfiguration.state === "enabled") {
             this.validateSummaryHeuristicConfiguration(this.summaryConfiguration);
         }
+        this.enableOpReentryCheck = runtimeOptions.enableOpReentryCheck === true
+            // Allow for a break-glass config to override the options
+            && this.mc.config.getBoolean("Fluid.ContainerRuntime.DisableOpReentryCheck") !== true;
         this.summariesDisabled = this.isSummariesDisabled();
         this.heuristicsDisabled = this.isHeuristicsDisabled();
         this.summarizerClientElectionEnabled = this.isSummarizerClientElectionEnabled();
@@ -272,16 +276,20 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             throwOnFailure: true,
             // If GC should not run, let the summarizer node know so that it does not track GC state.
             gcDisabled: !this.garbageCollector.shouldRunGC,
-        });
+        }, 
+        // Function to get GC data if needed. This will always be called by the root summarizer node to get GC data.
+        async (fullGC) => this.getGCDataInternal(fullGC), 
+        // Function to get the GC details from the base snapshot we loaded from.
+        async () => this.garbageCollector.getBaseGCDetails());
         if (baseSnapshot) {
             this.summarizerNode.updateBaseSummaryState(baseSnapshot);
         }
         this.dataStores = new dataStores_1.DataStores((0, dataStores_1.getSummaryForDatastores)(baseSnapshot, metadata), this, (attachMsg) => this.submit(ContainerMessageType.Attach, attachMsg), (id, createParam) => (summarizeInternal, getGCDataFn, getBaseGCDetailsFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, undefined, getGCDataFn, getBaseGCDetailsFn), (id) => this.summarizerNode.deleteChild(id), this.mc.logger, async () => this.garbageCollector.getBaseGCDetails(), (path, timestampMs, packagePath) => this.garbageCollector.nodeUpdated(path, "Changed", timestampMs, packagePath), new Map(dataStoreAliasMap));
-        this.blobManager = new blobManager_1.BlobManager(this.handleContext, blobManagerSnapshot, () => this.storage, (blobId, localId) => {
+        this.blobManager = new blobManager_1.BlobManager(this.handleContext, blobManagerSnapshot, () => this.storage, (localId, blobId) => {
             if (!this.disposed) {
-                this.submit(ContainerMessageType.BlobAttach, undefined, undefined, { blobId, localId });
+                this.submit(ContainerMessageType.BlobAttach, undefined, undefined, { localId, blobId });
             }
-        }, (blobPath) => this.garbageCollector.nodeUpdated(blobPath, "Loaded"), this, pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.pendingAttachmentBlobs);
+        }, (blobPath) => this.garbageCollector.nodeUpdated(blobPath, "Loaded"), (fromPath, toPath) => this.garbageCollector.addedOutboundReference(fromPath, toPath), this, pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.pendingAttachmentBlobs);
         this.scheduleManager = new scheduleManager_1.ScheduleManager(context.deltaManager, this, () => this.clientId, telemetry_utils_1.ChildLogger.create(this.logger, "ScheduleManager"));
         this.pendingStateManager = new pendingStateManager_1.PendingStateManager({
             applyStashedOp: this.applyStashedOp.bind(this),
@@ -293,15 +301,23 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             rollback: this.rollback.bind(this),
             orderSequentially: this.orderSequentially.bind(this),
         }, pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.pending);
+        const compressionOptions = this.mc.config.getBoolean("Fluid.ContainerRuntime.DisableCompression") === true ?
+            {
+                minimumBatchSizeInBytes: Number.POSITIVE_INFINITY,
+                compressionAlgorithm: CompressionAlgorithms.lz4
+            } : runtimeOptions.compressionOptions;
         this.outbox = new opLifecycle_1.Outbox({
             shouldSend: () => this.canSendOps(),
             pendingStateManager: this.pendingStateManager,
             containerContext: this.context,
             compressor: new opLifecycle_1.OpCompressor(this.mc.logger),
+            splitter: opSplitter,
             config: {
-                compressionOptions: runtimeOptions.compressionOptions,
+                compressionOptions,
                 maxBatchSizeInBytes: runtimeOptions.maxBatchSizeInBytes,
+                enableOpReentryCheck: this.enableOpReentryCheck,
             },
+            logger: this.mc.logger,
         });
         this.context.quorum.on("removeMember", (clientId) => {
             this.remoteMessageProcessor.clearPartialMessagesFor(clientId);
@@ -389,7 +405,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
      * allows mixin classes to leverage this method to define their own async initializer.
      */
     static async load(context, registryEntries, requestHandler, runtimeOptions = {}, containerScope = context.scope, existing, containerRuntimeCtor = ContainerRuntime) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         // 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
         const backCompatContext = context;
@@ -402,7 +418,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, enableOfflineLoad = false, compressionOptions = {
             minimumBatchSizeInBytes: Number.POSITIVE_INFINITY,
             compressionAlgorithm: CompressionAlgorithms.lz4
-        }, maxBatchSizeInBytes = defaultMaxBatchSizeInBytes, } = runtimeOptions;
+        }, maxBatchSizeInBytes = defaultMaxBatchSizeInBytes, chunkSizeInBytes = Number.POSITIVE_INFINITY, enableOpReentryCheck = false, } = runtimeOptions;
         const pendingRuntimeState = context.pendingLocalState;
         const baseSnapshot = (_b = pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.baseSnapshot) !== null && _b !== void 0 ? _b : context.baseSnapshot;
         const storage = !pendingRuntimeState ?
@@ -447,7 +463,9 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
                     logger.sendErrorEvent({ eventName: "SequenceNumberMismatch" }, error);
                 }
                 else {
+                    // Call both close and dispose as close implementation will no longer dispose runtime in future (2.0.0-internal.3.0.0)
                     context.closeFn(error);
+                    (_d = context.disposeFn) === null || _d === void 0 ? void 0 : _d.call(context, error);
                 }
             }
         }
@@ -459,6 +477,8 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             enableOfflineLoad,
             compressionOptions,
             maxBatchSizeInBytes,
+            chunkSizeInBytes,
+            enableOpReentryCheck,
         }, containerScope, logger, loadExisting, blobManagerSnapshot, storage, requestHandler);
         if (pendingRuntimeState) {
             await runtime.processSavedOps(pendingRuntimeState);
@@ -488,8 +508,18 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         // eslint-disable-next-line @typescript-eslint/unbound-method
         return this.reSubmit;
     }
+    get disposeFn() {
+        var _a;
+        // In old loaders without dispose functionality, closeFn is equivalent but will also switch container to readonly mode
+        return (_a = this.context.disposeFn) !== null && _a !== void 0 ? _a : this.context.closeFn;
+    }
     get closeFn() {
-        return this.context.closeFn;
+        // Also call disposeFn to retain functionality of runtime being disposed on close
+        return (error) => {
+            var _a, _b;
+            this.context.closeFn(error);
+            (_b = (_a = this.context).disposeFn) === null || _b === void 0 ? void 0 : _b.call(_a, error);
+        };
     }
     get flushMode() {
         return this._flushMode;
@@ -742,7 +772,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         }
         const gcSummary = this.garbageCollector.summarize(fullTree, trackState, telemetryContext);
         if (gcSummary !== undefined) {
-            (0, runtime_utils_1.addSummarizeResultToSummary)(summaryTree, garbageCollectionConstants_1.gcTreeKey, gcSummary);
+            (0, runtime_utils_1.addSummarizeResultToSummary)(summaryTree, runtime_definitions_1.gcTreeKey, gcSummary);
         }
     }
     // Track how many times the container tries to reconnect with pending messages.
@@ -867,9 +897,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         if (reconnection) {
             this.consecutiveReconnects++;
             if (!this.shouldContinueReconnecting()) {
-                this.closeFn(container_utils_1.DataProcessingError.create(
-                // eslint-disable-next-line max-len
-                "Runtime detected too many reconnects with no progress syncing local ops. Batch of ops is likely too large (over 1Mb)", "setConnectionState", undefined, {
+                this.closeFn(container_utils_1.DataProcessingError.create("Runtime detected too many reconnects with no progress syncing local ops. Batch of ops is likely too large (over 1Mb)", "setConnectionState", undefined, {
                     dataLoss: 1,
                     attempts: this.consecutiveReconnects,
                     pendingMessages: this.pendingStateManager.pendingMessagesCount,
@@ -903,7 +931,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         this.scheduleManager.beforeOpProcessing(message);
         try {
             let localOpMetadata;
-            if (local && runtimeMessage) {
+            if (local && runtimeMessage && message.type !== ContainerMessageType.ChunkedOp) {
                 localOpMetadata = this.pendingStateManager.processPendingLocalMessage(message);
             }
             // If there are no more pending messages after processing a local message,
@@ -1020,6 +1048,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
     }
     orderSequentially(callback) {
         let checkpoint;
+        let result;
         if (this.mc.config.getBoolean("Fluid.ContainerRuntime.EnableRollback")) {
             // Note: we are not touching this.pendingAttachBatch here, for two reasons:
             // 1. It would not help, as we flush attach ops as they become available.
@@ -1028,7 +1057,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         }
         try {
             this._orderSequentiallyCalls++;
-            callback();
+            result = callback();
         }
         catch (error) {
             if (checkpoint) {
@@ -1056,6 +1085,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         if (this.flushMode === runtime_definitions_1.FlushMode.Immediate && this._orderSequentiallyCalls === 0) {
             this.flush();
         }
+        return result;
     }
     async createDataStore(pkg) {
         const internalId = (0, uuid_1.v4)();
@@ -1221,6 +1251,9 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
     async updateStateBeforeGC() {
         return this.dataStores.updateStateBeforeGC();
     }
+    async getGCDataInternal(fullGC) {
+        return this.dataStores.getGCData(fullGC);
+    }
     /**
      * Implementation of IGarbageCollectionRuntime::getGCData.
      * Generates and returns the GC data for this container.
@@ -1228,7 +1261,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
      */
     async getGCData(fullGC) {
         const builder = new garbage_collector_1.GCDataBuilder();
-        const dsGCData = await this.dataStores.getGCData(fullGC);
+        const dsGCData = await this.summarizerNode.getGCData(fullGC);
         builder.addNodes(dsGCData.gcNodes);
         const blobsGCData = this.blobManager.getGCData(fullGC);
         builder.addNodes(blobsGCData.gcNodes);
@@ -1244,39 +1277,26 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         // summarizing is required and asserted by the the summarizer node. We are the root and are
         // always referenced, so the used routes is only self-route (empty string).
         this.summarizerNode.updateUsedRoutes([""]);
-        const blobManagerUsedRoutes = [];
-        const dataStoreUsedRoutes = [];
-        for (const route of usedRoutes) {
-            if (this.isBlobPath(route)) {
-                blobManagerUsedRoutes.push(route);
-            }
-            else {
-                dataStoreUsedRoutes.push(route);
-            }
-        }
-        this.blobManager.updateUsedRoutes(blobManagerUsedRoutes);
-        this.dataStores.updateUsedRoutes(dataStoreUsedRoutes);
+        const { dataStoreRoutes } = this.getDataStoreAndBlobManagerRoutes(usedRoutes);
+        this.dataStores.updateUsedRoutes(dataStoreRoutes);
     }
     /**
-     * This is called to update objects whose routes are unused. The unused objects are either deleted or marked as
-     * tombstones.
-     * @param unusedRoutes - The routes that are unused in all data stores and attachment blobs in this Container.
-     * @param tombstone - if true, the objects corresponding to unused routes are marked tombstones. Otherwise, they
-     * are deleted.
+     * This is called to update objects whose routes are unused.
+     * @param unusedRoutes - Data store and attachment blob routes that are unused in this Container.
      */
-    updateUnusedRoutes(unusedRoutes, tombstone) {
-        const blobManagerUnusedRoutes = [];
-        const dataStoreUnusedRoutes = [];
-        for (const route of unusedRoutes) {
-            if (this.isBlobPath(route)) {
-                blobManagerUnusedRoutes.push(route);
-            }
-            else {
-                dataStoreUnusedRoutes.push(route);
-            }
-        }
-        this.blobManager.updateUnusedRoutes(blobManagerUnusedRoutes, tombstone);
-        this.dataStores.updateUnusedRoutes(dataStoreUnusedRoutes, tombstone);
+    updateUnusedRoutes(unusedRoutes) {
+        const { blobManagerRoutes, dataStoreRoutes } = this.getDataStoreAndBlobManagerRoutes(unusedRoutes);
+        this.blobManager.updateUnusedRoutes(blobManagerRoutes);
+        this.dataStores.updateUnusedRoutes(dataStoreRoutes);
+    }
+    /**
+     * This is called to update objects that are tombstones.
+     * @param tombstonedRoutes - Data store and attachment blob routes that are tombstones in this Container.
+     */
+    updateTombstonedRoutes(tombstonedRoutes) {
+        const { blobManagerRoutes, dataStoreRoutes } = this.getDataStoreAndBlobManagerRoutes(tombstonedRoutes);
+        this.blobManager.updateTombstonedRoutes(blobManagerRoutes);
+        this.dataStores.updateTombstonedRoutes(dataStoreRoutes);
     }
     /**
      * Returns a server generated referenced timestamp to be used to track unreferenced nodes by GC.
@@ -1305,7 +1325,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
     async getGCNodePackagePath(nodePath) {
         switch (this.getNodeType(nodePath)) {
             case garbageCollection_1.GCNodeType.Blob:
-                return ["_blobs"];
+                return [blobManager_1.BlobManager.basePath];
             case garbageCollection_1.GCNodeType.DataStore:
             case garbageCollection_1.GCNodeType.SubDataStore:
                 return this.dataStores.getDataStorePackagePath(nodePath);
@@ -1323,6 +1343,25 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         }
         return true;
     }
+    /**
+     * From a given list of routes, separate and return routes that belong to blob manager and data stores.
+     * @param routes - A list of routes that can belong to data stores or blob manager.
+     * @returns - Two route lists - One that contains routes for blob manager and another one that contains routes
+     * for data stores.
+     */
+    getDataStoreAndBlobManagerRoutes(routes) {
+        const blobManagerRoutes = [];
+        const dataStoreRoutes = [];
+        for (const route of routes) {
+            if (this.isBlobPath(route)) {
+                blobManagerRoutes.push(route);
+            }
+            else {
+                dataStoreRoutes.push(route);
+            }
+        }
+        return { blobManagerRoutes, dataStoreRoutes };
+    }
     /**
      * Runs garbage collection and updates the reference / used state of the nodes in the container.
      * @returns the statistics of the garbage collection run; undefined if GC did not run.
@@ -1394,7 +1433,6 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
                 if (this.deltaManager.lastSequenceNumber !== summaryRefSeqNum) {
                     return {
                         continue: false,
-                        // eslint-disable-next-line max-len
                         error: `lastSequenceNumber changed before uploading to storage. ${this.deltaManager.lastSequenceNumber} !== ${summaryRefSeqNum}`,
                     };
                 }
@@ -1402,7 +1440,6 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
                 if (lastAck !== this.summaryCollection.latestAck) {
                     return {
                         continue: false,
-                        // eslint-disable-next-line max-len
                         error: `Last summary changed while summarizing. ${this.summaryCollection.latestAck} !== ${lastAck}`,
                     };
                 }
@@ -1447,8 +1484,8 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             const dataStoreTree = summaryTree.tree[runtime_definitions_1.channelsTreeName];
             (0, common_utils_1.assert)(dataStoreTree.type === protocol_definitions_1.SummaryType.Tree, 0x1fc /* "summary is not a tree" */);
             const handleCount = Object.values(dataStoreTree.tree).filter((value) => value.type === protocol_definitions_1.SummaryType.Handle).length;
-            const gcSummaryTreeStats = summaryTree.tree[garbageCollectionConstants_1.gcTreeKey]
-                ? (0, runtime_utils_1.calculateStats)(summaryTree.tree[garbageCollectionConstants_1.gcTreeKey])
+            const gcSummaryTreeStats = summaryTree.tree[runtime_definitions_1.gcTreeKey]
+                ? (0, runtime_utils_1.calculateStats)(summaryTree.tree[runtime_definitions_1.gcTreeKey])
                 : undefined;
             const summaryStats = Object.assign({ dataStoreCount: this.dataStores.size, summarizedDataStoreCount: this.dataStores.size - handleCount, gcStateUpdatedDataStoreCount: (_a = summarizeResult.gcStats) === null || _a === void 0 ? void 0 : _a.updatedDataStoreCount, gcBlobNodeCount: gcSummaryTreeStats === null || gcSummaryTreeStats === void 0 ? void 0 : gcSummaryTreeStats.blobNodeCount, gcTotalBlobsSize: gcSummaryTreeStats === null || gcSummaryTreeStats === void 0 ? void 0 : gcSummaryTreeStats.totalBlobSize, summaryNumber }, partialStats);
             const generateSummaryData = {
@@ -1617,7 +1654,6 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
             else if (!this.flushMicroTaskExists) {
                 this.flushMicroTaskExists = true;
                 // Queue a microtask to detect the end of the turn and force a flush.
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 Promise.resolve().then(() => {
                     this.flushMicroTaskExists = false;
                     this.flush();
@@ -1710,13 +1746,32 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         // It should only be done by the summarizerNode, if required.
         // When fetching from storage we will always get the latest version and do not use the ackHandle.
         const snapshotTreeFetcher = async () => {
-            const fetchResult = await this.fetchSnapshotFromStorage(null, summaryLogger, {
+            const fetchResult = await this.fetchLatestSnapshotFromStorage(summaryLogger, {
                 eventName: "RefreshLatestSummaryGetSnapshot",
                 ackHandle,
                 summaryRefSeq,
                 fetchLatest: true,
             });
             const latestSnapshotRefSeq = await (0, runtime_utils_1.seqFromTree)(fetchResult.snapshotTree, readAndParseBlob);
+            /**
+             * 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.
+             * However, there are couple of scenarios where it's possible:
+             * 1. A file was modified externally resulting in modifying the snapshot's sequence number. This can lead to
+             * the document being unusable and we should not proceed.
+             * 2. The server DB failed after the ack was sent which may delete the corresponding snapshot. Ideally, in
+             * such cases, the file will be rolled back along with the ack and we will eventually reach a consistent
+             * state.
+             */
+            if (latestSnapshotRefSeq < summaryRefSeq) {
+                const error = container_utils_1.DataProcessingError.create("Fetched snapshot is older than the received ack", "RefreshLatestSummaryAck", undefined /* sequencedMessage */, {
+                    ackHandle,
+                    summaryRefSeq,
+                    latestSnapshotRefSeq,
+                });
+                this.closeFn(error);
+                throw error;
+            }
             summaryLogger.sendTelemetryEvent({
                 eventName: "LatestSummaryRetrieved",
                 ackHandle,
@@ -1730,7 +1785,7 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
         };
         const result = await this.summarizerNode.refreshLatestSummary(proposalHandle, summaryRefSeq, snapshotTreeFetcher, readAndParseBlob, summaryLogger);
         // Notify the garbage collector so it can update its latest summary state.
-        await this.garbageCollector.latestSummaryStateRefreshed(result, readAndParseBlob);
+        await this.garbageCollector.refreshLatestSummary(result, proposalHandle, summaryRefSeq, readAndParseBlob);
     }
     /**
      * Fetches the latest snapshot from storage and uses it to refresh SummarizerNode's
@@ -1739,22 +1794,22 @@ class ContainerRuntime extends common_utils_1.TypedEventEmitter {
      * @returns downloaded snapshot's reference sequence number
      */
     async refreshLatestSummaryAckFromServer(summaryLogger) {
-        const { snapshotTree, versionId } = await this.fetchSnapshotFromStorage(null, summaryLogger, {
+        const { snapshotTree, versionId } = await this.fetchLatestSnapshotFromStorage(summaryLogger, {
             eventName: "RefreshLatestSummaryGetSnapshot",
             fetchLatest: true,
-        }, driver_definitions_1.FetchSource.noCache);
+        });
         const readAndParseBlob = async (id) => (0, driver_utils_1.readAndParse)(this.storage, id);
         const latestSnapshotRefSeq = await (0, runtime_utils_1.seqFromTree)(snapshotTree, readAndParseBlob);
         const result = await this.summarizerNode.refreshLatestSummary(undefined, latestSnapshotRefSeq, async () => snapshotTree, readAndParseBlob, summaryLogger);
         // Notify the garbage collector so it can update its latest summary state.
-        await this.garbageCollector.latestSummaryStateRefreshed(result, readAndParseBlob);
+        await this.garbageCollector.refreshLatestSummary(result, undefined, latestSnapshotRefSeq, readAndParseBlob);
         return { latestSnapshotRefSeq, latestSnapshotVersionId: versionId };
     }
-    async fetchSnapshotFromStorage(versionId, logger, event, fetchSource) {
+    async fetchLatestSnapshotFromStorage(logger, event) {
         return telemetry_utils_1.PerformanceEvent.timedExecAsync(logger, event, async (perfEvent) => {
             const stats = {};
             const trace = common_utils_1.Trace.start();
-            const versions = await this.storage.getVersions(versionId, 1, "refreshLatestSummaryAckFromServer", fetchSource);
+            const versions = await this.storage.getVersions(null, 1, "refreshLatestSummaryAckFromServer", driver_definitions_1.FetchSource.noCache);
             (0, common_utils_1.assert)(!!versions && !!versions[0], 0x137 /* "Failed to get version from storage" */);
             stats.getVersionDuration = trace.trace().duration;
             const maybeSnapshot = await this.storage.getSnapshotTree(versions[0]);
@@ -1871,6 +1926,7 @@ exports.ContainerRuntime = ContainerRuntime;
 const waitForSeq = async (deltaManager, targetSeq) => new Promise((resolve, reject) => {
     // TODO: remove cast to any when actual event is determined
     deltaManager.on("closed", reject);
+    deltaManager.on("disposed", reject);
     // If we already reached target sequence number, simply resolve the promise.
     if (deltaManager.lastSequenceNumber >= targetSeq) {
         resolve();