@fluidframework/routerlicious-driver 2.0.0-dev.4.2.0.153917 → 2.0.0-dev.4.3.0.158678

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/routerlicious-driver";
-export const pkgVersion = "2.0.0-dev.4.2.0.153917";
+export const pkgVersion = "2.0.0-dev.4.3.0.158678";

package/src/r11sSnapshotParser.ts

@@ -0,0 +1,83 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ISnapshotTree } from "@fluidframework/protocol-definitions";
+import { IWholeFlatSummary, IWholeFlatSummaryTree } from "@fluidframework/server-services-client";
+import { stringToBuffer } from "@fluidframework/common-utils";
+import { INormalizedWholeSummary } from "./contracts";
+
+/**
+ * Build a tree heirarchy from a flat tree.
+ *
+ * @param flatTree - a flat tree
+ * @param treePrefixToRemove - tree prefix to strip
+ * @returns the heirarchical tree
+ */
+function buildHierarchy(
+	flatTree: IWholeFlatSummaryTree,
+	treePrefixToRemove: string,
+): ISnapshotTree {
+	const lookup: { [path: string]: ISnapshotTree } = {};
+	// Root tree id will be used to determine which version was downloaded.
+	const root: ISnapshotTree = { id: flatTree.id, blobs: {}, trees: {} };
+	lookup[""] = root;
+
+	for (const entry of flatTree.entries) {
+		// Strip the `treePrefixToRemove` path from tree entries such that they are stored under root.
+		const entryPath = entry.path.replace(new RegExp(`^${treePrefixToRemove}/`), "");
+		const lastIndex = entryPath.lastIndexOf("/");
+		const entryPathDir = entryPath.slice(0, Math.max(0, lastIndex));
+		const entryPathBase = entryPath.slice(lastIndex + 1);
+
+		// The flat output is breadth-first so we can assume we see tree nodes prior to their contents
+		const node = lookup[entryPathDir];
+
+		// Add in either the blob or tree
+		if (entry.type === "tree") {
+			const newTree: ISnapshotTree = {
+				blobs: {},
+				trees: {},
+				unreferenced: entry.unreferenced,
+			};
+			node.trees[decodeURIComponent(entryPathBase)] = newTree;
+			lookup[entryPath] = newTree;
+		} else if (entry.type === "blob") {
+			node.blobs[decodeURIComponent(entryPathBase)] = entry.id;
+		} else {
+			throw new Error(`Unknown entry type!!`);
+		}
+	}
+
+	return root;
+}
+
+/**
+ * Converts existing IWholeFlatSummary to snapshot tree, blob array, and sequence number.
+ *
+ * @param flatSummary - flat summary
+ * @param treePrefixToRemove - tree prefix to strip. By default we are stripping ".app" prefix
+ * @returns snapshot tree, blob array, and sequence number
+ */
+export function convertWholeFlatSummaryToSnapshotTreeAndBlobs(
+	flatSummary: IWholeFlatSummary,
+	treePrefixToRemove: string = ".app",
+): INormalizedWholeSummary {
+	const blobs = new Map<string, ArrayBuffer>();
+	if (flatSummary.blobs) {
+		flatSummary.blobs.forEach((blob) => {
+			blobs.set(blob.id, stringToBuffer(blob.content, blob.encoding ?? "utf-8"));
+		});
+	}
+	const flatSummaryTree = flatSummary.trees?.[0];
+	const sequenceNumber = flatSummaryTree?.sequenceNumber;
+	const snapshotTree = buildHierarchy(flatSummaryTree, treePrefixToRemove);
+
+	return {
+		blobs,
+		snapshotTree,
+		sequenceNumber,
+		id: flatSummary.id,
+	};
+}

package/src/restWrapper.ts

