@fluidframework/container-runtime 2.0.0-internal.1.0.0.83139 → 2.0.0-internal.1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluidframework/container-runtime",
-  "version": "2.0.0-internal.1.0.0.83139",
+  "version": "2.0.0-internal.1.0.1",
   "description": "Fluid container runtime",
   "homepage": "https://fluidframework.com",
   "repository": {
@@ -62,30 +62,30 @@
   },
   "dependencies": {
     "@fluidframework/common-definitions": "^0.20.1",
-    "@fluidframework/common-utils": "^0.32.1",
-    "@fluidframework/container-definitions": "2.0.0-internal.1.0.0.83139",
-    "@fluidframework/container-runtime-definitions": "2.0.0-internal.1.0.0.83139",
-    "@fluidframework/container-utils": "2.0.0-internal.1.0.0.83139",
-    "@fluidframework/core-interfaces": "2.0.0-internal.1.0.0.83139",
-    "@fluidframework/datastore": "2.0.0-internal.1.0.0.83139",
-    "@fluidframework/driver-definitions": "2.0.0-internal.1.0.0.83139",
-    "@fluidframework/driver-utils": "2.0.0-internal.1.0.0.83139",
-    "@fluidframework/garbage-collector": "2.0.0-internal.1.0.0.83139",
-    "@fluidframework/protocol-base": "^0.1037.1000-0",
-    "@fluidframework/protocol-definitions": "^0.1029.1000-0",
-    "@fluidframework/runtime-definitions": "2.0.0-internal.1.0.0.83139",
-    "@fluidframework/runtime-utils": "2.0.0-internal.1.0.0.83139",
-    "@fluidframework/telemetry-utils": "2.0.0-internal.1.0.0.83139",
+    "@fluidframework/common-utils": "^1.0.0",
+    "@fluidframework/container-definitions": "^2.0.0-internal.1.0.1",
+    "@fluidframework/container-runtime-definitions": "^2.0.0-internal.1.0.1",
+    "@fluidframework/container-utils": "^2.0.0-internal.1.0.1",
+    "@fluidframework/core-interfaces": "^2.0.0-internal.1.0.1",
+    "@fluidframework/datastore": "^2.0.0-internal.1.0.1",
+    "@fluidframework/driver-definitions": "^2.0.0-internal.1.0.1",
+    "@fluidframework/driver-utils": "^2.0.0-internal.1.0.1",
+    "@fluidframework/garbage-collector": "^2.0.0-internal.1.0.1",
+    "@fluidframework/protocol-base": "^0.1037.1000",
+    "@fluidframework/protocol-definitions": "^1.0.0",
+    "@fluidframework/runtime-definitions": "^2.0.0-internal.1.0.1",
+    "@fluidframework/runtime-utils": "^2.0.0-internal.1.0.1",
+    "@fluidframework/telemetry-utils": "^2.0.0-internal.1.0.1",
     "double-ended-queue": "^2.1.0-0",
     "uuid": "^8.3.1"
   },
   "devDependencies": {
     "@fluidframework/build-common": "^0.24.0",
-    "@fluidframework/build-tools": "^0.3.0-0",
+    "@fluidframework/build-tools": "^0.3.1000",
     "@fluidframework/container-runtime-previous": "npm:@fluidframework/container-runtime@^1.0.0",
     "@fluidframework/eslint-config-fluid": "^0.28.2000",
-    "@fluidframework/mocha-test-setup": "2.0.0-internal.1.0.0.83139",
-    "@fluidframework/test-runtime-utils": "2.0.0-internal.1.0.0.83139",
+    "@fluidframework/mocha-test-setup": "^2.0.0-internal.1.0.1",
+    "@fluidframework/test-runtime-utils": "^2.0.0-internal.1.0.1",
     "@microsoft/api-extractor": "^7.22.2",
     "@rushstack/eslint-config": "^2.5.1",
     "@types/double-ended-queue": "^2.1.0",
@@ -130,6 +130,15 @@
       },
       "TypeAliasDeclaration_SubmitSummaryResult": {
         "backCompat": false
+      },
+      "ClassDeclaration_ContainerRuntime": {
+        "backCompat": false
+      },
+      "InterfaceDeclaration_IConnectableRuntime": {
+        "backCompat": false
+      },
+      "InterfaceDeclaration_ISummarizerRuntime": {
+        "backCompat": false
       }
     }
   }

