@fluidframework/container-loader 2.0.0-dev-rc.2.0.0.246488 → 2.0.0-dev-rc.3.0.0.253463

package/src/loader.ts

@@ -3,44 +3,46 @@
  * Licensed under the MIT License.
  */
 
-import { v4 as uuid } from "uuid";
-import {
-	ITelemetryLoggerExt,
-	mixinMonitoringContext,
-	MonitoringContext,
-	PerformanceEvent,
-	sessionStorageConfigProvider,
-	createChildMonitoringContext,
-	UsageError,
-} from "@fluidframework/telemetry-utils";
-import {
-	ITelemetryBaseLogger,
-	FluidObject,
-	IRequest,
-	IConfigProviderBase,
-} from "@fluidframework/core-interfaces";
 import {
 	IContainer,
+	IFluidCodeDetails,
 	IFluidModule,
 	IHostLoader,
 	ILoader,
 	ILoaderOptions as ILoaderOptions1,
-	LoaderHeader,
 	IProvideFluidCodeDetailsComparer,
-	IFluidCodeDetails,
-} from "@fluidframework/container-definitions";
+	LoaderHeader,
+} from "@fluidframework/container-definitions/internal";
+import {
+	FluidObject,
+	IConfigProviderBase,
+	IRequest,
+	ITelemetryBaseLogger,
+} from "@fluidframework/core-interfaces";
 import {
 	IDocumentServiceFactory,
 	IDocumentStorageService,
 	IResolvedUrl,
 	IUrlResolver,
-} from "@fluidframework/driver-definitions";
+} from "@fluidframework/driver-definitions/internal";
 import { IClientDetails } from "@fluidframework/protocol-definitions";
-import { Container, IPendingContainerState } from "./container.js";
-import { tryParseCompatibleResolvedUrl } from "./utils.js";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
+import {
+	MonitoringContext,
+	PerformanceEvent,
+	UsageError,
+	createChildMonitoringContext,
+	mixinMonitoringContext,
+	sessionStorageConfigProvider,
+} from "@fluidframework/telemetry-utils/internal";
+import { v4 as uuid } from "uuid";
+
+import { Container } from "./container.js";
+import { DebugLogger } from "./debugLogger.js";
 import { pkgVersion } from "./packageVersion.js";
 import { ProtocolHandlerBuilder } from "./protocol.js";
-import { DebugLogger } from "./debugLogger.js";
+import type { IPendingContainerState } from "./serializedStateManager.js";
+import { tryParseCompatibleResolvedUrl } from "./utils.js";
 
 function ensureResolvedUrlDefined(
 	resolved: IResolvedUrl | undefined,

package/src/location-redirection-utilities/resolveWithLocationRedirection.ts

@@ -3,13 +3,13 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryBaseLogger, IRequest } from "@fluidframework/core-interfaces";
+import { IRequest, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { DriverErrorTypes } from "@fluidframework/driver-definitions";
 import {
-	DriverErrorTypes,
 	ILocationRedirectionError,
 	IUrlResolver,
-} from "@fluidframework/driver-definitions";
-import { createChildLogger } from "@fluidframework/telemetry-utils";
+} from "@fluidframework/driver-definitions/internal";
+import { createChildLogger } from "@fluidframework/telemetry-utils/internal";
 
 /**
  * Checks if the error is location redirection error.

package/src/noopHeuristic.ts

@@ -4,10 +4,10 @@
  */
 
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
-import { assert, Timer } from "@fluidframework/core-utils";
-import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
-import { isRuntimeMessage } from "@fluidframework/driver-utils";
 import { IEvent } from "@fluidframework/core-interfaces";
+import { assert, Timer } from "@fluidframework/core-utils/internal";
+import { isRuntimeMessage } from "@fluidframework/driver-utils/internal";
+import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 
 const defaultNoopTimeFrequency = 2000;
 const defaultNoopCountFrequency = 50;

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-loader";
-export const pkgVersion = "2.0.0-dev-rc.2.0.0.246488";
+export const pkgVersion = "2.0.0-dev-rc.3.0.0.253463";

package/src/protocol.ts

