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

package/src/documentService.ts

@@ -5,11 +5,12 @@
 
 import { assert } from "@fluidframework/common-utils";
 import * as api from "@fluidframework/driver-definitions";
-import { RateLimiter } from "@fluidframework/driver-utils";
+import { DriverErrorType } from "@fluidframework/driver-definitions";
+import { RateLimiter, NetworkErrorBasic, canRetryOnError } from "@fluidframework/driver-utils";
 import { IClient } from "@fluidframework/protocol-definitions";
-import { GitManager, Historian, RestWrapper } from "@fluidframework/server-services-client";
+import { INormalizedWholeSummary } from "@fluidframework/server-services-client";
 import io from "socket.io-client";
-import { PerformanceEvent } from "@fluidframework/telemetry-utils";
+import { PerformanceEvent, wrapError } from "@fluidframework/telemetry-utils";
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { DeltaStorageService, DocumentDeltaStorageService } from "./deltaStorageService";
 import { DocumentStorageService } from "./documentStorageService";
@@ -20,6 +21,10 @@ import { RouterliciousOrdererRestWrapper, RouterliciousStorageRestWrapper } from
 import { IRouterliciousDriverPolicies } from "./policies";
 import { ICache } from "./cache";
 import { ISnapshotTreeVersion } from "./definitions";
+import { pkgVersion as driverVersion } from "./packageVersion";
+import { GitManager } from "./gitManager";
+import { Historian } from "./historian";
+import { RestWrapper } from "./restWrapperBase";
 
 /**
  * Amount of time between discoveries within which we don't need to rediscover on re-connect.
@@ -59,7 +64,8 @@ export class DocumentService implements api.IDocumentService {
 		private readonly documentStorageServicePolicies: api.IDocumentStorageServicePolicies,
 		private readonly driverPolicies: IRouterliciousDriverPolicies,
 		private readonly blobCache: ICache<ArrayBufferLike>,
-		private readonly snapshotTreeCache: ICache<ISnapshotTreeVersion>,
+		private readonly wholeSnapshotTreeCache: ICache<INormalizedWholeSummary>,
+		private readonly shreddedSummaryTreeCache: ICache<ISnapshotTreeVersion>,
 		private readonly discoverFluidResolvedUrl: () => Promise<api.IFluidResolvedUrl>,
 	) {}
 
@@ -103,14 +109,9 @@ export class DocumentService implements api.IDocumentService {
 					this.driverPolicies.enableRestLess,
 					this.storageUrl,
 				);
-				const historian = new Historian(this.storageUrl, true, false, storageRestWrapper);
+				const historian = new Historian(true, false, storageRestWrapper);
 				this.storageManager = new GitManager(historian);
-				const noCacheHistorian = new Historian(
-					this.storageUrl,
-					true,
-					true,
-					storageRestWrapper,
-				);
+				const noCacheHistorian = new Historian(true, true, storageRestWrapper);
 				this.noCacheStorageManager = new GitManager(noCacheHistorian);
 			}
 
@@ -126,7 +127,8 @@ export class DocumentService implements api.IDocumentService {
 			this.documentStorageServicePolicies,
 			this.driverPolicies,
 			this.blobCache,
-			this.snapshotTreeCache,
+			this.wholeSnapshotTreeCache,
+			this.shreddedSummaryTreeCache,
 			noCacheStorageManager,
 			getStorageManager,
 		);
@@ -185,7 +187,7 @@ export class DocumentService implements api.IDocumentService {
 	 */
 	public async connectToDeltaStream(client: IClient): Promise<api.IDocumentDeltaConnection> {
 		const connect = async (refreshToken?: boolean) => {
-			let ordererToken = this.ordererRestWrapper.getToken();
+			let ordererToken = await this.ordererRestWrapper.getToken();
 			if (this.shouldUpdateDiscoveredSessionInfo()) {
 				await this.refreshDiscovery();
 			}
@@ -200,15 +202,28 @@ export class DocumentService implements api.IDocumentService {
 							refreshToken,
 						}),
 					},
