@fluidframework/container-loader 2.0.0-rc.2.0.1 → 2.0.0-rc.3.0.0

package/src/serializedStateManager.ts

@@ -4,37 +4,83 @@
  */
 
 import {
+	IGetPendingLocalStateProps,
+	IRuntime,
+} from "@fluidframework/container-definitions/internal";
+import { assert } from "@fluidframework/core-utils/internal";
+import {
+	IDocumentStorageService,
+	IResolvedUrl,
+	ISnapshot,
+} from "@fluidframework/driver-definitions/internal";
+import { isInstanceOfISnapshot } from "@fluidframework/driver-utils/internal";
+import {
+	type IDocumentAttributes,
 	ISequencedDocumentMessage,
 	ISnapshotTree,
 	IVersion,
 } from "@fluidframework/protocol-definitions";
-import { IGetPendingLocalStateProps, IRuntime } from "@fluidframework/container-definitions";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import {
-	ITelemetryLoggerExt,
 	MonitoringContext,
 	PerformanceEvent,
 	UsageError,
 	createChildMonitoringContext,
-} from "@fluidframework/telemetry-utils";
-import { assert } from "@fluidframework/core-utils";
-import {
-	IDocumentStorageService,
-	IResolvedUrl,
-	ISnapshot,
-} from "@fluidframework/driver-definitions";
-import { isInstanceOfISnapshot } from "@fluidframework/driver-utils";
+} from "@fluidframework/telemetry-utils/internal";
+
 import { ISerializableBlobContents, getBlobContentsFromTree } from "./containerStorageAdapter.js";