@@ -203,7 +203,7 @@ export class RouterliciousRestWrapper extends RestWrapper {
 		requestHeaders?: AxiosRequestHeaders | undefined,
 	): Promise<Record<string, string>> {
 		const token = await this.getToken();
-		assert(token !== undefined, "token should be present");
+		assert(token !== undefined, 0x679 /* token should be present */);
 		const correlationId = requestHeaders?.["x-correlation-id"] ?? uuid();
 
 		return {

package/src/treeUtils.ts

@@ -10,7 +10,7 @@ import {
 	ISummaryTree,
 	SummaryObject,
 } from "@fluidframework/protocol-definitions";
-import { INormalizedWholeSummary } from "@fluidframework/server-services-client";
+import { INormalizedWholeSummary } from "./contracts";
 
 /**
  * Summary tree assembler props

package/src/wholeSummaryDocumentStorageService.ts

@@ -23,11 +23,7 @@ import {
 	ISummaryTree,
 	IVersion,
 } from "@fluidframework/protocol-definitions";
-import {
-	convertWholeFlatSummaryToSnapshotTreeAndBlobs,
-	INormalizedWholeSummary,
-	IWholeFlatSummary,
-} from "@fluidframework/server-services-client";
+import { IWholeFlatSummary } from "@fluidframework/server-services-client";
 import { PerformanceEvent } from "@fluidframework/telemetry-utils";
 import { ICache, InMemoryCache } from "./cache";
 import { IRouterliciousDriverPolicies } from "./policies";
@@ -40,6 +36,8 @@ import { GitManager } from "./gitManager";
 import { WholeSummaryUploadManager } from "./wholeSummaryUploadManager";
 import { ISummaryUploadManager } from "./storageContracts";
 import { IR11sResponse } from "./restWrapper";
+import { INormalizedWholeSummary } from "./contracts";
+import { convertWholeFlatSummaryToSnapshotTreeAndBlobs } from "./r11sSnapshotParser";
 
 const latestSnapshotId: string = "latest";
 
@@ -100,8 +98,8 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
 					);
 
 					const networkSnapshotP = !this.driverPolicies?.enableDiscovery
-						? this.fetchSnapshotTree(latestSnapshotId, false)
-						: this.fetchSnapshotTree(latestSnapshotId, true);
+						? this.fetchSnapshotTree(latestSnapshotId, false, "getVersions")
+						: this.fetchSnapshotTree(latestSnapshotId, true, "getVersions");
 
 					const promiseRaceWinner = await promiseRaceWithWinner([
 						cachedSnapshotP.catch(() => undefined),
@@ -130,10 +128,7 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
 				},
 			);
 
-			const _id = await this.initializeFromSnapshot(
-				normalizedSnapshotContents,
-				latestSnapshotId,
-			);
+			const _id = await this.initializeFromSnapshot(normalizedSnapshotContents);
 			this.firstVersionsCall = false;
 			return [
 				{
@@ -181,7 +176,8 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
 		if (normalizedWholeSnapshot !== undefined) {
 			return normalizedWholeSnapshot.snapshotTree;
 		}
-		return (await this.fetchSnapshotTree(requestVersion.id)).snapshotTree;
+		return (await this.fetchSnapshotTree(requestVersion.id, undefined, "getSnapshotTree"))
+			.snapshotTree;
 	}
 
 	public async readBlob(blobId: string): Promise<ArrayBufferLike> {
@@ -284,12 +280,14 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
 	private async fetchSnapshotTree(
 		versionId: string,
 		disableCache?: boolean,
+		scenarioName?: string,
 	): Promise<INormalizedWholeSummary> {
 		const normalizedWholeSummary = await PerformanceEvent.timedExecAsync(
 			this.logger,
 			{
 				eventName: "getWholeFlatSummary",
 				treeId: versionId,
+				scenarioName,
 			},
 			async (event) => {
 				const manager = await this.getStorageManager(disableCache);
@@ -316,35 +314,26 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
 			},
 		);
 
+		// Also add the result into the cache.
+		await this.snapshotTreeCache
+			.put(this.getCacheKey(versionId), normalizedWholeSummary)
+			.catch(() => undefined);
 		return normalizedWholeSummary;
 	}
 
 	private async initializeFromSnapshot(
 		normalizedWholeSummary: INormalizedWholeSummary,
-		versionId: string | null,
 	): Promise<string> {
-		const wholeFlatSummaryId = normalizedWholeSummary.snapshotTree.id;
-		assert(wholeFlatSummaryId !== undefined, 0x275 /* "Root tree should contain the id" */);
+		const snapshotId = normalizedWholeSummary.id;
+		assert(snapshotId !== undefined, 0x275 /* "Root tree should contain the id" */);
 		const cachePs: Promise<any>[] = [
-			this.snapshotTreeCache.put(
-				this.getCacheKey(wholeFlatSummaryId),
-				normalizedWholeSummary,
-			),
+			this.snapshotTreeCache.put(this.getCacheKey(snapshotId), normalizedWholeSummary),
 			this.initBlobCache(normalizedWholeSummary.blobs),
 		];
-		if (wholeFlatSummaryId !== versionId && versionId !== null) {
-			// versionId could be "latest". When summarizer checks cache for "latest", we want it to be available.
-			// TODO: For in-memory cache, <latest,snapshotTree> will be a shared pointer with <snapshotId,snapshotTree>,
-			// However, for something like Redis, this will cache the same value twice. Alternatively, could we simply
-			// cache with versionId?
-			cachePs.push(
-				this.snapshotTreeCache.put(this.getCacheKey(versionId), normalizedWholeSummary),
-			);
-		}
 
 		await Promise.all(cachePs);
 
-		return wholeFlatSummaryId;
+		return snapshotId;
 	}
 
 	private async initBlobCache(blobs: Map<string, ArrayBuffer>): Promise<void> {