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

package/src/documentServiceFactory.ts

@@ -5,18 +5,21 @@
 
 import { assert } from "@fluidframework/common-utils";
 import {
-    IDocumentService,
-    IDocumentServiceFactory,
-    IFluidResolvedUrl,
-    IResolvedUrl,
+	FiveDaysMs,
+	IDocumentService,
+	IDocumentServiceFactory,
+	IDocumentStorageServicePolicies,
+	IFluidResolvedUrl,
+	IResolvedUrl,
+	LoaderCachingPolicy,
 } from "@fluidframework/driver-definitions";
 import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
 import { ISummaryTree } from "@fluidframework/protocol-definitions";
 import {
-    ensureFluidResolvedUrl,
-    getDocAttributesFromProtocolSummary,
-    getQuorumValuesFromProtocolSummary,
-    RateLimiter,
+	ensureFluidResolvedUrl,
+	getDocAttributesFromProtocolSummary,
+	getQuorumValuesFromProtocolSummary,
+	RateLimiter,
 } from "@fluidframework/driver-utils";
 import { ChildLogger, PerformanceEvent } from "@fluidframework/telemetry-utils";
 import { ISession } from "@fluidframework/server-services-client";
@@ -30,15 +33,17 @@ import { ICache, InMemoryCache, NullCache } from "./cache";
 import { pkgVersion as driverVersion } from "./packageVersion";
 import { ISnapshotTreeVersion } from "./definitions";
 