-import { IPendingContainerState } from "./container.js";
+import { getDocumentAttributes } from "./utils.js";
+
+export interface SnapshotWithBlobs {
+	/**
+	 * Snapshot from which container initially loaded.
+	 */
+	baseSnapshot: ISnapshotTree;
+	/**
+	 * Serializable blobs from the base snapshot. Used to load offline since
+	 * storage is not available.
+	 */
+	snapshotBlobs: ISerializableBlobContents;
+}
+/**
+ * State saved by a container at close time, to be used to load a new instance
+ * of the container to the same state
+ * @internal
+ */
+export interface IPendingContainerState extends SnapshotWithBlobs {
+	attached: true;
+	pendingRuntimeState: unknown;
+	/**
+	 * All ops since base snapshot sequence number up to the latest op
+	 * seen when the container was closed. Used to apply stashed (saved pending)
+	 * ops at the same sequence number at which they were made.
+	 */
+	savedOps: ISequencedDocumentMessage[];
+	url: string;
+	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 extends SnapshotWithBlobs {
+	attached: false;
+	hasAttachmentBlobs: boolean;
+	pendingRuntimeState?: unknown;
+}
+
+export interface ISnapshotInfo extends SnapshotWithBlobs {
+	snapshotSequenceNumber: number;
+}
 
 export class SerializedStateManager {
 	private readonly processedOps: ISequencedDocumentMessage[] = [];
-	private snapshot:
-		| {
-				tree: ISnapshotTree;
-				blobs: ISerializableBlobContents;
-		  }
-		| undefined;
+	private snapshot: ISnapshotInfo | undefined;
 	private readonly mc: MonitoringContext;
+	private latestSnapshot: ISnapshotInfo | undefined;
+	private refreshSnapshot: Promise<void> | undefined;
 
 	constructor(
 		private readonly pendingLocalState: IPendingContainerState | undefined,
@@ -44,6 +90,7 @@ export class SerializedStateManager {
 			"readBlob" | "getSnapshotTree" | "getSnapshot" | "getVersions"
 		>,
 		private readonly _offlineLoadEnabled: boolean,
+		private readonly newSnapshotFetched?: () => void,
 	) {
 		this.mc = createChildMonitoringContext({
 			logger: subLogger,
@@ -58,107 +105,101 @@ export class SerializedStateManager {
 	public addProcessedOp(message: ISequencedDocumentMessage) {
 		if (this.offlineLoadEnabled) {
 			this.processedOps.push(message);
+			this.updateSnapshotAndProcessedOpsMaybe();
 		}
 	}
 
-	private async getVersion(version: string | null): Promise<IVersion | undefined> {
-		const versions = await this.storageAdapter.getVersions(version, 1);
-		return versions[0];
-	}
-
 	public async fetchSnapshot(
 		specifiedVersion: string | undefined,
-		supportGetSnapshotApi: boolean | undefined,
+		supportGetSnapshotApi: boolean,
 	) {
-		const { snapshot, version } =
-			this.pendingLocalState === undefined
-				? await this.fetchSnapshotCore(specifiedVersion, supportGetSnapshotApi)
-				: { snapshot: this.pendingLocalState.baseSnapshot, version: undefined };
-		const snapshotTree: ISnapshotTree | undefined = isInstanceOfISnapshot(snapshot)
-			? snapshot.snapshotTree
-			: snapshot;
-		if (this.pendingLocalState) {
-			this.snapshot = {
-				tree: this.pendingLocalState.baseSnapshot,
-				blobs: this.pendingLocalState.snapshotBlobs,
-			};
-		} else {
-			assert(snapshotTree !== undefined, 0x8e4 /* Snapshot should exist */);
+		if (this.pendingLocalState === undefined) {
+			const { baseSnapshot, version } = await getSnapshotTree(
+				this.mc,
+				this.storageAdapter,
+				supportGetSnapshotApi,
+				specifiedVersion,
+			);
 			// non-interactive clients will not have any pending state we want to save
 			if (this.offlineLoadEnabled) {
-				const blobs = await getBlobContentsFromTree(snapshotTree, this.storageAdapter);
-				this.snapshot = { tree: snapshotTree, blobs };
+				const snapshotBlobs = await getBlobContentsFromTree(
+					baseSnapshot,
+					this.storageAdapter,
+				);
+				const attributes = await getDocumentAttributes(this.storageAdapter, baseSnapshot);
+				this.snapshot = {
+					baseSnapshot,
+					snapshotBlobs,
+					snapshotSequenceNumber: attributes.sequenceNumber,
+				};
 			}
-		}
-		return { snapshotTree, version };
-	}
+			return { baseSnapshot, version };
+		} else {
+			const { baseSnapshot, snapshotBlobs } = this.pendingLocalState;
+			const attributes = await getDocumentAttributes(this.storageAdapter, baseSnapshot);
+			this.snapshot = {
+				baseSnapshot,
+				snapshotBlobs,
+				snapshotSequenceNumber: attributes.sequenceNumber,
+			};
+			this.refreshSnapshot ??= (async () => {
+				this.latestSnapshot = await getLatestSnapshotInfo(
+					this.mc,
+					this.storageAdapter,
+					supportGetSnapshotApi,
+				);
+				this.newSnapshotFetched?.();
+				this.updateSnapshotAndProcessedOpsMaybe();
+			})();
 
-	private async fetchSnapshotCore(
-		specifiedVersion: string | undefined,
-		supportGetSnapshotApi: boolean | undefined,
-	): Promise<{ snapshot?: ISnapshot | ISnapshotTree; version?: IVersion }> {
-		if (
-			this.mc.config.getBoolean("Fluid.Container.UseLoadingGroupIdForSnapshotFetch") ===
-				true &&
-			supportGetSnapshotApi === true
-		) {
-			const snapshot =
-				(await this.storageAdapter.getSnapshot?.({
-					versionId: specifiedVersion,
-				})) ?? undefined;
-			const version: IVersion | undefined =
-				snapshot?.snapshotTree.id === undefined
-					? undefined
-					: {
-							id: snapshot.snapshotTree.id,
-							treeId: snapshot.snapshotTree.id,
-					  };
-
-			if (snapshot === undefined && specifiedVersion !== undefined) {
-				this.mc.logger.sendErrorEvent({
-					eventName: "getSnapshotTreeFailed",
-					id: specifiedVersion,
-				});
-				// Not sure if this should be here actually
-			} else if (snapshot !== undefined && version?.id === undefined) {
-				this.mc.logger.sendErrorEvent({
-					eventName: "getSnapshotFetchedTreeWithoutVersionId",
-					hasVersion: version !== undefined, // if hasVersion is true, this means that the contract with the service was broken.
-				});
-			}
-			return { snapshot, version };
+			return { baseSnapshot, version: undefined };
 		}
-		return this.fetchSnapshotTree(specifiedVersion);
 	}
 
 	/**
-	 * Get the most recent snapshot, or a specific version.
-	 * @param specifiedVersion - The specific version of the snapshot to retrieve
-	 * @returns The snapshot requested, or the latest snapshot if no version was specified, plus version ID
+	 * Updates class snapshot and processedOps if we have a new snapshot and it's among processedOps range.
 	 */
-	private async fetchSnapshotTree(
-		specifiedVersion: string | undefined,
-	): Promise<{ snapshot?: ISnapshotTree; version?: IVersion | undefined }> {
-		const version = await this.getVersion(specifiedVersion ?? null);
-
-		if (version === undefined && specifiedVersion !== undefined) {
-			// We should have a defined version to load from if specified version requested
-			this.mc.logger.sendErrorEvent({
-				eventName: "NoVersionFoundWhenSpecified",
-				id: specifiedVersion,
-			});
+	private updateSnapshotAndProcessedOpsMaybe() {
+		if (this.latestSnapshot === undefined || this.processedOps.length === 0) {
+			// can't refresh latest snapshot until we have processed the ops up to it.
+			// Pending state would be behind the latest snapshot.
+			return;
 		}
-		const snapshot = (await this.storageAdapter.getSnapshotTree(version)) ?? undefined;
-
-		if (snapshot === undefined && version !== undefined) {
-			this.mc.logger.sendErrorEvent({ eventName: "getSnapshotTreeFailed", id: version.id });
-		} else if (snapshot !== undefined && version?.id === undefined) {
-			this.mc.logger.sendErrorEvent({
-				eventName: "getSnapshotFetchedTreeWithoutVersionId",
-				hasVersion: version !== undefined, // if hasVersion is true, this means that the contract with the service was broken.
+		const snapshotSequenceNumber = this.latestSnapshot.snapshotSequenceNumber;
+		const firstProcessedOpSequenceNumber = this.processedOps[0].sequenceNumber;
+		const lastProcessedOpSequenceNumber =
+			this.processedOps[this.processedOps.length - 1].sequenceNumber;
+
+		if (snapshotSequenceNumber < firstProcessedOpSequenceNumber) {
+			// Snapshot seq number is older than our first processed op, which could mean we're fetching
+			// the same snapshot that we already have or snapshot is too old, implicating an unexpected behavior.
+			this.mc.logger.sendTelemetryEvent({
+				eventName: "OldSnapshotFetchWhileRefreshing",
+				snapshotSequenceNumber,
+				firstProcessedOpSequenceNumber,
+				lastProcessedOpSequenceNumber,
+				stashedSnapshotSequenceNumber: this.snapshot?.snapshotSequenceNumber,
+			});
+			this.latestSnapshot = undefined;
+		} else if (snapshotSequenceNumber <= lastProcessedOpSequenceNumber) {
+			// Snapshot seq num is between the first and last processed op.
+			// Remove the ops that are already part of the snapshot
+			this.processedOps.splice(
+				0,
+				snapshotSequenceNumber - firstProcessedOpSequenceNumber + 1,
+			);
+			this.snapshot = this.latestSnapshot;
+			this.latestSnapshot = undefined;
+			this.mc.logger.sendTelemetryEvent({
+				eventName: "SnapshotRefreshed",
+				snapshotSequenceNumber,
+				firstProcessedOpSequenceNumber,
+				newFirstProcessedOpSequenceNumber:
+					this.processedOps.length === 0
+						? undefined
+						: this.processedOps[0].sequenceNumber,
 			});
 		}
-		return { snapshot, version };
 	}
 
 	/**
@@ -166,15 +207,25 @@ export class SerializedStateManager {
 	 * base snapshot when attaching.
 	 * @param snapshot - snapshot and blobs collected while attaching
 	 */
-	public setSnapshot(
-		snapshot:
-			| {
-					tree: ISnapshotTree;
-					blobs: ISerializableBlobContents;
-			  }
-			| undefined,
-	) {
-		this.snapshot = snapshot;
+	public setInitialSnapshot(snapshot: SnapshotWithBlobs | undefined) {
+		if (this.offlineLoadEnabled) {
+			assert(
+				this.snapshot === undefined,
+				0x937 /* inital snapshot should only be defined once */,
+			);
+			assert(snapshot !== undefined, 0x938 /* attachment snapshot should be defined */);
+			const { baseSnapshot, snapshotBlobs } = snapshot;
+			const attributesHash =
+				".protocol" in baseSnapshot.trees
+					? baseSnapshot.trees[".protocol"].blobs.attributes
+					: baseSnapshot.blobs[".attributes"];
+			const attributes = JSON.parse(snapshotBlobs[attributesHash]);
+			assert(
+				attributes.sequenceNumber === 0,
+				0x939 /* trying to set a non attachment snapshot */,
+			);
+			this.snapshot = { ...snapshot, snapshotSequenceNumber: attributes.sequenceNumber };
+		}
 	}
 
 	public async getPendingLocalStateCore(
@@ -202,8 +253,8 @@ export class SerializedStateManager {
 				const pendingState: IPendingContainerState = {
 					attached: true,
 					pendingRuntimeState,
-					baseSnapshot: this.snapshot.tree,
-					snapshotBlobs: this.snapshot.blobs,
+					baseSnapshot: this.snapshot.baseSnapshot,
+					snapshotBlobs: this.snapshot.snapshotBlobs,
 					savedOps: this.processedOps,
 					url: resolvedUrl.url,
 					// no need to save this if there is no pending runtime state
@@ -215,3 +266,140 @@ export class SerializedStateManager {
 		);
 	}
 }
+
+/**
+ * Retrieves the most recent snapshot and returns its info.
+ *
+ * @param mc - The monitoring context.
+ * @param storageAdapter - The storage adapter providing methods to retrieve the snapshot.
+ * @param supportGetSnapshotApi - a boolean indicating whether to use the fetchISnapshot or fetchISnapshotTree.
+ * @returns a SnapshotInfo object containing the snapshot tree, snapshot blobs and its sequence number.
+ */
+export async function getLatestSnapshotInfo(
+	mc: MonitoringContext,
+	storageAdapter: Pick<
+		IDocumentStorageService,
+		"getSnapshot" | "getSnapshotTree" | "getVersions" | "readBlob"
+	>,
+	supportGetSnapshotApi: boolean,
+): Promise<ISnapshotInfo | undefined> {
+	return PerformanceEvent.timedExecAsync(
+		mc.logger,
+		{ eventName: "GetLatestSnapshotInfo" },
+		async () => {
+			const { baseSnapshot } = await getSnapshotTree(
+				mc,
+				storageAdapter,
+				supportGetSnapshotApi,
+				undefined,
+			);
+			const snapshotBlobs = await getBlobContentsFromTree(baseSnapshot, storageAdapter);
+			const attributes: IDocumentAttributes = await getDocumentAttributes(
+				storageAdapter,
+				baseSnapshot,
+			);
+			const snapshotSequenceNumber = attributes.sequenceNumber;
+			return { baseSnapshot, snapshotBlobs, snapshotSequenceNumber };
+		},
+	).catch(() => undefined);
+}
+
+/**
+ * Retrieves a snapshot from the storage adapter and transforms it into an ISnapshotTree object.
+ *
+ * @param mc - The monitoring context.
+ * @param storageAdapter - The storage adapter providing methods to retrieve the snapshot.
+ * @param supportGetSnapshotApi - a boolean indicating whether to use the fetchISnapshot or fetchISnapshotTree.
+ * @param specifiedVersion - An optional version string specifying the version of the snapshot tree to fetch.
+ * @returns - An ISnapshotTree and its version.
+ */
+async function getSnapshotTree(
+	mc: MonitoringContext,
+	storageAdapter: Pick<
+		IDocumentStorageService,
+		"getSnapshot" | "getSnapshotTree" | "getVersions"
+	>,
+	supportGetSnapshotApi: boolean,
+	specifiedVersion: string | undefined,
+): Promise<{ baseSnapshot: ISnapshotTree; version?: IVersion }> {
+	const { snapshot, version } = supportGetSnapshotApi
+		? await fetchISnapshot(mc, storageAdapter, specifiedVersion)
+		: await fetchISnapshotTree(mc, storageAdapter, specifiedVersion);
+	const baseSnapshot: ISnapshotTree | undefined = isInstanceOfISnapshot(snapshot)
+		? snapshot.snapshotTree
+		: snapshot;
+	assert(baseSnapshot !== undefined, 0x8e4 /* Snapshot should exist */);
+	return { baseSnapshot, version };
+}
+
+/**
+ * Fetches an ISnapshot from a storage adapter based on the specified version.
+ *
+ * @param mc - The monitoring context.
+ * @param storageAdapter - The storage adapter providing a getSnapshot method to retrieve the ISnapshot and version.
+ * @param specifiedVersion - An optional version string specifying the version of the snapshot tree to fetch.
+ * @returns - The fetched snapshot tree and its version.
+ */
+export async function fetchISnapshot(
+	mc: MonitoringContext,
+	storageAdapter: Pick<IDocumentStorageService, "getSnapshot">,
+	specifiedVersion: string | undefined,
+): Promise<{ snapshot?: ISnapshot; version?: IVersion }> {
+	const snapshot = await storageAdapter.getSnapshot?.({ versionId: specifiedVersion });
+	const version: IVersion | undefined =
+		snapshot?.snapshotTree.id === undefined
+			? undefined
+			: {
+					id: snapshot.snapshotTree.id,
+					treeId: snapshot.snapshotTree.id,
+			  };
+
+	if (snapshot === undefined && specifiedVersion !== undefined) {
+		mc.logger.sendErrorEvent({
+			eventName: "getSnapshotTreeFailed",
+			id: specifiedVersion,
+		});
+	} else if (snapshot !== undefined && version?.id === undefined) {
+		mc.logger.sendErrorEvent({
+			eventName: "getSnapshotFetchedTreeWithoutVersionId",
+			hasVersion: version !== undefined, // if hasVersion is true, this means that the contract with the service was broken.
+		});
+	}
+	return { snapshot, version };
+}
+
+/**
+ * Fetches an ISnapshotTree from a storage adapter based on the specified version.
+ *
+ * @param mc - The monitoring context.
+ * @param storageAdapter - The storage adapter providing methods to retrieve the ISnapshotTree and version.
+ * @param specifiedVersion - An optional version string specifying the version of the snapshot tree to fetch.
+ * @returns - The fetched snapshot tree and its version.
+ */
+export async function fetchISnapshotTree(
+	mc: MonitoringContext,
+	storageAdapter: Pick<IDocumentStorageService, "getSnapshotTree" | "getVersions">,
+	specifiedVersion: string | undefined,
+): Promise<{ snapshot?: ISnapshotTree; version?: IVersion | undefined }> {
+	const versions = await storageAdapter.getVersions(specifiedVersion ?? null, 1);
+	const version = versions[0];
+
+	if (version === undefined && specifiedVersion !== undefined) {
+		// We should have a defined version to load from if specified version requested
+		mc.logger.sendErrorEvent({
+			eventName: "NoVersionFoundWhenSpecified",
+			id: specifiedVersion,
+		});
+	}
+	const snapshot = (await storageAdapter.getSnapshotTree(version)) ?? undefined;
+
+	if (snapshot === undefined && version !== undefined) {
+		mc.logger.sendErrorEvent({ eventName: "getSnapshotTreeFailed", id: version.id });
+	} else if (snapshot !== undefined && version?.id === undefined) {
+		mc.logger.sendErrorEvent({
+			eventName: "getSnapshotFetchedTreeWithoutVersionId",
+			hasVersion: version !== undefined, // if hasVersion is true, this means that the contract with the service was broken.
+		});
+	}
+	return { snapshot, version };
+}

package/src/utils.ts

@@ -3,19 +3,34 @@
  * Licensed under the MIT License.
  */
 
-import { v4 as uuid } from "uuid";
-import { Uint8ArrayToString, stringToBuffer } from "@fluid-internal/client-utils";
-import { assert, compareArrays, unreachableCase } from "@fluidframework/core-utils";
-import { ISummaryTree, ISnapshotTree, SummaryType } from "@fluidframework/protocol-definitions";
-import { LoggingError, UsageError } from "@fluidframework/telemetry-utils";
+import { Uint8ArrayToString, bufferToString, stringToBuffer } from "@fluid-internal/client-utils";
+import { assert, compareArrays, unreachableCase } from "@fluidframework/core-utils/internal";
+import { DriverErrorTypes } from "@fluidframework/driver-definitions";
+import {
+	IDocumentStorageService,
+	type ISnapshot,
+} from "@fluidframework/driver-definitions/internal";
 import {
 	CombinedAppAndProtocolSummary,
 	DeltaStreamConnectionForbiddenError,
 	isCombinedAppAndProtocolSummary,
-} from "@fluidframework/driver-utils";
-import { DriverErrorTypes } from "@fluidframework/driver-definitions";
+	readAndParse,
+} from "@fluidframework/driver-utils/internal";
+import {
+	IDocumentAttributes,
+	ISnapshotTree,
+	ISummaryTree,
+	SummaryType,
+} from "@fluidframework/protocol-definitions";
+import { LoggingError, UsageError } from "@fluidframework/telemetry-utils/internal";
+import { v4 as uuid } from "uuid";
+
 import { ISerializableBlobContents } from "./containerStorageAdapter.js";
-import { IPendingDetachedContainerState } from "./container.js";
+import type {
+	IPendingDetachedContainerState,
+	ISnapshotInfo,
+	SnapshotWithBlobs,
+} from "./serializedStateManager.js";
 
 // This is used when we rehydrate a container from the snapshot. Here we put the blob contents
 // in separate property: blobContents.
@@ -28,7 +43,7 @@ export interface ISnapshotTreeWithBlobContents extends ISnapshotTree {
  * Interface to represent the parsed parts of IResolvedUrl.url to help
  * in getting info about different parts of the url.
  * May not be compatible or relevant for any Url Resolver
- * @internal
+ * @alpha
  */
 export interface IParsedUrl {
 	/**
@@ -57,7 +72,7 @@ export interface IParsedUrl {
  * with urls of type: protocol://<string>/.../..?<querystring>
  * @param url - This is the IResolvedUrl.url part of the resolved url.
  * @returns The IParsedUrl representing the input URL, or undefined if the format was not supported
- * @internal
+ * @alpha
  */
 export function tryParseCompatibleResolvedUrl(url: string): IParsedUrl | undefined {
 	const parsed = new URL(url);
@@ -111,10 +126,7 @@ export function combineAppAndProtocolSummary(
  * to align detached container format with IPendingContainerState
  * @param summary - ISummaryTree
  */
-function convertSummaryToSnapshotAndBlobs(summary: ISummaryTree): {
-	tree: ISnapshotTree;
-	blobs: ISerializableBlobContents;
-} {
+function convertSummaryToSnapshotAndBlobs(summary: ISummaryTree): SnapshotWithBlobs {
 	let blobContents: ISerializableBlobContents = {};
 	const treeNode: ISnapshotTree = {
 		blobs: {},
@@ -129,9 +141,9 @@ function convertSummaryToSnapshotAndBlobs(summary: ISummaryTree): {
 
 		switch (summaryObject.type) {
 			case SummaryType.Tree: {
-				const { tree, blobs } = convertSummaryToSnapshotAndBlobs(summaryObject);
-				treeNode.trees[key] = tree;
-				blobContents = { ...blobContents, ...blobs };
+				const innerSnapshot = convertSummaryToSnapshotAndBlobs(summaryObject);
+				treeNode.trees[key] = innerSnapshot.baseSnapshot;
+				blobContents = { ...blobContents, ...innerSnapshot.snapshotBlobs };
 				break;
 			}
 			case SummaryType.Attachment:
@@ -151,13 +163,58 @@ function convertSummaryToSnapshotAndBlobs(summary: ISummaryTree): {
 				throw new LoggingError(
 					"No handles should be there in summary in detached container!!",
 				);
-				break;
 			default: {
 				unreachableCase(summaryObject, `Unknown tree type ${(summaryObject as any).type}`);
 			}
 		}
 	}
-	return { tree: treeNode, blobs: blobContents };
+	const pendingSnapshot = { baseSnapshot: treeNode, snapshotBlobs: blobContents };
+	return pendingSnapshot;
+}
+
+/**
+ * Converts a snapshot to snapshotInfo with its blob contents
+ * to align detached container format with IPendingContainerState
+ *
+ * Note, this assumes the ISnapshot sequence number is defined. Otherwise an assert will be thrown
+ * @param snapshot - ISnapshot
+ */
+export function convertSnapshotToSnapshotInfo(snapshot: ISnapshot): ISnapshotInfo {
+	assert(snapshot.sequenceNumber !== undefined, 0x93a /* Snapshot sequence number is missing */);
+	const snapshotBlobs: ISerializableBlobContents = {};
+	for (const [blobId, arrayBufferLike] of snapshot.blobContents.entries()) {
+		snapshotBlobs[blobId] = bufferToString(arrayBufferLike, "utf8");
+	}
+	return {
+		baseSnapshot: snapshot.snapshotTree,
+		snapshotBlobs,
+		snapshotSequenceNumber: snapshot.sequenceNumber,
+	};
+}
+
+/**
+ * Converts a snapshot to snapshotInfo with its blob contents
+ * to align detached container format with IPendingContainerState
+ *
+ * Note, this assumes the ISnapshot sequence number is defined. Otherwise an assert will be thrown
+ * @param snapshot - ISnapshot
+ */
+export function convertSnapshotInfoToSnapshot(
+	snapshotInfo: ISnapshotInfo,
+	snapshotSequenceNumber: number,
+): ISnapshot {
+	const blobContents = new Map<string, ArrayBufferLike>();
+	for (const [blobId, serializedContent] of Object.entries(snapshotInfo.snapshotBlobs)) {
+		blobContents.set(blobId, stringToBuffer(serializedContent, "utf8"));
+	}
+	return {
+		snapshotTree: snapshotInfo.baseSnapshot,
+		blobContents,
+		ops: [],
+		sequenceNumber: snapshotSequenceNumber,
+		latestSequenceNumber: undefined,
+		snapshotFormatV: 1,
+	};
 }
 
 /**
@@ -168,7 +225,7 @@ function convertSummaryToSnapshotAndBlobs(summary: ISummaryTree): {
 function convertProtocolAndAppSummaryToSnapshotAndBlobs(
 	protocolSummaryTree: ISummaryTree,
 	appSummaryTree: ISummaryTree,
-): { tree: ISnapshotTree; blobs: ISerializableBlobContents } {
+): SnapshotWithBlobs {
 	const combinedSummary: ISummaryTree = {
 		type: SummaryType.Tree,
 		tree: { ...appSummaryTree.tree },
@@ -181,7 +238,7 @@ function convertProtocolAndAppSummaryToSnapshotAndBlobs(
 
 export const getSnapshotTreeAndBlobsFromSerializedContainer = (
 	detachedContainerSnapshot: ISummaryTree,
-): { tree: ISnapshotTree; blobs: ISerializableBlobContents } => {
+): SnapshotWithBlobs => {
 	assert(
 		isCombinedAppAndProtocolSummary(detachedContainerSnapshot),
 		0x8e6 /* Protocol and App summary trees should be present */,
@@ -264,12 +321,12 @@ export function getDetachedContainerStateFromSerializedContainer(
 	if (isPendingDetachedContainerState(parsedContainerState)) {
 		return parsedContainerState;
 	} else if (isCombinedAppAndProtocolSummary(parsedContainerState)) {
-		const { tree, blobs } =
+		const { baseSnapshot, snapshotBlobs } =
 			getSnapshotTreeAndBlobsFromSerializedContainer(parsedContainerState);
 		const detachedContainerState: IPendingDetachedContainerState = {
 			attached: false,
-			baseSnapshot: tree,
-			snapshotBlobs: blobs,
+			baseSnapshot,
+			snapshotBlobs,
 			hasAttachmentBlobs: parsedContainerState.tree[hasBlobsSummaryTree] !== undefined,
 		};
 		return detachedContainerState;
@@ -305,3 +362,25 @@ export const runSingle = <A extends any[], R>(func: (...args: A) => Promise<R>)
 		return running.result;
 	};
 };
+
+export async function getDocumentAttributes(
+	storage: Pick<IDocumentStorageService, "readBlob">,
+	tree: ISnapshotTree | undefined,
+): Promise<IDocumentAttributes> {
+	if (tree === undefined) {
+		return {
+			minimumSequenceNumber: 0,
+			sequenceNumber: 0,
+		};
+	}
+
+	// Backward compatibility: old docs would have ".attributes" instead of "attributes"
+	const attributesHash =
+		".protocol" in tree.trees
+			? tree.trees[".protocol"].blobs.attributes
+			: tree.blobs[".attributes"];
+
+	const attributes = await readAndParse<IDocumentAttributes>(storage, attributesHash);
+
+	return attributes;
+}