-					async () => {
-						const newOrdererToken = await this.tokenProvider.fetchOrdererToken(
-							this.tenantId,
-							this.documentId,
-							refreshToken,
-						);
-						this.ordererRestWrapper.setToken(newOrdererToken);
-						return newOrdererToken;
-					},
+					async () =>
+						this.tokenProvider
+							.fetchOrdererToken(this.tenantId, this.documentId, refreshToken)
+							.then(
+								(newOrdererToken) => {
+									this.ordererRestWrapper.setToken(newOrdererToken);
+									return newOrdererToken;
+								},
+								(error) => {
+									const tokenError = wrapError(
+										error,
+										(errorMessage) =>
+											new NetworkErrorBasic(
+												`The Host-provided token fetcher threw an error`,
+												DriverErrorType.fetchTokenError,
+												canRetryOnError(error),
+												{ errorMessage, driverVersion },
+											),
+									);
+									throw tokenError;
+								},
+							),
 				);
 			}
 

package/src/documentServiceFactory.ts

@@ -4,6 +4,7 @@
  */
 
 import { assert } from "@fluidframework/common-utils";
+import { getW3CData } from "@fluidframework/driver-base";
 import {
 	FiveDaysMs,
 	IDocumentService,
@@ -19,10 +20,11 @@ import {
 	ensureFluidResolvedUrl,
 	getDocAttributesFromProtocolSummary,
 	getQuorumValuesFromProtocolSummary,
+	isCombinedAppAndProtocolSummary,
 	RateLimiter,
 } from "@fluidframework/driver-utils";
 import { ChildLogger, PerformanceEvent } from "@fluidframework/telemetry-utils";
-import { ISession } from "@fluidframework/server-services-client";
+import { INormalizedWholeSummary, ISession } from "@fluidframework/server-services-client";
 import { DocumentService } from "./documentService";
 import { IRouterliciousDriverPolicies } from "./policies";
 import { ITokenProvider } from "./tokens";
@@ -51,10 +53,10 @@ const defaultRouterliciousDriverPolicies: IRouterliciousDriverPolicies = {
  * use the routerlicious implementation.
  */
 export class RouterliciousDocumentServiceFactory implements IDocumentServiceFactory {
-	public readonly protocolName = "fluid:";
 	private readonly driverPolicies: IRouterliciousDriverPolicies;
 	private readonly blobCache: ICache<ArrayBufferLike>;
-	private readonly snapshotTreeCache: ICache<ISnapshotTreeVersion>;
+	private readonly wholeSnapshotTreeCache: ICache<INormalizedWholeSummary> = new NullCache();
+	private readonly shreddedSummaryTreeCache: ICache<ISnapshotTreeVersion> = new NullCache();
 
 	constructor(
 		private readonly tokenProvider: ITokenProvider,
@@ -68,9 +70,17 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
 			...driverPolicies,
 		};
 		this.blobCache = new InMemoryCache<ArrayBufferLike>();
-		this.snapshotTreeCache = this.driverPolicies.enableInternalSummaryCaching
-			? new InMemoryCache<ISnapshotTreeVersion>(snapshotCacheExpiryMs)
-			: new NullCache<ISnapshotTreeVersion>();
+		if (this.driverPolicies.enableInternalSummaryCaching) {
+			if (this.driverPolicies.enableWholeSummaryUpload) {
+				this.wholeSnapshotTreeCache = new InMemoryCache<INormalizedWholeSummary>(
+					snapshotCacheExpiryMs,
+				);
+			} else {
+				this.shreddedSummaryTreeCache = new InMemoryCache<ISnapshotTreeVersion>(
+					snapshotCacheExpiryMs,
+				);
+			}
+		}
 	}
 
 	/**
@@ -96,11 +106,12 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
 		}
 		const [, tenantId] = parsedUrl.pathname.split("/");
 
-		const protocolSummary = createNewSummary.tree[".protocol"] as ISummaryTree;
-		const appSummary = createNewSummary.tree[".app"] as ISummaryTree;
-		if (!(protocolSummary && appSummary)) {
+		if (!isCombinedAppAndProtocolSummary(createNewSummary)) {
 			throw new Error("Protocol and App Summary required in the full summary");
 		}
+		const protocolSummary = createNewSummary.tree[".protocol"];
+		const appSummary = createNewSummary.tree[".app"];
+
 		const documentAttributes = getDocAttributesFromProtocolSummary(protocolSummary);
 		const quorumValues = getQuorumValuesFromProtocolSummary(protocolSummary);
 
@@ -127,15 +138,17 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
 			},
 			async (event) => {
 				// @TODO: Remove returned "string" type when removing back-compat code
-				const postRes = await ordererRestWrapper.post<
-					{ id: string; token?: string; session?: ISession } | string
-				>(`/documents/${tenantId}`, {
-					summary: convertSummaryToCreateNewSummary(appSummary),
-					sequenceNumber: documentAttributes.sequenceNumber,
-					values: quorumValues,
-					enableDiscovery: this.driverPolicies.enableDiscovery,
-					generateToken: this.tokenProvider.documentPostCreateCallback !== undefined,
-				});
+				const postRes = (
+					await ordererRestWrapper.post<
+						{ id: string; token?: string; session?: ISession } | string
+					>(`/documents/${tenantId}`, {
+						summary: convertSummaryToCreateNewSummary(appSummary),
+						sequenceNumber: documentAttributes.sequenceNumber,
+						values: quorumValues,
+						enableDiscovery: this.driverPolicies.enableDiscovery,
+						generateToken: this.tokenProvider.documentPostCreateCallback !== undefined,
+					})
+				).content;
 
 				event.end({
 					docId: typeof postRes === "string" ? postRes : postRes.id,
@@ -252,11 +265,16 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
 					eventName: "DiscoverSession",
 					docId: documentId,
 				},
-				async () => {
+				async (event) => {
 					// The service responds with the current document session associated with the container.
-					return ordererRestWrapper.get<ISession>(
+					const response = await ordererRestWrapper.get<ISession>(
 						`${resolvedUrl.endpoints.ordererUrl}/documents/${tenantId}/session/${documentId}`,
 					);
+					event.end({
+						...response.propsToLog,
+						...getW3CData(response.requestUrl, "xmlhttprequest"),
+					});
+					return response.content;
 				},
 			);
 			return getDiscoveredFluidResolvedUrl(resolvedUrl, discoveredSession);
@@ -298,7 +316,8 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
 			documentStorageServicePolicies,
 			this.driverPolicies,
 			this.blobCache,
-			this.snapshotTreeCache,
+			this.wholeSnapshotTreeCache,
+			this.shreddedSummaryTreeCache,
 			discoverFluidResolvedUrl,
 		);
 	}

package/src/documentStorageService.ts

@@ -10,15 +10,16 @@ import {
 	LoaderCachingPolicy,
 } from "@fluidframework/driver-definitions";
 import { ISnapshotTree, IVersion } from "@fluidframework/protocol-definitions";
-import { GitManager } from "@fluidframework/server-services-client";
 import {
 	DocumentStorageServiceProxy,
 	PrefetchDocumentStorageService,
 } from "@fluidframework/driver-utils";
+import { INormalizedWholeSummary } from "@fluidframework/server-services-client";
 import { IRouterliciousDriverPolicies } from "./policies";
 import { ICache } from "./cache";
 import { WholeSummaryDocumentStorageService } from "./wholeSummaryDocumentStorageService";
 import { ShreddedSummaryDocumentStorageService } from "./shreddedSummaryDocumentStorageService";
+import { GitManager } from "./gitManager";
 import { ISnapshotTreeVersion } from "./definitions";
 
 export class DocumentStorageService extends DocumentStorageServiceProxy {
@@ -35,7 +36,8 @@ export class DocumentStorageService extends DocumentStorageServiceProxy {
 		policies: IDocumentStorageServicePolicies,
 		driverPolicies?: IRouterliciousDriverPolicies,
 		blobCache?: ICache<ArrayBufferLike>,
-		snapshotTreeCache?: ICache<ISnapshotTreeVersion>,
+		snapshotTreeCache?: ICache<INormalizedWholeSummary>,
+		shreddedSummaryTreeCache?: ICache<ISnapshotTreeVersion>,
 		noCacheGitManager?: GitManager,
 		getStorageManager?: (disableCache?: boolean) => Promise<GitManager>,
 	): IDocumentStorageService {
@@ -58,7 +60,7 @@ export class DocumentStorageService extends DocumentStorageServiceProxy {
 					policies,
 					driverPolicies,
 					blobCache,
-					snapshotTreeCache,
+					shreddedSummaryTreeCache,
 					getStorageManager,
 			  );
 		// TODO: worth prefetching latest summary making version + snapshot call with WholeSummary storage?
@@ -78,7 +80,8 @@ export class DocumentStorageService extends DocumentStorageServiceProxy {
 		policies: IDocumentStorageServicePolicies,
 		driverPolicies?: IRouterliciousDriverPolicies,
 		blobCache?: ICache<ArrayBufferLike>,
-		snapshotTreeCache?: ICache<ISnapshotTreeVersion>,
+		snapshotTreeCache?: ICache<INormalizedWholeSummary>,
+		shreddedSummaryTreeCache?: ICache<ISnapshotTreeVersion>,
 		public noCacheGitManager?: GitManager,
 		getStorageManager?: (disableCache?: boolean) => Promise<GitManager>,
 	) {
@@ -91,6 +94,7 @@ export class DocumentStorageService extends DocumentStorageServiceProxy {
 				driverPolicies,
 				blobCache,
 				snapshotTreeCache,
+				shreddedSummaryTreeCache,
 				noCacheGitManager,
 				getStorageManager,
 			),

package/src/errorUtils.ts

@@ -12,8 +12,16 @@ import {
 } from "@fluidframework/driver-utils";
 import { pkgVersion as driverVersion } from "./packageVersion";
 
-export enum R11sErrorType {
+/**
+ * Routerlicious Error types
+ * Different error types that may be thrown by the routerlicious driver
+ */
+export enum RouterliciousErrorType {
+	/**
+	 * File not found, or file deleted during session
+	 */
 	fileNotFoundOrAccessDeniedError = "fileNotFoundOrAccessDeniedError",
+
 	sslCertError = "sslCertError",
 }
 
@@ -48,7 +56,7 @@ export interface IR11sSocketError {
 }
 
 export interface IR11sError {
-	readonly errorType: R11sErrorType;
+	readonly errorType: RouterliciousErrorType;
 	readonly message: string;
 	canRetry: boolean;
 }
@@ -69,7 +77,11 @@ export function createR11sNetworkError(
 			// If there exists a self-signed SSL certificates error, throw a NonRetryableError
 			// TODO: instead of relying on string matching, filter error based on the error code like we do for websocket connections
 			if (errorMessage.includes("failed, reason: self signed certificate")) {
-				return new NonRetryableError(errorMessage, R11sErrorType.sslCertError, props);
+				return new NonRetryableError(
+					errorMessage,
+					RouterliciousErrorType.sslCertError,
+					props,
+				);
 			}
 			return new GenericNetworkError(
 				errorMessage,
@@ -82,7 +94,7 @@ export function createR11sNetworkError(
 		case 403:
 			return new AuthorizationError(errorMessage, undefined, undefined, props);
 		case 404:
-			const errorType = R11sErrorType.fileNotFoundOrAccessDeniedError;
+			const errorType = RouterliciousErrorType.fileNotFoundOrAccessDeniedError;
 			return new NonRetryableError(errorMessage, errorType, props);
 		case 429:
 			return createGenericNetworkError(errorMessage, { canRetry: true, retryAfterMs }, props);

package/src/gitManager.ts

@@ -0,0 +1,116 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import * as resources from "@fluidframework/gitresources";
+import {
+	IWholeFlatSummary,
+	IWholeSummaryPayload,
+	IWriteSummaryResponse,
+} from "@fluidframework/server-services-client";
+import { IGitManager, IHistorian } from "./storageContracts";
+import { IR11sResponse, createR11sResponseFromContent } from "./restWrapper";
+
+export class GitManager implements IGitManager {
+	private readonly blobCache = new Map<string, resources.IBlob>();
+	private readonly commitCache = new Map<string, resources.ICommit>();
+	private readonly treeCache = new Map<string, resources.ITree>();
+	private readonly refCache = new Map<string, string>();
+
+	constructor(private readonly historian: IHistorian) {}
+
+	/**
+	 * Reads the object with the given ID. We defer to the client implementation to do the actual read.
+	 */
+	public async getCommits(
+		shaOrRef: string,
+		count: number,
+	): Promise<IR11sResponse<resources.ICommitDetails[]>> {
+		let sha: string | undefined = shaOrRef;
+
+		// See if the sha is really a ref and convert
+		if (this.refCache.has(shaOrRef)) {
+			sha = this.refCache.get(shaOrRef);
+
+			// Delete refcache after first use
+			this.refCache.delete(shaOrRef);
+
+			// If null is stored for the ref then there are no commits - return an empty array
+			if (!sha) {
+				return createR11sResponseFromContent([]);
+			}
+		}
+
+		// See if the commit sha is hashed and return it if so
+		const commit = this.commitCache.get(sha);
+		if (commit !== undefined) {
+			return createR11sResponseFromContent([
+				{
+					commit: {
+						author: commit.author,
+						committer: commit.committer,
+						message: commit.message,
+						tree: commit.tree,
+						url: commit.url,
+					},
+					parents: commit.parents,
+					sha: commit.sha,
+					url: commit.url,
+				},
+			]);
+		}
+
+		// Otherwise fall back to the historian
+		return this.historian.getCommits(sha, count);
+	}
+
+	/**
+	 * Reads the object with the given ID. We defer to the client implementation to do the actual read.
+	 */
+	public async getTree(root: string, recursive = true): Promise<IR11sResponse<resources.ITree>> {
+		const tree = this.treeCache.get(root);
+		if (tree !== undefined) {
+			return createR11sResponseFromContent(tree);
+		}
+
+		return this.historian.getTree(root, recursive);
+	}
+
+	public async getBlob(sha: string): Promise<IR11sResponse<resources.IBlob>> {
+		const blob = this.blobCache.get(sha);
+		if (blob !== undefined) {
+			return createR11sResponseFromContent(blob);
+		}
+		return this.historian.getBlob(sha);
+	}
+
+	public async createBlob(
+		content: string,
+		encoding: "utf-8" | "base64",
+	): Promise<IR11sResponse<resources.ICreateBlobResponse>> {
+		const blob: resources.ICreateBlobParams = {
+			content,
+			encoding,
+		};
+		return this.historian.createBlob(blob);
+	}
+
+	public async createGitTree(
+		params: resources.ICreateTreeParams,
+	): Promise<IR11sResponse<resources.ITree>> {
+		const treeP = this.historian.createTree(params);
+		return treeP;
+	}
+
+	public async createSummary(
+		summary: IWholeSummaryPayload,
+		initial: boolean = false,
+	): Promise<IR11sResponse<IWriteSummaryResponse>> {
+		return this.historian.createSummary(summary, initial);
+	}
+
+	public async getSummary(sha: string): Promise<IR11sResponse<IWholeFlatSummary>> {
+		return this.historian.getSummary(sha);
+	}
+}

package/src/historian.ts

@@ -0,0 +1,121 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { fromUtf8ToBase64 } from "@fluidframework/common-utils";
+import * as git from "@fluidframework/gitresources";
+import {
+	IWholeFlatSummary,
+	IWholeSummaryPayload,
+	IWriteSummaryResponse,
+} from "@fluidframework/server-services-client";
+import { QueryStringType, RestWrapper } from "./restWrapperBase";
+import { IR11sResponse } from "./restWrapper";
+import { IHistorian } from "./storageContracts";
+
+export interface ICredentials {
+	user: string;
+	password: string;
+}
+
+export const getAuthorizationTokenFromCredentials = (credentials: ICredentials): string =>
+	`Basic ${fromUtf8ToBase64(`${credentials.user}:${credentials.password}`)}`;
+
+/**
+ * Implementation of the IHistorian interface that calls out to a REST interface
+ */
+export class Historian implements IHistorian {
+	private readonly defaultQueryString: QueryStringType = {};
+	private readonly cacheBust: boolean;
+
+	constructor(
+		private readonly historianApi: boolean,
+		disableCache: boolean,
+		private readonly restWrapper: RestWrapper,
+	) {
+		if (disableCache && this.historianApi) {
+			this.defaultQueryString.disableCache = disableCache;
+			this.cacheBust = false;
+		} else {
+			this.cacheBust = disableCache;
+		}
+	}
+
+	public async getBlob(sha: string): Promise<IR11sResponse<git.IBlob>> {
+		return this.restWrapper.get<git.IBlob>(
+			`/git/blobs/${encodeURIComponent(sha)}`,
+			this.getQueryString(),
+		);
+	}
+
+	public async createBlob(
+		blob: git.ICreateBlobParams,
+	): Promise<IR11sResponse<git.ICreateBlobResponse>> {
+		return this.restWrapper.post<git.ICreateBlobResponse>(
+			`/git/blobs`,
+			blob,
+			this.getQueryString(),
+		);
+	}
+
+	public async getCommits(
+		sha: string,
+		count: number,
+	): Promise<IR11sResponse<git.ICommitDetails[]>> {
+		return this.restWrapper
+			.get<git.ICommitDetails[]>(`/commits`, this.getQueryString({ count, sha }))
+			.catch((error) =>
+				error.statusCode === 400 || error.statusCode === 404
+					? {
+							content: [],
+							headers: new Map(),
+							propsToLog: {},
+							requestUrl: "",
+					  }
+					: Promise.reject<IR11sResponse<git.ICommitDetails[]>>(error),
+			);
+	}
+
+	public async createTree(tree: git.ICreateTreeParams): Promise<IR11sResponse<git.ITree>> {
+		return this.restWrapper.post<git.ITree>(`/git/trees`, tree, this.getQueryString());
+	}
+
+	public async getTree(sha: string, recursive: boolean): Promise<IR11sResponse<git.ITree>> {
+		return this.restWrapper.get<git.ITree>(
+			`/git/trees/${encodeURIComponent(sha)}`,
+			this.getQueryString({ recursive: recursive ? 1 : 0 }),
+		);
+	}
+	public async createSummary(
+		summary: IWholeSummaryPayload,
+		initial?: boolean,
+	): Promise<IR11sResponse<IWriteSummaryResponse>> {
+		return this.restWrapper.post<IWriteSummaryResponse>(
+			`/git/summaries`,
+			summary,
+			this.getQueryString(initial !== undefined ? { initial } : undefined),
+		);
+	}
+
+	public async getSummary(sha: string): Promise<IR11sResponse<IWholeFlatSummary>> {
+		return this.restWrapper.get<IWholeFlatSummary>(
+			`/git/summaries/${sha}`,
+			this.getQueryString(),
+		);
+	}
+
+	private getQueryString(queryString?: QueryStringType): QueryStringType {
+		if (this.cacheBust) {
+			return {
+				cacheBust: Date.now(),
+				...this.defaultQueryString,
+				...queryString,
+			};
+		}
+		return {
+			...this.defaultQueryString,
+			...queryString,
+		};
+	}
+}

package/src/index.ts

@@ -7,6 +7,9 @@
 export { DefaultTokenProvider } from "./defaultTokenProvider";
 export { ITokenProvider, ITokenResponse, ITokenService } from "./tokens";
 
+// Errors
+export { RouterliciousErrorType } from "./errorUtils";
+
 // Factory
 export {
 	DocumentPostCreateError,