@fluidframework/container-loader 2.0.0-dev-rc.1.0.0.228517 → 2.0.0-dev-rc.1.0.0.232845

package/src/container.ts

@@ -10,9 +10,9 @@ import {
 	IEvent,
 	ITelemetryProperties,
 	TelemetryEventCategory,
-	IRequest,
 	FluidObject,
 	LogLevel,
+	IRequest,
 } from "@fluidframework/core-interfaces";
 import {
 	AttachState,
@@ -41,6 +41,7 @@ import {
 	IDocumentServiceFactory,
 	IDocumentStorageService,
 	IResolvedUrl,
+	ISnapshot,
 	IThrottlingWarning,
 	IUrlResolver,
 } from "@fluidframework/driver-definitions";
@@ -48,9 +49,10 @@ import {
 	readAndParse,
 	OnlineStatus,
 	isOnline,
-	runWithRetry,
 	isCombinedAppAndProtocolSummary,
 	MessageType2,
+	isInstanceOfISnapshot,
+	runWithRetry,
 } from "@fluidframework/driver-utils";
 import { IQuorumSnapshot } from "@fluidframework/protocol-base";
 import {
@@ -86,7 +88,9 @@ import {
 	formatTick,
 	GenericError,
 	UsageError,
+	IFluidErrorBase,
 } from "@fluidframework/telemetry-utils";
+import structuredClone from "@ungap/structured-clone";
 import { Audience } from "./audience";
 import { ContainerContext } from "./containerContext";
 import {
@@ -102,14 +106,17 @@ import { pkgVersion } from "./packageVersion";
 import {
 	ContainerStorageAdapter,
 	getBlobContentsFromTree,
-	getBlobContentsFromTreeWithBlobContents,
 	ISerializableBlobContents,
 } from "./containerStorageAdapter";
 import { IConnectionStateHandler, createConnectionStateHandler } from "./connectionStateHandler";
 import {
+	ISnapshotTreeWithBlobContents,
 	combineAppAndProtocolSummary,
 	getProtocolSnapshotTree,
-	getSnapshotTreeFromSerializedContainer,
+	getSnapshotTreeAndBlobsFromSerializedContainer,
+	combineSnapshotTreeAndSnapshotBlobs,
+	getDetachedContainerStateFromSerializedContainer,
+	runSingle,
 } from "./utils";
 import { initQuorumValuesFromCodeDetails } from "./quorum";
 import { NoopHeuristic } from "./noopHeuristic";
@@ -121,6 +128,7 @@ import {
 	ProtocolHandlerBuilder,
 	protocolHandlerShouldProcessSignal,
 } from "./protocol";
+import { AttachProcessProps, AttachmentData, runRetriableAttachProcess } from "./attachment";
 
 const detachedContainerRefSeqNumber = 0;
 
@@ -129,8 +137,6 @@ const savedContainerEvent = "saved";
 
 const packageNotFactoryError = "Code package does not implement IRuntimeFactory";
 
-const hasBlobsSummaryTree = ".hasAttachmentBlobs";
-
 /**
  * @internal
  */
@@ -360,6 +366,18 @@ export interface IPendingContainerState {
 	clientId?: string;
 }
 
+/**
+ * State saved by a container in detached state, to be used to load a new instance
+ * of the container to the same state (rehydrate)
+ * @internal
+ */
+export interface IPendingDetachedContainerState {
+	attached: boolean;
+	baseSnapshot: ISnapshotTree;
+	snapshotBlobs: ISerializableBlobContents;
+	hasAttachmentBlobs: boolean;
+}
+
 const summarizerClientType = "summarizer";
 
 interface IContainerLifecycleEvents extends IEvent {
@@ -471,12 +489,9 @@ export class Container
 			container.mc.logger,
 			{ eventName: "RehydrateDetachedFromSnapshot" },
 			async (_event) => {
-				const deserializedSummary = JSON.parse(snapshot);
-				if (!isCombinedAppAndProtocolSummary(deserializedSummary, hasBlobsSummaryTree)) {
-					throw new UsageError("Cannot rehydrate detached container. Incorrect format");
-				}
-
-				await container.rehydrateDetachedFromSnapshot(deserializedSummary);
+				const detachedContainerState: IPendingDetachedContainerState =
+					getDetachedContainerStateFromSerializedContainer(snapshot);
+				await container.rehydrateDetachedFromSnapshot(detachedContainerState);
 				return container;
 			},
 			{ start: true, end: true, cancel: "generic" },
@@ -551,8 +566,6 @@ export class Container
 		return this._lifecycleState === "disposing" || this._lifecycleState === "disposed";
 	}
 
-	private _attachState = AttachState.Detached;
-
 	private readonly storageAdapter: ContainerStorageAdapter;
 
 	private readonly _deltaManager: DeltaManager<ConnectionManager>;
@@ -578,17 +591,16 @@ export class Container
 	private firstConnection = true;
 	private readonly connectionTransitionTimes: number[] = [];
 	private _loadedFromVersion: IVersion | undefined;
-	private attachStarted = false;
 	private _dirtyContainer = false;
 	private readonly savedOps: ISequencedDocumentMessage[] = [];
-	private baseSnapshot?: ISnapshotTree;
-	private baseSnapshotBlobs?: ISerializableBlobContents;
+	private attachmentData: AttachmentData = { state: AttachState.Detached };
 	private readonly _containerId: string;
 
 	private lastVisible: number | undefined;
 	private readonly visibilityEventHandler: (() => void) | undefined;
 	private readonly connectionStateHandler: IConnectionStateHandler;
 	private readonly clientsWhoShouldHaveLeft = new Set<string>();
+	private _containerMetadata: Readonly<Record<string, string>> = {};
 
 	private setAutoReconnectTime = performance.now();
 
@@ -617,6 +629,10 @@ export class Container
 		return this._deltaManager.readOnlyInfo;
 	}
 
+	public get containerMetadata(): Record<string, string> {
+		return this._containerMetadata;
+	}
+
 	/**
 	 * Sends signal to runtime (and data stores) to be read-only.
 	 * Hosts may have read only views, indicating to data stores that no edits are allowed.
@@ -829,7 +845,7 @@ export class Container
 					clientType, // Differentiating summarizer container from main container
 					containerId: this._containerId,
 					docId: () => this.resolvedUrl?.id,
-					containerAttachState: () => this._attachState,
+					containerAttachState: () => this.attachState,
 					containerLifecycleState: () => this._lifecycleState,
 					containerConnectionState: () => ConnectionState[this.connectionState],
 					serializedContainer: pendingLocalState !== undefined,
@@ -1030,6 +1046,11 @@ export class Container
 
 				this._lifecycleState = "closing";
 
+				// Back-compat for Old driver
+				if (this.service?.off !== undefined) {
+					this.service?.off("metadataUpdate", this.metadataUpdateHandler);
+				}
+
 				this._protocolHandler?.close();
 
 				this.connectionStateHandler.dispose();
@@ -1147,20 +1168,19 @@ export class Container
 					);
 				}
 				assert(
-					this.attachState === AttachState.Attached,
+					this.attachmentData.state === AttachState.Attached,
 					0x0d1 /* "Container should be attached before close" */,
 				);
 				assert(
 					this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid",
 					0x0d2 /* "resolved url should be valid Fluid url" */,
 				);
-				assert(!!this.baseSnapshot, 0x5d4 /* no base snapshot */);
-				assert(!!this.baseSnapshotBlobs, 0x5d5 /* no snapshot blobs */);
+				assert(this.attachmentData.snapshot !== undefined, 0x5d5 /* no base data */);
 				const pendingRuntimeState = await this.runtime.getPendingLocalState(props);
 				const pendingState: IPendingContainerState = {
 					pendingRuntimeState,
-					baseSnapshot: this.baseSnapshot,
-					snapshotBlobs: this.baseSnapshotBlobs,
+					baseSnapshot: this.attachmentData.snapshot.tree,
+					snapshotBlobs: this.attachmentData.snapshot.blobs,
 					savedOps: this.savedOps,
 					url: this.resolvedUrl.url,
 					// no need to save this if there is no pending runtime state
@@ -1173,7 +1193,7 @@ export class Container
 	}
 
 	public get attachState(): AttachState {
-		return this._attachState;
+		return this.attachmentData.state;
 	}
 
 	public serialize(): string {
@@ -1186,142 +1206,129 @@ export class Container
 		const protocolSummary = this.captureProtocolSummary();
 		const combinedSummary = combineAppAndProtocolSummary(appSummary, protocolSummary);
 
-		if (this.detachedBlobStorage && this.detachedBlobStorage.size > 0) {
-			combinedSummary.tree[hasBlobsSummaryTree] = {
-				type: SummaryType.Blob,
-				content: "true",
-			};
-		}
-		return JSON.stringify(combinedSummary);
-	}
+		const { tree: snapshot, blobs } =
+			getSnapshotTreeAndBlobsFromSerializedContainer(combinedSummary);
 
-	public async attach(
-		request: IRequest,
-		attachProps?: { deltaConnection?: "none" | "delayed" },
-	): Promise<void> {
-		await PerformanceEvent.timedExecAsync(
-			this.mc.logger,
-			{ eventName: "Attach" },
-			async () => {
-				if (this._lifecycleState !== "loaded") {
-					// pre-0.58 error message: containerNotValidForAttach
-					throw new UsageError(
-						`The Container is not in a valid state for attach [${this._lifecycleState}]`,
-					);
-				}
-
-				// If container is already attached or attach is in progress, throw an error.
-				assert(
-					this._attachState === AttachState.Detached && !this.attachStarted,
-					0x205 /* "attach() called more than once" */,
-				);
-				this.attachStarted = true;
-
-				// If attachment blobs were uploaded in detached state we will go through a different attach flow
-				const hasAttachmentBlobs =
-					this.detachedBlobStorage !== undefined && this.detachedBlobStorage.size > 0;
-
-				try {
-					assert(
-						this.deltaManager.inbound.length === 0,
-						0x0d6 /* "Inbound queue should be empty when attaching" */,
-					);
-
-					let summary: ISummaryTree;
-					if (!hasAttachmentBlobs) {
-						// Get the document state post attach - possibly can just call attach but we need to change the
-						// semantics around what the attach means as far as async code goes.
-						const appSummary: ISummaryTree = this.runtime.createSummary();
-						const protocolSummary = this.captureProtocolSummary();
-						summary = combineAppAndProtocolSummary(appSummary, protocolSummary);
-
-						// Set the state as attaching as we are starting the process of attaching container.
-						// This should be fired after taking the summary because it is the place where we are
-						// starting to attach the container to storage.
-						// Also, this should only be fired in detached container.
-						this._attachState = AttachState.Attaching;
-						this.runtime.setAttachState(AttachState.Attaching);
-						this.emit("attaching");
-						if (this.offlineLoadEnabled) {
-							const snapshot = getSnapshotTreeFromSerializedContainer(summary);
-							this.baseSnapshot = snapshot;
-							this.baseSnapshotBlobs =
-								getBlobContentsFromTreeWithBlobContents(snapshot);
-						}
-					}
-
-					// Actually go and create the resolved document
-					if (this.service === undefined) {
-						const createNewResolvedUrl = await this.urlResolver.resolve(request);
-						assert(
-							this.client.details.type !== summarizerClientType &&
-								createNewResolvedUrl !== undefined,
-							0x2c4 /* "client should not be summarizer before container is created" */,
-						);
-						this.service = await runWithRetry(
-							async () =>
-								this.serviceFactory.createContainer(
-									summary,
-									createNewResolvedUrl,
-									this.subLogger,
-									false, // clientIsSummarizer
-								),
-							"containerAttach",
-							this.mc.logger,
-							{
-								cancel: this._deltaManager.closeAbortController.signal,
-							}, // progress
+		const detachedContainerState: IPendingDetachedContainerState = {
+			attached: false,
+			baseSnapshot: snapshot,
+			snapshotBlobs: blobs,
+			hasAttachmentBlobs: !!this.detachedBlobStorage && this.detachedBlobStorage.size > 0,
+		};
+		return JSON.stringify(detachedContainerState);
+	}
+
+	public readonly attach = runSingle(
+		async (
+			request: IRequest,
+			attachProps?: { deltaConnection?: "none" | "delayed" },
+		): Promise<void> => {
+			await PerformanceEvent.timedExecAsync(
+				this.mc.logger,
+				{ eventName: "Attach" },
+				async () => {
+					if (
+						this._lifecycleState !== "loaded" ||
+						this.attachmentData.state === AttachState.Attached
+					) {
+						// pre-0.58 error message: containerNotValidForAttach
+						throw new UsageError(
+							`The Container is not in a valid state for attach [${this._lifecycleState}] and [${this.attachState}]`,
 						);
 					}
-					this.storageAdapter.connectToService(this.service);
 
-					if (hasAttachmentBlobs) {
-						// upload blobs to storage
-						assert(
-							!!this.detachedBlobStorage,
-							0x24e /* "assertion for type narrowing" */,
-						);
+					const normalizeErrorAndClose = (error: unknown): IFluidErrorBase => {
+						const newError = normalizeError(error);
+						this.close(newError);
+						// add resolved URL on error object so that host has the ability to find this document and delete it
+						newError.addTelemetryProperties({
+							resolvedUrl: this.service?.resolvedUrl?.url,
+						});
+						return newError;
+					};
 
-						// build a table mapping IDs assigned locally to IDs assigned by storage and pass it to runtime to
-						// support blob handles that only know about the local IDs
-						const redirectTable = new Map<string, string>();
-						// if new blobs are added while uploading, upload them too
-						while (redirectTable.size < this.detachedBlobStorage.size) {
-							const newIds = this.detachedBlobStorage
-								.getBlobIds()
-								.filter((id) => !redirectTable.has(id));
-							for (const id of newIds) {
-								const blob = await this.detachedBlobStorage.readBlob(id);
-								const response = await this.storageAdapter.createBlob(blob);
-								redirectTable.set(id, response.id);
+					const setAttachmentData: AttachProcessProps["setAttachmentData"] = (
+						attachmentData,
+					) => {
+						const previousState = this.attachmentData.state;
+						this.attachmentData = attachmentData;
+						const state = this.attachmentData.state;
+						if (state !== previousState && state !== AttachState.Detached) {
+							try {
+								this.runtime.setAttachState(state);
+								this.emit(state.toLocaleLowerCase());
+							} catch (error) {
+								throw normalizeErrorAndClose(error);
 							}
 						}
+					};
 
-						// take summary and upload
-						const appSummary: ISummaryTree = this.runtime.createSummary(redirectTable);
-						const protocolSummary = this.captureProtocolSummary();
-						summary = combineAppAndProtocolSummary(appSummary, protocolSummary);
-
-						this._attachState = AttachState.Attaching;
-						this.runtime.setAttachState(AttachState.Attaching);
-						this.emit("attaching");
-						if (this.offlineLoadEnabled) {
-							const snapshot = getSnapshotTreeFromSerializedContainer(summary);
-							this.baseSnapshot = snapshot;
-							this.baseSnapshotBlobs =
-								getBlobContentsFromTreeWithBlobContents(snapshot);
+					const createAttachmentSummary: AttachProcessProps["createAttachmentSummary"] = (
+						redirectTable?: Map<string, string>,
+					) => {
+						try {
+							assert(
+								this.deltaManager.inbound.length === 0,
+								0x0d6 /* "Inbound queue should be empty when attaching" */,
+							);
+							return combineAppAndProtocolSummary(
+								this.runtime.createSummary(redirectTable),
+								this.captureProtocolSummary(),
+							);
+						} catch (error) {
+							throw normalizeErrorAndClose(error);
 						}
+					};
+
+					const createOrGetStorageService: AttachProcessProps["createOrGetStorageService"] =
+						async (summary) => {
+							// Actually go and create the resolved document
+							if (this.service === undefined) {
+								const createNewResolvedUrl =
+									await this.urlResolver.resolve(request);
+								assert(
+									this.client.details.type !== summarizerClientType &&
+										createNewResolvedUrl !== undefined,
+									0x2c4 /* "client should not be summarizer before container is created" */,
+								);
+								this.service = await runWithRetry(
+									async () =>
+										this.serviceFactory.createContainer(
+											summary,
+											createNewResolvedUrl,
+											this.subLogger,
+											false, // clientIsSummarizer
+										),
+									"containerAttach",
+									this.mc.logger,
+									{
+										cancel: this._deltaManager.closeAbortController.signal,
+									}, // progress
+								);
+							}
+							this.storageAdapter.connectToService(this.service);
+							return this.storageAdapter;
+						};
+
+					let attachP = runRetriableAttachProcess({
+						initialAttachmentData: this.attachmentData,
+						offlineLoadEnabled: this.offlineLoadEnabled,
+						detachedBlobStorage: this.detachedBlobStorage,
+						setAttachmentData,
+						createAttachmentSummary,
+						createOrGetStorageService,
+					});
 
-						await this.storageAdapter.uploadSummaryWithContext(summary, {
-							referenceSequenceNumber: 0,
-							ackHandle: undefined,
-							proposalHandle: undefined,
+					// only enable the new behavior if the config is set
+					if (
+						this.mc.config.getBoolean("Fluid.Container.RetryOnAttachFailure") !== true
+					) {
+						attachP = attachP.catch((error) => {
+							throw normalizeErrorAndClose(error);
 						});
 					}
 
-					this._attachState = AttachState.Attached;
-					this.runtime.setAttachState(AttachState.Attached);
-					this.emit("attached");
+					await attachP;
 
 					if (!this.closed) {
 						this.handleDeltaConnectionArg(
@@ -1332,17 +1339,11 @@ export class Container
 							attachProps?.deltaConnection,
 						);
 					}
-				} catch (error) {
-					// add resolved URL on error object so that host has the ability to find this document and delete it
-					const newError = normalizeError(error);
-					newError.addTelemetryProperties({ resolvedUrl: this.resolvedUrl?.url });
-					this.close(newError);
-					throw newError;
-				}
-			},
-			{ start: true, end: true, cancel: "generic" },
-		);
-	}
+				},
+				{ start: true, end: true, cancel: "generic" },
+			);
+		},
+	);
 
 	private setAutoReconnectInternal(mode: ReconnectMode, reason: IConnectionStateChangeReason) {
 		const currentMode = this._deltaManager.connectionManager.reconnectMode;
@@ -1369,7 +1370,7 @@ export class Container
 	public connect() {
 		if (this.closed) {
 			throw new UsageError(`The Container is closed and cannot be connected`);
-		} else if (this._attachState !== AttachState.Attached) {
+		} else if (this.attachState !== AttachState.Attached) {
 			throw new UsageError(`The Container is not attached and cannot be connected`);
 		} else if (!this.connected) {
 			// Note: no need to fetch ops as we do it preemptively as part of DeltaManager.attachOpHandler().
@@ -1385,7 +1386,7 @@ export class Container
 	private connectInternal(args: IConnectionArgs) {
 		assert(!this.closed, 0x2c5 /* "Attempting to connect() a closed Container" */);
 		assert(
-			this._attachState === AttachState.Attached,
+			this.attachState === AttachState.Attached,
 			0x2c6 /* "Attempting to connect() a container that is not attached" */,
 		);
 
@@ -1534,6 +1535,22 @@ export class Container
 		this._deltaManager.connect(args);
 	}
 
+	private readonly metadataUpdateHandler = (metadata: Record<string, string>) => {
+		this._containerMetadata = { ...this._containerMetadata, ...metadata };
+		this.emit("metadataUpdate", metadata);
+	};
+
+	private async createDocumentService(
+		serviceProvider: () => Promise<IDocumentService>,
+	): Promise<IDocumentService> {
+		const service = await serviceProvider();
+		// Back-compat for Old driver
+		if (service.on !== undefined) {
+			service.on("metadataUpdate", this.metadataUpdateHandler);
+		}
+		return service;
+	}
+
 	/**
 	 * Load container.
 	 *
@@ -1547,10 +1564,12 @@ export class Container
 		loadToSequenceNumber: number | undefined,
 	) {
 		const timings: Record<string, number> = { phase1: performance.now() };
-		this.service = await this.serviceFactory.createDocumentService(
-			resolvedUrl,
-			this.subLogger,
-			this.client.details.type === summarizerClientType,
+		this.service = await this.createDocumentService(async () =>
+			this.serviceFactory.createDocumentService(
+				resolvedUrl,
+				this.subLogger,
+				this.client.details.type === summarizerClientType,
+			),
 		);
 
 		// Except in cases where it has stashed ops or requested by feature gate, the container will connect in "read" mode
@@ -1573,33 +1592,42 @@ export class Container
 
 		this.storageAdapter.connectToService(this.service);
 
-		this._attachState = AttachState.Attached;
+		this.attachmentData = {
+			state: AttachState.Attached,
+		};
 
 		timings.phase2 = performance.now();
 		// Fetch specified snapshot.
 		const { snapshot, versionId } =
 			pendingLocalState === undefined
-				? await this.fetchSnapshotTree(specifiedVersion)
+				? await this.fetchSnapshot(specifiedVersion)
 				: { snapshot: pendingLocalState.baseSnapshot, versionId: undefined };
 
+		const snapshotTree: ISnapshotTree | undefined = isInstanceOfISnapshot(snapshot)
+			? snapshot.snapshotTree
+			: snapshot;
 		if (pendingLocalState) {
-			this.baseSnapshot = pendingLocalState.baseSnapshot;
-			this.baseSnapshotBlobs = pendingLocalState.snapshotBlobs;
+			this.attachmentData = {
+				state: AttachState.Attached,
+				snapshot: {
+					tree: pendingLocalState.baseSnapshot,
+					blobs: pendingLocalState.snapshotBlobs,
+				},
+			};
 		} else {
-			assert(snapshot !== undefined, 0x237 /* "Snapshot should exist" */);
+			assert(snapshotTree !== undefined, 0x237 /* "Snapshot should exist" */);
 			if (this.offlineLoadEnabled) {
-				this.baseSnapshot = snapshot;
-				// Save contents of snapshot now, otherwise closeAndGetPendingLocalState() must be async
-				this.baseSnapshotBlobs = await getBlobContentsFromTree(
-					snapshot,
-					this.storageAdapter,
-				);
+				const blobs = await getBlobContentsFromTree(snapshotTree, this.storageAdapter);
+				this.attachmentData = {
+					state: AttachState.Attached,
+					snapshot: { tree: snapshotTree, blobs },
+				};
 			}
 		}
 
 		const attributes: IDocumentAttributes = await this.getDocumentAttributes(
 			this.storageAdapter,
-			snapshot,
+			snapshotTree,
 		);
 
 		// If we saved ops, we will replay them and don't need DeltaManager to fetch them
@@ -1686,15 +1714,20 @@ export class Container
 
 		// ...load in the existing quorum
 		// Initialize the protocol handler
-		await this.initializeProtocolStateFromSnapshot(attributes, this.storageAdapter, snapshot);
+		await this.initializeProtocolStateFromSnapshot(
+			attributes,
+			this.storageAdapter,
+			snapshotTree,
+		);
 
 		timings.phase3 = performance.now();
 		const codeDetails = this.getCodeDetailsFromQuorum();
 		await this.instantiateRuntime(
 			codeDetails,
-			snapshot,
+			snapshotTree,
 			// give runtime a dummy value so it knows we're loading from a stash blob
 			pendingLocalState ? pendingLocalState?.pendingRuntimeState ?? {} : undefined,
+			isInstanceOfISnapshot(snapshot) ? snapshot : undefined,
 		);
 
 		// replay saved ops
@@ -1807,24 +1840,30 @@ export class Container
 		this.setLoaded();
 	}
 
-	private async rehydrateDetachedFromSnapshot(detachedContainerSnapshot: ISummaryTree) {
-		if (detachedContainerSnapshot.tree[hasBlobsSummaryTree] !== undefined) {
+	private async rehydrateDetachedFromSnapshot({
+		attached,
+		baseSnapshot,
+		snapshotBlobs,
+		hasAttachmentBlobs,
+	}: IPendingDetachedContainerState) {
+		if (hasAttachmentBlobs) {
 			assert(
 				!!this.detachedBlobStorage && this.detachedBlobStorage.size > 0,
 				0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */,
 			);
-			// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-			delete detachedContainerSnapshot.tree[hasBlobsSummaryTree];
 		}
-
-		const snapshotTree = getSnapshotTreeFromSerializedContainer(detachedContainerSnapshot);
-		this.storageAdapter.loadSnapshotForRehydratingContainer(snapshotTree);
-		const attributes = await this.getDocumentAttributes(this.storageAdapter, snapshotTree);
+		const snapshotTreeWithBlobContents: ISnapshotTreeWithBlobContents =
+			combineSnapshotTreeAndSnapshotBlobs(baseSnapshot, snapshotBlobs);
+		this.storageAdapter.loadSnapshotFromSnapshotBlobs(snapshotBlobs);
+		const attributes = await this.getDocumentAttributes(
+			this.storageAdapter,
+			snapshotTreeWithBlobContents,
+		);
 
 		await this.attachDeltaManagerOpHandler(attributes);
 
 		// Initialize the protocol handler
-		const baseTree = getProtocolSnapshotTree(snapshotTree);
+		const baseTree = getProtocolSnapshotTree(snapshotTreeWithBlobContents);
 		const qValues = await readAndParse<[string, ICommittedProposal][]>(
 			this.storageAdapter,
 			baseTree.blobs.quorumValues,
@@ -1839,7 +1878,7 @@ export class Container
 		);
 		const codeDetails = this.getCodeDetailsFromQuorum();
 
-		await this.instantiateRuntime(codeDetails, snapshotTree);
+		await this.instantiateRuntime(codeDetails, snapshotTreeWithBlobContents);
 
 		this.setLoaded();
 	}
@@ -2383,10 +2422,39 @@ export class Container
 		return { snapshot, versionId: version?.id };
 	}
 
+	private async fetchSnapshot(
+		specifiedVersion: string | undefined,
+	): Promise<{ snapshot?: ISnapshot | ISnapshotTree; versionId?: string }> {
+		if (
+			this.mc.config.getBoolean("Fluid.Container.FetchSnapshotUsingGetSnapshotApi") ===
+				true &&
+			this.service?.policies?.supportGetSnapshotApi === true
+		) {
+			const snapshot = await this.storageAdapter.getSnapshot({
+				versionId: specifiedVersion,
+			});
+			const version: IVersion = {
+				id: snapshot.snapshotTree.id ?? "",
+				treeId: snapshot.snapshotTree.id ?? "",
+			};
+			this._loadedFromVersion = version;
+
+			if (snapshot === undefined && specifiedVersion !== undefined) {
+				this.mc.logger.sendErrorEvent({
+					eventName: "getSnapshotTreeFailed",
+					id: version.id,
+				});
+			}
+			return { snapshot, versionId: version.id };
+		}
+		return this.fetchSnapshotTree(specifiedVersion);
+	}
+
 	private async instantiateRuntime(
 		codeDetails: IFluidCodeDetails,
-		snapshot: ISnapshotTree | undefined,
+		snapshotTree: ISnapshotTree | undefined,
 		pendingLocalState?: unknown,
+		snapshot?: ISnapshot,
 	) {
 		assert(this._runtime?.disposed !== false, 0x0dd /* "Existing runtime not disposed" */);
 
@@ -2420,12 +2488,12 @@ export class Container
 			(this.protocolHandler.quorum.get("code") ??
 				this.protocolHandler.quorum.get("code2")) as IFluidCodeDetails | undefined;
 
-		const existing = snapshot !== undefined;
+		const existing = snapshotTree !== undefined;
 
 		const context = new ContainerContext(
 			this.options,
 			this.scope,
-			snapshot,
+			snapshotTree,
 			this._loadedFromVersion,
 			this._deltaManager,
 			this.storageAdapter,
@@ -2452,6 +2520,7 @@ export class Container
 			existing,
 			this.subLogger,
 			pendingLocalState,
+			snapshot,
 		);
 
 		this._runtime = await PerformanceEvent.timedExecAsync(