@@ -3,8 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { IAudienceOwner } from "@fluidframework/container-definitions";
-import { canBeCoalescedByService } from "@fluidframework/driver-utils";
+import { IAudienceOwner } from "@fluidframework/container-definitions/internal";
+import { canBeCoalescedByService } from "@fluidframework/driver-utils/internal";
 import {
 	IProtocolHandler as IBaseProtocolHandler,
 	IQuorumSnapshot,

package/src/protocolTreeDocumentStorageService.ts

@@ -4,7 +4,10 @@
  */
 
 import { IDisposable } from "@fluidframework/core-interfaces";
-import { IDocumentStorageService, ISummaryContext } from "@fluidframework/driver-definitions";
+import {
+	IDocumentStorageService,
+	ISummaryContext,
+} from "@fluidframework/driver-definitions/internal";
 import { ISummaryTree } from "@fluidframework/protocol-definitions";
 
 /**

package/src/quorum.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { IFluidCodeDetails } from "@fluidframework/core-interfaces";
+import { IFluidCodeDetails } from "@fluidframework/container-definitions/internal";
 import { ICommittedProposal } from "@fluidframework/protocol-definitions";
 
 export function initQuorumValuesFromCodeDetails(

package/src/retriableDocumentStorageService.ts

@@ -3,7 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
+import { IDisposable } from "@fluidframework/core-interfaces";
+import { assert } from "@fluidframework/core-utils/internal";
 import {
 	FetchSource,
 	IDocumentStorageService,
@@ -11,7 +12,8 @@ import {
 	ISnapshot,
 	ISnapshotFetchOptions,
 	ISummaryContext,
-} from "@fluidframework/driver-definitions";
+} from "@fluidframework/driver-definitions/internal";
+import { runWithRetry } from "@fluidframework/driver-utils/internal";
 import {
 	ICreateBlobResponse,
 	ISnapshotTree,
@@ -19,9 +21,8 @@ import {
 	ISummaryTree,
 	IVersion,
 } from "@fluidframework/protocol-definitions";
-import { IDisposable } from "@fluidframework/core-interfaces";
-import { GenericError, ITelemetryLoggerExt, UsageError } from "@fluidframework/telemetry-utils";
-import { runWithRetry } from "@fluidframework/driver-utils";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
+import { GenericError, UsageError } from "@fluidframework/telemetry-utils/internal";
 
 export class RetriableDocumentStorageService implements IDocumentStorageService, IDisposable {
 	private _disposed = false;

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;
+}
+
+interface SnapshotInfo extends SnapshotWithBlobs {
+	snapshotSequenceNumber: number;
+}
 
 export class SerializedStateManager {
 	private readonly processedOps: ISequencedDocumentMessage[] = [];
-	private snapshot:
-		| {
-				tree: ISnapshotTree;
-				blobs: ISerializableBlobContents;
-		  }
-		| undefined;
+	private snapshot: SnapshotWithBlobs | undefined;
 	private readonly mc: MonitoringContext;
+	private latestSnapshot: SnapshotInfo | 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,96 @@ 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,
+				);
+				this.snapshot = { baseSnapshot, snapshotBlobs };
 			}
-		}
-		return { snapshotTree, version };
-	}
+			return { baseSnapshot, version };
+		} else {
+			const { baseSnapshot, snapshotBlobs } = this.pendingLocalState;
+			this.snapshot = { baseSnapshot, snapshotBlobs };
+			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) {
+			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;
+		if (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 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({
+				category:
+					snapshotSequenceNumber < firstProcessedOpSequenceNumber - 1
+						? "error"
+						: "generic",
+				eventName: "OldSnapshotFetchWhileRefreshing",
+				snapshotSequenceNumber,
+				firstProcessedOpSequenceNumber,
+			});
+			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,14 +202,7 @@ export class SerializedStateManager {
 	 * base snapshot when attaching.
 	 * @param snapshot - snapshot and blobs collected while attaching
 	 */
-	public setSnapshot(
-		snapshot:
-			| {
-					tree: ISnapshotTree;
-					blobs: ISerializableBlobContents;
-			  }
-			| undefined,
-	) {
+	public setSnapshot(snapshot: SnapshotWithBlobs | undefined) {
 		this.snapshot = snapshot;
 	}
 
@@ -202,8 +231,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 +244,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<SnapshotInfo | 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 };
+}