package/src/batchTracker.ts

@@ -37,7 +37,7 @@ export class BatchTracker {
 
             const length = message.sequenceNumber - this.startBatchSequenceNumber + 1;
             if (length >= batchLengthThreshold) {
-                this.logger.sendErrorEvent({
+                this.logger.sendPerformanceEvent({
                     eventName: "LengthTooBig",
                     length,
                     threshold: batchLengthThreshold,

package/src/blobManager.ts

@@ -219,7 +219,7 @@ export class BlobManager {
         // For a detached container, entries are inserted into the redirect table with an undefined storage ID.
         // For an attached container, entries are inserted w/storage ID after the BlobAttach op round-trips.
         assert(!undefinedValueInTable || this.runtime.attachState === AttachState.Detached && ids.size === 0,
-            "'redirectTable' must contain only undefined while detached / defined values while attached");
+            0x382 /* 'redirectTable' must contain only undefined while detached / defined values while attached */);
 
         return ids as Set<string>;
     }
@@ -231,7 +231,7 @@ export class BlobManager {
         }
         let storageId;
         if (this.runtime.attachState === AttachState.Detached) {
-            assert(this.redirectTable.has(blobId), "requesting unknown blobs");
+            assert(this.redirectTable.has(blobId), 0x383 /* requesting unknown blobs */);
 
             // Blobs created while the container is detached are stored in IDetachedBlobStorage.
             // The 'IDocumentStorageService.readBlob()' call below will retrieve these via localId.
@@ -256,7 +256,7 @@ export class BlobManager {
 
     private getBlobHandle(id: string): IFluidHandle<ArrayBufferLike> {
         assert(this.redirectTable.has(id) || this.pendingBlobs.has(id),
-            "requesting handle for unknown blob");
+            0x384 /* requesting handle for unknown blob */);
         return new BlobHandle(
             `${BlobManager.basePath}/${id}`,
             this.routeContext,
@@ -282,7 +282,7 @@ export class BlobManager {
             await new Promise<void>((resolve) => this.runtime.once("attached", resolve));
         }
         assert(this.runtime.attachState === AttachState.Attached,
-            "For clarity and paranoid defense against adding future attachment states");
+            0x385 /* For clarity and paranoid defense against adding future attachment states */);
 
         // Create a local ID for each blob. This is used to support blobs if/when the client goes
         // offline since we don't have the ID from storage yet. If online flow succeeds this won't be used.
@@ -314,7 +314,7 @@ export class BlobManager {
         const entry = this.pendingBlobs.get(localId);
         assert(entry?.status === PendingBlobStatus.OnlinePendingUpload ||
             entry?.status === PendingBlobStatus.OfflinePendingUpload,
-            "Must have pending blob entry for uploaded blob");
+            0x386 /* Must have pending blob entry for uploaded blob */);
         entry.storageId = response.id;
         if (this.runtime.connected) {
             if (entry.status === PendingBlobStatus.OnlinePendingUpload) {
@@ -348,7 +348,7 @@ export class BlobManager {
 
     private async onUploadReject(localId: string, error) {
         const entry = this.pendingBlobs.get(localId);
-        assert(!!entry, "Must have pending blob entry for blob which failed to upload");
+        assert(!!entry, 0x387 /* Must have pending blob entry for blob which failed to upload */);
         if (!this.runtime.connected) {
             if (entry.status === PendingBlobStatus.OnlinePendingUpload) {
                 this.transitionToOffline(localId);
@@ -363,11 +363,11 @@ export class BlobManager {
     }
 
     private transitionToOffline(localId: string) {
-        assert(!this.runtime.connected, "Must only transition to offline flow while runtime is disconnected");
+        assert(!this.runtime.connected, 0x388 /* Must only transition to offline flow while runtime is disconnected */);
         const entry = this.pendingBlobs.get(localId);
-        assert(!!entry, "No pending blob entry");
+        assert(!!entry, 0x389 /* No pending blob entry */);
         assert([PendingBlobStatus.OnlinePendingUpload, PendingBlobStatus.OnlinePendingOp].includes(entry.status),
-            "Blob must be in online flow to transition to offline flow");
+            0x38a /* Blob must be in online flow to transition to offline flow */);
 
         entry.status = entry.status === PendingBlobStatus.OnlinePendingUpload
             ? PendingBlobStatus.OfflinePendingUpload
@@ -388,14 +388,14 @@ export class BlobManager {
      * @param metadata - op metadata containing storage and/or local IDs
      */
     public reSubmit(metadata: Record<string, unknown> | undefined) {
-        assert(!!metadata, "Resubmitted ops must have metadata");
+        assert(!!metadata, 0x38b /* Resubmitted ops must have metadata */);
         const { blobId, localId }: { blobId?: string; localId?: string; } = metadata;
         if (!blobId) {
-            assert(!!localId, "Submitted BlobAttach ops must have a blobId or localId");
+            assert(!!localId, 0x38c /* Submitted BlobAttach ops must have a blobId or localId */);
             // We submitted this op while offline. The blob should have been uploaded by now.
             const pendingEntry = this.pendingBlobs.get(localId);
             assert(pendingEntry?.status === PendingBlobStatus.OfflinePendingOp &&
-                !!pendingEntry?.storageId, "blob must be uploaded before resubmitting BlobAttach op");
+                !!pendingEntry?.storageId, 0x38d /* blob must be uploaded before resubmitting BlobAttach op */);
             return this.sendBlobAttachOp(pendingEntry.storageId, localId);
         }
         return this.sendBlobAttachOp(blobId, localId);
@@ -413,10 +413,13 @@ export class BlobManager {
             if (message.metadata.localId === undefined) {
                 // Since there is no local ID, we know this op was submitted while online.
                 const waitingBlobs = this.opsInFlight.get(message.metadata.blobId);
-                assert(!!waitingBlobs, "local online BlobAttach op with no pending blob");
+                assert(!!waitingBlobs, 0x38e /* local online BlobAttach op with no pending blob */);
                 waitingBlobs.forEach((localId) => {
                     const pendingBlobEntry = this.pendingBlobs.get(localId);
-                    assert(pendingBlobEntry !== undefined, "local online BlobAttach op with no pending blob entry");
+                    assert(
+                        pendingBlobEntry !== undefined,
+                        0x38f, /* local online BlobAttach op with no pending blob entry */
+                    );
 
                     // It's possible we transitioned to offline flow while waiting for this op.
                     if (pendingBlobEntry.status === PendingBlobStatus.OnlinePendingOp) {
@@ -497,7 +500,7 @@ export class BlobManager {
         // Note that because of de-duping, there can be multiple localIds that all redirect to the same storageId or
         // a blob may be referenced via its storageId handle.
         for (const [localId, storageId] of this.redirectTable) {
-            assert(!!storageId, "Must be attached to get GC data");
+            assert(!!storageId, 0x390 /* Must be attached to get GC data */);
             // Add node for the localId and add a route to the storageId node. The storageId node will have been
             // added above when adding nodes for this.blobIds.
             gcData.gcNodes[this.getBlobGCNodePath(localId)] = [this.getBlobGCNodePath(storageId)];
@@ -554,7 +557,8 @@ export class BlobManager {
     public setRedirectTable(table: Map<string, string>) {
         assert(this.runtime.attachState === AttachState.Detached,
             0x252 /* "redirect table can only be set in detached container" */);
-        assert(this.redirectTable.size === table.size, "Redirect table size must match BlobManager's local ID count");
+        assert(this.redirectTable.size === table.size,
+            0x391 /* Redirect table size must match BlobManager's local ID count */);
         for (const [localId, storageId] of table) {
             assert(this.redirectTable.has(localId), 0x254 /* "unrecognized id in redirect table" */);
             this.redirectTable.set(localId, storageId);

package/src/containerRuntime.ts

@@ -425,12 +425,6 @@ export interface IContainerRuntimeOptions {
      * 3. "bypass" will skip the check entirely. This is not recommended.
      */
     readonly loadSequenceNumberVerification?: "close" | "log" | "bypass";
-    /**
-     * Should the runtime use data store aliasing for creating root datastores.
-     * In case of aliasing conflicts, the runtime will raise an exception which does
-     * not effect the status of the container.
-     */
-    readonly useDataStoreAliasing?: boolean;
     /**
      * Sets the flush mode for the runtime. In Immediate flush mode the runtime will immediately
      * send all operations to the driver layer, while in TurnBased the operations will be buffered
@@ -509,7 +503,6 @@ export interface IPendingRuntimeState {
     savedOps: ISequencedDocumentMessage[];
 }
 
-const useDataStoreAliasingKey = "Fluid.ContainerRuntime.UseDataStoreAliasing";
 const maxConsecutiveReconnectsKey = "Fluid.ContainerRuntime.MaxConsecutiveReconnects";
 
 // Feature gate for the max op size. If the value is negative, chunking is enabled
@@ -903,7 +896,6 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             summaryOptions = {},
             gcOptions = {},
             loadSequenceNumberVerification = "close",
-            useDataStoreAliasing = false,
             flushMode = defaultFlushMode,
             enableOfflineLoad = false,
         } = runtimeOptions;
@@ -979,7 +971,6 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
                 summaryOptions,
                 gcOptions,
                 loadSequenceNumberVerification,
-                useDataStoreAliasing,
                 flushMode,
                 enableOfflineLoad,
             },
@@ -1069,7 +1060,6 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
     private readonly summaryCollection: SummaryCollection;
 
     private readonly summarizerNode: IRootSummarizerNodeWithGC;
-    private readonly _aliasingEnabled: boolean;
     private readonly _maxOpSizeInBytes: number;
 
     private readonly maxConsecutiveReconnects: number;
@@ -1263,10 +1253,6 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         this.maxOpsSinceLastSummary = this.getMaxOpsSinceLastSummary();
         this.initialSummarizerDelayMs = this.getInitialSummarizerDelayMs();
 
-        this._aliasingEnabled =
-            (this.mc.config.getBoolean(useDataStoreAliasingKey) ?? false) ||
-            (runtimeOptions.useDataStoreAliasing ?? false);
-
         this._maxOpSizeInBytes = (this.mc.config.getNumber(maxOpSizeInBytesKey) ?? defaultMaxOpSizeInBytes);
         this.maxConsecutiveReconnects =
             this.mc.config.getNumber(maxConsecutiveReconnectsKey) ?? this.defaultMaxConsecutiveReconnects;
@@ -1829,8 +1815,9 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         // ensure we don't submit ops referencing a blob that has not been uploaded
         const connecting = connected && !this._connected && !this.deltaManager.readOnlyInfo.readonly;
         if (connecting && this.blobManager.hasPendingOfflineUploads) {
-            assert(!this.delayConnectClientId, "Connect event delay must be canceled before subsequent connect event");
-            assert(!!clientId, "Must have clientId when connecting");
+            assert(!this.delayConnectClientId,
+                0x392 /* Connect event delay must be canceled before subsequent connect event */);
+            assert(!!clientId, 0x393 /* Must have clientId when connecting */);
             this.delayConnectClientId = clientId;
             this.blobManager.onConnected().then(() => {
                 // make sure we didn't reconnect before the promise resolved
@@ -1846,7 +1833,8 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
     }
 
     private setConnectionStateCore(connected: boolean, clientId?: string) {
-        assert(!this.delayConnectClientId, "connect event delay must be cleared before propagating connect event");
+        assert(!this.delayConnectClientId,
+            0x394 /* connect event delay must be cleared before propagating connect event */);
         this.verifyNotClosed();
 
         // There might be no change of state due to Container calling this API after loading runtime.
@@ -1870,11 +1858,11 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
                         "Runtime detected too many reconnects with no progress syncing local ops",
                         "setConnectionState",
                         undefined,
-                       {
-                        dataLoss: 1,
-                        attempts: this.consecutiveReconnects,
-                        pendingMessages: this.pendingStateManager.pendingMessagesCount,
-                    }));
+                        {
+                            dataLoss: 1,
+                            attempts: this.consecutiveReconnects,
+                            pendingMessages: this.pendingStateManager.pendingMessagesCount,
+                        }));
                 return;
             }
         }
@@ -2137,83 +2125,13 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
     public async createDataStore(pkg: string | string[]): Promise<IDataStore> {
         const internalId = uuid();
         return channelToDataStore(
-            await this._createDataStore(pkg, false /* isRoot */, internalId),
+            await this._createDataStore(pkg, internalId),
             internalId,
             this,
             this.dataStores,
             this.mc.logger);
     }
 
-    /**
-     * Creates a root datastore directly with a user generated id and attaches it to storage.
-     * It is vulnerable to name collisions and should not be used.
-     *
-     * This method will be removed. See #6465.
-     */
-    private async createRootDataStoreLegacy(pkg: string | string[], rootDataStoreId: string): Promise<IFluidRouter> {
-        const fluidDataStore = await this._createDataStore(pkg, true /* isRoot */, rootDataStoreId);
-        fluidDataStore.makeVisibleAndAttachGraph();
-        return fluidDataStore;
-    }
-
-    /**
-     * @deprecated - will be removed in an upcoming release. See #9660.
-     */
-    public async createRootDataStore(pkg: string | string[], rootDataStoreId: string): Promise<IFluidRouter> {
-        if (rootDataStoreId.includes("/")) {
-            throw new UsageError(`Id cannot contain slashes: '${rootDataStoreId}'`);
-        }
-        return this._aliasingEnabled === true ?
-            this.createAndAliasDataStore(pkg, rootDataStoreId) :
-            this.createRootDataStoreLegacy(pkg, rootDataStoreId);
-    }
-
-    /**
-     * Creates a data store then attempts to alias it.
-     * If aliasing fails, it will raise an exception.
-     *
-     * This method will be removed. See #6465.
-     *
-     * @param pkg - Package name of the data store
-     * @param alias - Alias to be assigned to the data store
-     * @param props - Properties for the data store
-     * @returns - An aliased data store which can can be found / loaded by alias.
-     */
-    private async createAndAliasDataStore(pkg: string | string[], alias: string, props?: any): Promise<IDataStore> {
-        const internalId = uuid();
-
-        try {
-            // A similar call may have been initiated by the same client, so we should try to get
-            // a possible existing aliased datastore first.
-            const existingDataStore = await this.getRootDataStoreChannel(alias, /* wait */ false);
-            return channelToDataStore(
-                existingDataStore,
-                internalId,
-                this,
-                this.dataStores,
-                this.mc.logger,
-                true, // AlreadyAliased. This will block further alias attempts for the datastore
-            );
-        } catch (err) {
-            const newChannel = await this._createDataStore(pkg, false /* isRoot */, internalId, props);
-            const newDataStore = channelToDataStore(newChannel, internalId, this, this.dataStores, this.mc.logger);
-            const aliasResult = await newDataStore.trySetAlias(alias);
-            if (aliasResult === "Success") {
-                return newDataStore;
-            }
-
-            const existingDataStore = await this.getRootDataStoreChannel(alias, /* wait */ false);
-            return channelToDataStore(
-                existingDataStore,
-                internalId,
-                this,
-                this.dataStores,
-                this.mc.logger,
-                true, // AlreadyAliased. This will block further alias attempts for the datastore
-            );
-        }
-    }
-
     public createDetachedRootDataStore(
         pkg: Readonly<string[]>,
         rootDataStoreId: string): IFluidDataStoreContextDetached {
@@ -2227,49 +2145,23 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         return this.dataStores.createDetachedDataStoreCore(pkg, false);
     }
 
-    /**
-     * Creates a possibly root datastore directly with a possibly user generated id and attaches it to storage.
-     * It is vulnerable to name collisions if both aforementioned conditions are true, and should not be used.
-     *
-     * This method will be removed. See #6465.
-     */
-    private async _createDataStoreWithPropsLegacy(
+    public async _createDataStoreWithProps(
         pkg: string | string[],
         props?: any,
         id = uuid(),
-        isRoot = false,
     ): Promise<IDataStore> {
         const fluidDataStore = await this.dataStores._createFluidDataStoreContext(
-            Array.isArray(pkg) ? pkg : [pkg], id, isRoot, props).realize();
-        if (isRoot) {
-            fluidDataStore.makeVisibleAndAttachGraph();
-            this.logger.sendTelemetryEvent({
-                eventName: "Root datastore with props",
-                hasProps: props !== undefined,
-            });
-        }
+            Array.isArray(pkg) ? pkg : [pkg], id, props).realize();
         return channelToDataStore(fluidDataStore, id, this, this.dataStores, this.mc.logger);
     }
 
-    public async _createDataStoreWithProps(
-        pkg: string | string[],
-        props?: any,
-        id = uuid(),
-        isRoot = false,
-    ): Promise<IDataStore> {
-        return this._aliasingEnabled === true && isRoot ?
-            this.createAndAliasDataStore(pkg, id, props) :
-            this._createDataStoreWithPropsLegacy(pkg, props, id, isRoot);
-    }
-
     private async _createDataStore(
         pkg: string | string[],
-        isRoot: boolean,
         id = uuid(),
         props?: any,
     ): Promise<IFluidDataStoreChannel> {
         return this.dataStores
-            ._createFluidDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], id, isRoot, props)
+            ._createFluidDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], id, props)
             .realize();
     }
 
@@ -2626,21 +2518,24 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             },
         );
 
+        let latestSnapshotVersionId: string | undefined;
         if (refreshLatestAck) {
-            const latestSummaryRefSeq = await this.refreshLatestSummaryAckFromServer(
+            const latestSnapshotInfo = await this.refreshLatestSummaryAckFromServer(
                 ChildLogger.create(summaryNumberLogger, undefined, { all: { safeSummary: true } }));
+            const latestSnapshotRefSeq = latestSnapshotInfo.latestSnapshotRefSeq;
+            latestSnapshotVersionId = latestSnapshotInfo.latestSnapshotVersionId;
 
-            if (latestSummaryRefSeq > this.deltaManager.lastSequenceNumber) {
+            if (latestSnapshotRefSeq > this.deltaManager.lastSequenceNumber) {
                 // We need to catch up to the latest summary's reference sequence number before pausing.
                 await PerformanceEvent.timedExecAsync(
                     summaryNumberLogger,
                     {
                         eventName: "WaitingForSeq",
                         lastSequenceNumber: this.deltaManager.lastSequenceNumber,
-                        targetSequenceNumber: latestSummaryRefSeq,
+                        targetSequenceNumber: latestSnapshotRefSeq,
                         lastKnownSeqNumber: this.deltaManager.lastKnownSeqNumber,
                     },
-                    async () => waitForSeq(this.deltaManager, latestSummaryRefSeq),
+                    async () => waitForSeq(this.deltaManager, latestSnapshotRefSeq),
                     { start: true, end: true, cancel: "error" }, // definitely want start event
                 );
             }
@@ -2683,7 +2578,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
                     };
                 }
                 assert(summaryRefSeqNum === this.deltaManager.lastMessage?.sequenceNumber,
-                    "it's one and the same thing");
+                    0x395 /* it's one and the same thing */);
 
                 if (lastAck !== this.summaryCollection.latestAck) {
                     return {
@@ -2765,18 +2660,32 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
                 return { stage: "generate", ...generateSummaryData, error: continueResult.error };
             }
 
-            const summaryContext: ISummaryContext =
-                lastAck === undefined
-                    ? {
-                        proposalHandle: undefined,
-                        ackHandle: this.context.getLoadedFromVersion()?.id,
-                        referenceSequenceNumber: summaryRefSeqNum,
-                    }
-                    : {
-                        proposalHandle: lastAck.summaryOp.contents.handle,
-                        ackHandle: lastAck.summaryAck.contents.handle,
-                        referenceSequenceNumber: summaryRefSeqNum,
-                    };
+            // It may happen that the lastAck it not correct due to missing summaryAck in case of single commit
+            // summary. So if the previous summarizer closes just after submitting the summary and before
+            // submitting the summaryOp then we can't rely on summaryAck. So in case we have
+            // latestSnapshotVersionId from storage and it does not match with the lastAck ackHandle, then use
+            // the one fetched from storage as parent as that is the latest.
+            let summaryContext: ISummaryContext;
+            if (lastAck?.summaryAck.contents.handle !== latestSnapshotVersionId
+                && latestSnapshotVersionId !== undefined) {
+                summaryContext = {
+                    proposalHandle: undefined,
+                    ackHandle: latestSnapshotVersionId,
+                    referenceSequenceNumber: summaryRefSeqNum,
+                };
+            } else if (lastAck === undefined) {
+                summaryContext = {
+                    proposalHandle: undefined,
+                    ackHandle: this.context.getLoadedFromVersion()?.id,
+                    referenceSequenceNumber: summaryRefSeqNum,
+                };
+            } else {
+                summaryContext = {
+                    proposalHandle: lastAck.summaryOp.contents.handle,
+                    ackHandle: lastAck.summaryAck.contents.handle,
+                    referenceSequenceNumber: summaryRefSeqNum,
+                };
+            }
 
             let handle: string;
             try {
@@ -3123,20 +3032,29 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         summaryLogger: ITelemetryLogger,
     ) {
         const readAndParseBlob = async <T>(id: string) => readAndParse<T>(this.storage, id);
-        const result = await this.summarizerNode.refreshLatestSummary(
-            proposalHandle,
-            summaryRefSeq,
-            async () => this.fetchSnapshotFromStorage(ackHandle, summaryLogger, {
-                eventName: "RefreshLatestSummaryGetSnapshot",
-                ackHandle,
-                summaryRefSeq,
-                fetchLatest: false,
-            }),
-            readAndParseBlob,
-            summaryLogger,
-        );
-
-        // Notify the garbage collector so it can update its latest summary state.
+        // The call to fetch the snapshot is very expensive and not always needed.
+        // It should only be done by the summarizerNode, if required.
+        const snapshotTreeFetcher = async () => {
+            const fetchResult = await this.fetchSnapshotFromStorage(
+             ackHandle,
+             summaryLogger,
+             {
+                 eventName: "RefreshLatestSummaryGetSnapshot",
+                 ackHandle,
+                 summaryRefSeq,
+                 fetchLatest: false,
+             });
+             return fetchResult.snapshotTree;
+         };
+         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);
     }
 
@@ -3146,21 +3064,23 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
      * @param summaryLogger - logger to use when fetching snapshot from storage
      * @returns downloaded snapshot's reference sequence number
      */
-    private async refreshLatestSummaryAckFromServer(summaryLogger: ITelemetryLogger): Promise<number> {
-        const snapshot = await this.fetchSnapshotFromStorage(null, summaryLogger, {
-                eventName: "RefreshLatestSummaryGetSnapshot",
-                fetchLatest: true,
-            },
+    private async refreshLatestSummaryAckFromServer(
+        summaryLogger: ITelemetryLogger,
+    ): Promise<{ latestSnapshotRefSeq: number; latestSnapshotVersionId: string | undefined; }> {
+        const { snapshotTree, versionId } = await this.fetchSnapshotFromStorage(null, summaryLogger, {
+            eventName: "RefreshLatestSummaryGetSnapshot",
+            fetchLatest: true,
+        },
             FetchSource.noCache,
         );
 
         const readAndParseBlob = async <T>(id: string) => readAndParse<T>(this.storage, id);
-        const snapshotRefSeq = await seqFromTree(snapshot, readAndParseBlob);
+        const latestSnapshotRefSeq = await seqFromTree(snapshotTree, readAndParseBlob);
 
         const result = await this.summarizerNode.refreshLatestSummary(
             undefined,
-            snapshotRefSeq,
-            async () => snapshot,
+            latestSnapshotRefSeq,
+            async () => snapshotTree,
             readAndParseBlob,
             summaryLogger,
         );
@@ -3168,7 +3088,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         // Notify the garbage collector so it can update its latest summary state.
         await this.garbageCollector.latestSummaryStateRefreshed(result, readAndParseBlob);
 
-        return snapshotRefSeq;
+        return { latestSnapshotRefSeq, latestSnapshotVersionId: versionId };
     }
 
     private async fetchSnapshotFromStorage(
@@ -3176,7 +3096,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         logger: ITelemetryLogger,
         event: ITelemetryGenericEvent,
         fetchSource?: FetchSource,
-    ) {
+    ): Promise<{ snapshotTree: ISnapshotTree; versionId: string; }> {
         return PerformanceEvent.timedExecAsync(
             logger, event, async (perfEvent: {
                 end: (arg0: {
@@ -3197,7 +3117,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             stats.getSnapshotDuration = trace.trace().duration;
 
             perfEvent.end(stats);
-            return maybeSnapshot;
+            return { snapshotTree: maybeSnapshot, versionId: versions[0].id };
         });
     }
 

package/src/dataStore.ts

@@ -43,8 +43,7 @@ export const channelToDataStore = (
     runtime: ContainerRuntime,
     datastores: DataStores,
     logger: ITelemetryLogger,
-    alreadyAliased: boolean = false,
-): IDataStore => new DataStore(fluidDataStoreChannel, internalId, runtime, datastores, logger, alreadyAliased);
+): IDataStore => new DataStore(fluidDataStoreChannel, internalId, runtime, datastores, logger);
 
 enum AliasState {
     Aliased = "Aliased",
@@ -158,10 +157,8 @@ class DataStore implements IDataStore {
         private readonly runtime: ContainerRuntime,
         private readonly datastores: DataStores,
         private readonly logger: ITelemetryLogger,
-        alreadyAliased: boolean,
     ) {
         this.pendingAliases = datastores.pendingAliases;
-        this.aliasState = alreadyAliased ? AliasState.Aliased : AliasState.None;
     }
 
     public get IFluidRouter() { return this.fluidDataStoreChannel; }