+const maximumSnapshotCacheDurationMs: FiveDaysMs = 432_000_000; // 5 days in ms
+
 const defaultRouterliciousDriverPolicies: IRouterliciousDriverPolicies = {
-    enablePrefetch: true,
-    maxConcurrentStorageRequests: 100,
-    maxConcurrentOrdererRequests: 100,
-    aggregateBlobsSmallerThanBytes: undefined,
-    enableDiscovery: false,
-    enableWholeSummaryUpload: false,
-    enableRestLess: true,
-    enableInternalSummaryCaching: true,
+	enablePrefetch: true,
+	maxConcurrentStorageRequests: 100,
+	maxConcurrentOrdererRequests: 100,
+	aggregateBlobsSmallerThanBytes: undefined,
+	enableDiscovery: false,
+	enableWholeSummaryUpload: false,
+	enableRestLess: true,
+	enableInternalSummaryCaching: true,
 };
 
 /**
@@ -46,234 +51,257 @@ 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>;
+	public readonly protocolName = "fluid:";
+	private readonly driverPolicies: IRouterliciousDriverPolicies;
+	private readonly blobCache: ICache<ArrayBufferLike>;
+	private readonly snapshotTreeCache: ICache<ISnapshotTreeVersion>;
+
+	constructor(
+		private readonly tokenProvider: ITokenProvider,
+		driverPolicies: Partial<IRouterliciousDriverPolicies> = {},
+	) {
+		// Use the maximum allowed by the policy (IDocumentStorageServicePolicies.maximumCacheDurationMs set below)
+		const snapshotCacheExpiryMs: FiveDaysMs = maximumSnapshotCacheDurationMs;
+
+		this.driverPolicies = {
+			...defaultRouterliciousDriverPolicies,
+			...driverPolicies,
+		};
+		this.blobCache = new InMemoryCache<ArrayBufferLike>();
+		this.snapshotTreeCache = this.driverPolicies.enableInternalSummaryCaching
+			? new InMemoryCache<ISnapshotTreeVersion>(snapshotCacheExpiryMs)
+			: new NullCache<ISnapshotTreeVersion>();
+	}
 
-    constructor(
-        private readonly tokenProvider: ITokenProvider,
-        driverPolicies: Partial<IRouterliciousDriverPolicies> = {},
-    ) {
-        this.driverPolicies = {
-            ...defaultRouterliciousDriverPolicies,
-            ...driverPolicies,
-        };
-        this.blobCache = new InMemoryCache<ArrayBufferLike>();
-        this.snapshotTreeCache = this.driverPolicies.enableInternalSummaryCaching
-            ? new InMemoryCache<ISnapshotTreeVersion>()
-            : new NullCache<ISnapshotTreeVersion>();
-    }
+	/**
+	 * {@inheritDoc @fluidframework/driver-definitions#IDocumentServiceFactory.createContainer}
+	 *
+	 * @throws {@link DocumentPostCreateError}
+	 * If an exception is thrown while invoking the provided {@link ITokenProvider.documentPostCreateCallback}.
+	 */
+	public async createContainer(
+		createNewSummary: ISummaryTree | undefined,
+		resolvedUrl: IResolvedUrl,
+		logger?: ITelemetryBaseLogger,
+		clientIsSummarizer?: boolean,
+	): Promise<IDocumentService> {
+		ensureFluidResolvedUrl(resolvedUrl);
+		if (createNewSummary === undefined) {
+			throw new Error("Empty file summary creation isn't supported in this driver.");
+		}
+		assert(!!resolvedUrl.endpoints.ordererUrl, 0x0b2 /* "Missing orderer URL!" */);
+		let parsedUrl = parseFluidUrl(resolvedUrl.url);
+		if (!parsedUrl.pathname) {
+			throw new Error("Parsed url should contain tenant and doc Id!!");
+		}
+		const [, tenantId] = parsedUrl.pathname.split("/");
 
-    /**
-     * {@inheritDoc @fluidframework/driver-definitions#IDocumentServiceFactory.createContainer}
-     *
-     * @throws {@link DocumentPostCreateError}
-     * If an exception is thrown while invoking the provided {@link ITokenProvider.documentPostCreateCallback}.
-     */
-    public async createContainer(
-        createNewSummary: ISummaryTree | undefined,
-        resolvedUrl: IResolvedUrl,
-        logger?: ITelemetryBaseLogger,
-        clientIsSummarizer?: boolean,
-    ): Promise<IDocumentService> {
-        ensureFluidResolvedUrl(resolvedUrl);
-        if (createNewSummary === undefined) {
-            throw new Error("Empty file summary creation isn't supported in this driver.");
-        }
-        assert(!!resolvedUrl.endpoints.ordererUrl, 0x0b2 /* "Missing orderer URL!" */);
-        let parsedUrl = parseFluidUrl(resolvedUrl.url);
-        if (!parsedUrl.pathname) {
-            throw new Error("Parsed url should contain tenant and doc Id!!");
-        }
-        const [, tenantId] = parsedUrl.pathname.split("/");
+		const protocolSummary = createNewSummary.tree[".protocol"] as ISummaryTree;
+		const appSummary = createNewSummary.tree[".app"] as ISummaryTree;
+		if (!(protocolSummary && appSummary)) {
+			throw new Error("Protocol and App Summary required in the full summary");
+		}
+		const documentAttributes = getDocAttributesFromProtocolSummary(protocolSummary);
+		const quorumValues = getQuorumValuesFromProtocolSummary(protocolSummary);
 
-        const protocolSummary = createNewSummary.tree[".protocol"] as ISummaryTree;
-        const appSummary = createNewSummary.tree[".app"] as ISummaryTree;
-        if (!(protocolSummary && appSummary)) {
-            throw new Error("Protocol and App Summary required in the full summary");
-        }
-        const documentAttributes = getDocAttributesFromProtocolSummary(protocolSummary);
-        const quorumValues = getQuorumValuesFromProtocolSummary(protocolSummary);
+		const logger2 = ChildLogger.create(logger, "RouterliciousDriver");
+		const rateLimiter = new RateLimiter(this.driverPolicies.maxConcurrentOrdererRequests);
+		const ordererRestWrapper = await RouterliciousOrdererRestWrapper.load(
+			tenantId,
+			undefined,
+			this.tokenProvider,
+			logger2,
+			rateLimiter,
+			this.driverPolicies.enableRestLess,
+			resolvedUrl.endpoints.ordererUrl,
+		);
 
-        const logger2 = ChildLogger.create(logger, "RouterliciousDriver");
-        const rateLimiter = new RateLimiter(this.driverPolicies.maxConcurrentOrdererRequests);
-        const ordererRestWrapper = await RouterliciousOrdererRestWrapper.load(
-            tenantId,
-            undefined,
-            this.tokenProvider,
-            logger2,
-            rateLimiter,
-            this.driverPolicies.enableRestLess,
-            resolvedUrl.endpoints.ordererUrl,
-        );
+		const res = await PerformanceEvent.timedExecAsync(
+			logger2,
+			{
+				eventName: "CreateNew",
+				details: JSON.stringify({
+					enableDiscovery: this.driverPolicies.enableDiscovery,
+					sequenceNumber: documentAttributes.sequenceNumber,
+				}),
+			},
+			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 res = await PerformanceEvent.timedExecAsync(
-            logger2,
-            {
-                eventName: "CreateNew",
-                details: JSON.stringify({
-                    enableDiscovery: this.driverPolicies.enableDiscovery,
-                    sequenceNumber: documentAttributes.sequenceNumber,
-                }),
-            },
-            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,
-                });
+				event.end({
+					docId: typeof postRes === "string" ? postRes : postRes.id,
+				});
+				return postRes;
+			},
+		);
 
-                event.end({
-                    docId: typeof postRes === "string" ? postRes : postRes.id,
-                });
-                return postRes;
-            }
-        );
+		// For supporting backward compatibility, when the request has generateToken === true, it will return
+		// an object instead of string
+		// @TODO: Remove the logic when no need to support back-compat
 
-        // For supporting backward compatibility, when the request has generateToken === true, it will return
-        // an object instead of string
-        // @TODO: Remove the logic when no need to support back-compat
+		let documentId: string;
+		let token: string | undefined;
+		let session: ISession | undefined;
+		if (typeof res === "string") {
+			documentId = res;
+		} else {
+			documentId = res.id;
+			token = res.token;
+			session = this.driverPolicies.enableDiscovery ? res.session : undefined;
+		}
+		parsedUrl = parseFluidUrl(resolvedUrl.url);
 
-        let documentId: string;
-        let token: string | undefined;
-        let session: ISession | undefined;
-        if (typeof res === "string") {
-            documentId = res;
-        } else {
-            documentId = res.id;
-            token = res.token;
-            session = this.driverPolicies.enableDiscovery ? res.session : undefined;
-        }
-        parsedUrl = parseFluidUrl(resolvedUrl.url);
+		// @TODO: Remove token from the condition, checking the documentPostCreateCallback !== undefined
+		// is sufficient to determine if the token will be undefined or not.
+		try {
+			await PerformanceEvent.timedExecAsync(
+				logger2,
+				{
+					eventName: "DocPostCreateCallback",
+					docId: documentId,
+				},
+				async () => {
+					if (token && this.tokenProvider.documentPostCreateCallback !== undefined) {
+						return this.tokenProvider.documentPostCreateCallback(documentId, token);
+					}
+				},
+			);
+		} catch (error: any) {
+			throw new DocumentPostCreateError(error);
+		}
 
-        // @TODO: Remove token from the condition, checking the documentPostCreateCallback !== undefined
-        // is sufficient to determine if the token will be undefined or not.
-        try {
-            await PerformanceEvent.timedExecAsync(
-                logger2,
-                {
-                    eventName: "DocPostCreateCallback",
-                    docId: documentId,
-                },
-                async () => {
-                    if (token && this.tokenProvider.documentPostCreateCallback !== undefined) {
-                        return this.tokenProvider.documentPostCreateCallback(documentId, token);
-                    }
-                });
-        } catch (error: any) {
-            throw new DocumentPostCreateError(error);
-        }
+		parsedUrl.set("pathname", replaceDocumentIdInPath(parsedUrl.pathname, documentId));
+		const deltaStorageUrl = resolvedUrl.endpoints.deltaStorageUrl;
+		if (!deltaStorageUrl) {
+			throw new Error(
+				`All endpoints urls must be provided. [deltaStorageUrl:${deltaStorageUrl}]`,
+			);
+		}
+		const parsedDeltaStorageUrl = new URL(deltaStorageUrl);
+		parsedDeltaStorageUrl.pathname = replaceDocumentIdInPath(
+			parsedDeltaStorageUrl.pathname,
+			documentId,
+		);
 
-        parsedUrl.set("pathname", replaceDocumentIdInPath(parsedUrl.pathname, documentId));
-        const deltaStorageUrl = resolvedUrl.endpoints.deltaStorageUrl;
-        if (!deltaStorageUrl) {
-            throw new Error(
-                `All endpoints urls must be provided. [deltaStorageUrl:${deltaStorageUrl}]`);
-        }
-        const parsedDeltaStorageUrl = new URL(deltaStorageUrl);
-        parsedDeltaStorageUrl.pathname = replaceDocumentIdInPath(parsedDeltaStorageUrl.pathname, documentId);
+		return this.createDocumentService(
+			{
+				...resolvedUrl,
+				url: parsedUrl.toString(),
+				id: documentId,
+				endpoints: {
+					...resolvedUrl.endpoints,
+					deltaStorageUrl: parsedDeltaStorageUrl.toString(),
+				},
+			},
+			logger,
+			clientIsSummarizer,
+			session,
+		);
+	}
 
-        return this.createDocumentService(
-            {
-                ...resolvedUrl,
-                url: parsedUrl.toString(),
-                id: documentId,
-                endpoints: {
-                    ...resolvedUrl.endpoints,
-                    deltaStorageUrl: parsedDeltaStorageUrl.toString(),
-                },
-            },
-            logger,
-            clientIsSummarizer,
-            session,
-        );
-    }
+	/**
+	 * {@inheritDoc @fluidframework/driver-definitions#IDocumentServiceFactory.createDocumentService}
+	 *
+	 * @returns Routerlicious document service.
+	 */
+	public async createDocumentService(
+		resolvedUrl: IResolvedUrl,
+		logger?: ITelemetryBaseLogger,
+		clientIsSummarizer?: boolean,
+		session?: ISession,
+	): Promise<IDocumentService> {
+		ensureFluidResolvedUrl(resolvedUrl);
+		const parsedUrl = parseFluidUrl(resolvedUrl.url);
+		const [, tenantId, documentId] = parsedUrl.pathname.split("/");
+		if (!documentId || !tenantId) {
+			throw new Error(
+				`Couldn't parse documentId and/or tenantId. [documentId:${documentId}][tenantId:${tenantId}]`,
+			);
+		}
+		const logger2 = ChildLogger.create(logger, "RouterliciousDriver", {
+			all: { driverVersion },
+		});
 
-    /**
-     * {@inheritDoc @fluidframework/driver-definitions#IDocumentServiceFactory.createDocumentService}
-     *
-     * @returns Routerlicious document service.
-     */
-    public async createDocumentService(
-        resolvedUrl: IResolvedUrl,
-        logger?: ITelemetryBaseLogger,
-        clientIsSummarizer?: boolean,
-        session?: ISession,
-    ): Promise<IDocumentService> {
-        ensureFluidResolvedUrl(resolvedUrl);
+		const rateLimiter = new RateLimiter(this.driverPolicies.maxConcurrentOrdererRequests);
+		const ordererRestWrapper = await RouterliciousOrdererRestWrapper.load(
+			tenantId,
+			documentId,
+			this.tokenProvider,
+			logger2,
+			rateLimiter,
+			this.driverPolicies.enableRestLess,
+		);
 
-        const parsedUrl = parseFluidUrl(resolvedUrl.url);
-        const [, tenantId, documentId] = parsedUrl.pathname.split("/");
-        if (!documentId || !tenantId) {
-            throw new Error(
-                `Couldn't parse documentId and/or tenantId. [documentId:${documentId}][tenantId:${tenantId}]`);
-        }
-        const logger2 = ChildLogger.create(logger, "RouterliciousDriver", { all: { driverVersion } });
+		const discoverFluidResolvedUrl = async (): Promise<IFluidResolvedUrl> => {
+			if (!this.driverPolicies.enableDiscovery) {
+				return resolvedUrl;
+			}
 
-        const discoverFluidResolvedUrl = async (): Promise<IFluidResolvedUrl> => {
-            if (!this.driverPolicies.enableDiscovery) {
-                return resolvedUrl;
-            }
-            const rateLimiter = new RateLimiter(this.driverPolicies.maxConcurrentOrdererRequests);
-            const ordererRestWrapper = await RouterliciousOrdererRestWrapper.load(
-                tenantId,
-                documentId,
-                this.tokenProvider,
-                logger2,
-                rateLimiter,
-                this.driverPolicies.enableRestLess,
-                resolvedUrl.endpoints.ordererUrl,
-            );
+			const discoveredSession = await PerformanceEvent.timedExecAsync(
+				logger2,
+				{
+					eventName: "DiscoverSession",
+					docId: documentId,
+				},
+				async () => {
+					// The service responds with the current document session associated with the container.
+					return ordererRestWrapper.get<ISession>(
+						`${resolvedUrl.endpoints.ordererUrl}/documents/${tenantId}/session/${documentId}`,
+					);
+				},
+			);
+			return getDiscoveredFluidResolvedUrl(resolvedUrl, discoveredSession);
+		};
+		const fluidResolvedUrl: IFluidResolvedUrl =
+			session !== undefined
+				? getDiscoveredFluidResolvedUrl(resolvedUrl, session)
+				: await discoverFluidResolvedUrl();
 
-            const discoveredSession = await PerformanceEvent.timedExecAsync(
-                logger2,
-                {
-                    eventName: "DiscoverSession",
-                    docId: documentId,
-                },
-                async () => {
-                    // The service responds with the current document session associated with the container.
-                    return ordererRestWrapper.get<ISession>(
-                        `/documents/${tenantId}/session/${documentId}`);
-                });
-            return getDiscoveredFluidResolvedUrl(resolvedUrl, discoveredSession);
-        };
-        const fluidResolvedUrl: IFluidResolvedUrl = session !== undefined
-            ? getDiscoveredFluidResolvedUrl(resolvedUrl, session)
-            : await discoverFluidResolvedUrl();
+		const storageUrl = fluidResolvedUrl.endpoints.storageUrl;
+		const ordererUrl = fluidResolvedUrl.endpoints.ordererUrl;
+		const deltaStorageUrl = fluidResolvedUrl.endpoints.deltaStorageUrl;
+		const deltaStreamUrl = fluidResolvedUrl.endpoints.deltaStreamUrl || ordererUrl; // backward compatibility
+		if (!ordererUrl || !deltaStorageUrl) {
+			throw new Error(
+				`All endpoints urls must be provided. [ordererUrl:${ordererUrl}][deltaStorageUrl:${deltaStorageUrl}]`,
+			);
+		}
 
-        const storageUrl = fluidResolvedUrl.endpoints.storageUrl;
-        const ordererUrl = fluidResolvedUrl.endpoints.ordererUrl;
-        const deltaStorageUrl = fluidResolvedUrl.endpoints.deltaStorageUrl;
-        const deltaStreamUrl = fluidResolvedUrl.endpoints.deltaStreamUrl || ordererUrl; // backward compatibility
-        if (!ordererUrl || !deltaStorageUrl) {
-            throw new Error(
-                `All endpoints urls must be provided. [ordererUrl:${ordererUrl}][deltaStorageUrl:${deltaStorageUrl}]`);
-        }
+		const documentStorageServicePolicies: IDocumentStorageServicePolicies = {
+			caching: this.driverPolicies.enablePrefetch
+				? LoaderCachingPolicy.Prefetch
+				: LoaderCachingPolicy.NoCaching,
+			minBlobSize: this.driverPolicies.aggregateBlobsSmallerThanBytes,
+			maximumCacheDurationMs: maximumSnapshotCacheDurationMs,
+		};
 
-        return new DocumentService(
-            fluidResolvedUrl,
-            ordererUrl,
-            deltaStorageUrl,
-            deltaStreamUrl,
-            storageUrl,
-            logger2,
-            this.tokenProvider,
-            tenantId,
-            documentId,
-            this.driverPolicies,
-            this.blobCache,
-            this.snapshotTreeCache,
-            discoverFluidResolvedUrl);
-    }
+		return new DocumentService(
+			fluidResolvedUrl,
+			ordererUrl,
+			deltaStorageUrl,
+			deltaStreamUrl,
+			storageUrl,
+			logger2,
+			this.tokenProvider,
+			tenantId,
+			documentId,
+			ordererRestWrapper,
+			documentStorageServicePolicies,
+			this.driverPolicies,
+			this.blobCache,
+			this.snapshotTreeCache,
+			discoverFluidResolvedUrl,
+		);
+	}
 }
 
 /**
@@ -288,16 +316,18 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
  * - What would a retry pattern look like here?
  */
 export class DocumentPostCreateError extends Error {
-    public constructor(
-        /**
-         * Inner error being wrapped.
-         */
-        private readonly innerError: Error,
-    ) {
-        super(innerError.message);
-    }
+	public constructor(
+		/**
+		 * Inner error being wrapped.
+		 */
+		private readonly innerError: Error,
+	) {
+		super(innerError.message);
+	}
 
-    public readonly name = "DocumentPostCreateError";
+	public readonly name = "DocumentPostCreateError";
 
-    public get stack() { return this.innerError.stack; }
+	public get stack() {
+		return this.innerError.stack;
+	}
 }