@fluidframework/container-loader 2.0.0-dev.6.4.0.192049 → 2.0.0-dev.7.2.0.203917

package/src/loader.ts

@@ -17,6 +17,7 @@ import {
 import {
 	ITelemetryBaseLogger,
 	FluidObject,
+	// eslint-disable-next-line import/no-deprecated
 	IFluidRouter,
 	IRequest,
 	IRequestHeader,
@@ -40,15 +41,11 @@ import {
 } from "@fluidframework/driver-definitions";
 import { IClientDetails } from "@fluidframework/protocol-definitions";
 import { Container, IPendingContainerState } from "./container";
-import { IParsedUrl, parseUrl } from "./utils";
+import { IParsedUrl, tryParseCompatibleResolvedUrl } from "./utils";
 import { pkgVersion } from "./packageVersion";
 import { ProtocolHandlerBuilder } from "./protocol";
 import { DebugLogger } from "./debugLogger";
 
-function canUseCache(request: IRequest): boolean {
-	return request.headers?.[LoaderHeader.cache] === true;
-}
-
 function ensureResolvedUrlDefined(
 	resolved: IResolvedUrl | undefined,
 ): asserts resolved is IResolvedUrl {
@@ -66,31 +63,28 @@ export class RelativeLoader implements ILoader {
 	) {}
 
 	/**
-	 * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
+	 * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
 	 */
+	// eslint-disable-next-line import/no-deprecated
 	public get IFluidRouter(): IFluidRouter {
 		return this;
 	}
 
 	public async resolve(request: IRequest): Promise<IContainer> {
 		if (request.url.startsWith("/")) {
-			if (canUseCache(request)) {
-				return this.container;
-			} else {
-				ensureResolvedUrlDefined(this.container.resolvedUrl);
-				const container = await this.container.clone(
-					{
-						resolvedUrl: { ...this.container.resolvedUrl },
-						version: request.headers?.[LoaderHeader.version] ?? undefined,
-						loadMode: request.headers?.[LoaderHeader.loadMode],
-					},
-					{
-						canReconnect: request.headers?.[LoaderHeader.reconnect],
-						clientDetailsOverride: request.headers?.[LoaderHeader.clientDetails],
-					},
-				);
-				return container;
-			}
+			ensureResolvedUrlDefined(this.container.resolvedUrl);
+			const container = await this.container.clone(
+				{
+					resolvedUrl: { ...this.container.resolvedUrl },
+					version: request.headers?.[LoaderHeader.version] ?? undefined,
+					loadMode: request.headers?.[LoaderHeader.loadMode],
+				},
+				{
+					canReconnect: request.headers?.[LoaderHeader.reconnect],
+					clientDetailsOverride: request.headers?.[LoaderHeader.clientDetails],
+				},
+			);
+			return container;
 		}
 
 		if (this.loader === undefined) {
@@ -100,7 +94,7 @@ export class RelativeLoader implements ILoader {
 	}
 
 	/**
-	 * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
+	 * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
 	 */
 	public async request(request: IRequest): Promise<IResponse> {
 		if (request.url.startsWith("/")) {
@@ -279,18 +273,20 @@ export type IDetachedBlobStorage = Pick<IDocumentStorageService, "createBlob" |
  * With an already-resolved container, we can request a component directly, without loading the container again
  * @param container - a resolved container
  * @returns component on the container
+ * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
  */
 export async function requestResolvedObjectFromContainer(
 	container: IContainer,
 	headers?: IRequestHeader,
 ): Promise<IResponse> {
 	ensureResolvedUrlDefined(container.resolvedUrl);
-	const parsedUrl = parseUrl(container.resolvedUrl.url);
+	const parsedUrl = tryParseCompatibleResolvedUrl(container.resolvedUrl.url);
 
 	if (parsedUrl === undefined) {
 		throw new Error(`Invalid URL ${container.resolvedUrl.url}`);
 	}
 
+	// eslint-disable-next-line import/no-deprecated
 	const entryPoint: FluidObject<IFluidRouter> | undefined = await container.getEntryPoint?.();
 	const router = entryPoint?.IFluidRouter ?? container.IFluidRouter;
 
@@ -304,7 +300,6 @@ export async function requestResolvedObjectFromContainer(
  * Manages Fluid resource loading
  */
 export class Loader implements IHostLoader {
-	private readonly containers = new Map<string, Promise<Container>>();
 	public readonly services: ILoaderServices;
 	private readonly mc: MonitoringContext;
 
@@ -352,8 +347,9 @@ export class Loader implements IHostLoader {
 	}
 
 	/**
-	 * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
+	 * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
 	 */
+	// eslint-disable-next-line import/no-deprecated
 	public get IFluidRouter(): IFluidRouter {
 		return this;
 	}
@@ -365,25 +361,13 @@ export class Loader implements IHostLoader {
 			clientDetailsOverride?: IClientDetails;
 		},
 	): Promise<IContainer> {
-		const container = await Container.createDetached(
+		return Container.createDetached(
 			{
 				...createDetachedProps,
 				...this.services,
 			},
 			codeDetails,
 		);
-
-		if (this.cachingEnabled) {
-			container.once("attached", () => {
-				ensureResolvedUrlDefined(container.resolvedUrl);
-				const parsedUrl = parseUrl(container.resolvedUrl.url);
-				if (parsedUrl !== undefined) {
-					this.addToContainerCache(parsedUrl.id, Promise.resolve(container));
-				}
-			});
-		}
-
-		return container;
 	}
 
 	public async rehydrateDetachedContainerFromSnapshot(
@@ -414,7 +398,7 @@ export class Loader implements IHostLoader {
 	}
 
 	/**
-	 * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
+	 * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
 	 */
 	public async request(request: IRequest): Promise<IResponse> {
 		return PerformanceEvent.timedExecAsync(
@@ -430,37 +414,6 @@ export class Loader implements IHostLoader {
 		);
 	}
 
-	private getKeyForContainerCache(request: IRequest, parsedUrl: IParsedUrl): string {
-		const key =
-			request.headers?.[LoaderHeader.version] !== undefined
-				? `${parsedUrl.id}@${request.headers[LoaderHeader.version]}`
-				: parsedUrl.id;
-		return key;
-	}
-
-	private addToContainerCache(key: string, containerP: Promise<Container>) {
-		this.containers.set(key, containerP);
-		containerP
-			.then((container) => {
-				// If the container is closed/disposed or becomes closed/disposed after we resolve it,
-				// remove it from the cache.
-				if (container.closed || container.disposed) {
-					this.containers.delete(key);
-				} else {
-					container.once("closed", () => {
-						this.containers.delete(key);
-					});
-					container.once("disposed", () => {
-						this.containers.delete(key);
-					});
-				}
-			})
-			.catch((error) => {
-				// If an error occured while resolving the container request, then remove it from the cache.
-				this.containers.delete(key);
-			});
-	}
-
 	private async resolveCore(
 		request: IRequest,
 		pendingLocalState?: IPendingContainerState,
@@ -469,13 +422,13 @@ export class Loader implements IHostLoader {
 		ensureResolvedUrlDefined(resolvedAsFluid);
 
 		// Parse URL into data stores
-		const parsed = parseUrl(resolvedAsFluid.url);
+		const parsed = tryParseCompatibleResolvedUrl(resolvedAsFluid.url);
 		if (parsed === undefined) {
 			throw new Error(`Invalid URL ${resolvedAsFluid.url}`);
 		}
 
 		if (pendingLocalState !== undefined) {
-			const parsedPendingUrl = parseUrl(pendingLocalState.url);
+			const parsedPendingUrl = tryParseCompatibleResolvedUrl(pendingLocalState.url);
 			if (
 				parsedPendingUrl?.id !== parsed.id ||
 				parsedPendingUrl?.path.replace(/\/$/, "") !== parsed.path.replace(/\/$/, "")
@@ -489,11 +442,6 @@ export class Loader implements IHostLoader {
 		// If set in both query string and headers, use query string.  Also write the value from the query string into the header either way.
 		request.headers[LoaderHeader.version] =
 			parsed.version ?? request.headers[LoaderHeader.version];
-		const cacheHeader = request.headers[LoaderHeader.cache];
-		const canCache =
-			// Take header value if present, else use ILoaderOptions.cache value
-			(cacheHeader !== undefined ? cacheHeader === true : this.cachingEnabled) &&
-			pendingLocalState === undefined;
 		const fromSequenceNumber = request.headers[LoaderHeader.sequenceNumber] as
 			| number
 			| undefined;
@@ -513,26 +461,10 @@ export class Loader implements IHostLoader {
 			throw new UsageError('opsBeforeReturn must be set to "sequenceNumber"');
 		}
 
-		let container: Container;
-		if (canCache) {
-			const key = this.getKeyForContainerCache(request, parsed);
-			const maybeContainer = await this.containers.get(key);
-			if (maybeContainer !== undefined) {
-				container = maybeContainer;
-			} else {
-				const containerP = this.loadContainer(request, resolvedAsFluid);
-				this.addToContainerCache(key, containerP);
-				container = await containerP;
-			}
-		} else {
-			container = await this.loadContainer(request, resolvedAsFluid, pendingLocalState);
-		}
-
-		return { container, parsed };
-	}
-
-	private get cachingEnabled() {
-		return this.services.options.cache === true;
+		return {
+			container: await this.loadContainer(request, resolvedAsFluid, pendingLocalState),
+			parsed,
+		};
 	}
 
 	private async loadContainer(

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

@@ -0,0 +1,9 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export {
+	isLocationRedirectionError,
+	resolveWithLocationRedirectionHandling,
+} from "./resolveWithLocationRedirection";

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

@@ -0,0 +1,59 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ITelemetryBaseLogger, IRequest } from "@fluidframework/core-interfaces";
+import {
+	DriverErrorTypes,
+	ILocationRedirectionError,
+	IUrlResolver,
+} from "@fluidframework/driver-definitions";
+import { createChildLogger } from "@fluidframework/telemetry-utils";
+
+/**
+ * Checks if the error is location redirection error.
+ * @param error - error whose type is to be determined.
+ * @returns `true` is the error is location redirection error, otherwise `false`.
+ */
+export function isLocationRedirectionError(error: any): error is ILocationRedirectionError {
+	return (
+		typeof error === "object" &&
+		error !== null &&
+		error.errorType === DriverErrorTypes.locationRedirection
+	);
+}
+
+/**
+ * Handles location redirection while fulfilling the loader request.
+ * @param api - Callback in which user can wrap the loader.resolve or loader.request call.
+ * @param request - request to be resolved.
+ * @param urlResolver - resolver used to resolve the url.
+ * @param logger - logger to send events.
+ * @returns Response from the API call.
+ */
+export async function resolveWithLocationRedirectionHandling<T>(
+	api: (request: IRequest) => Promise<T>,
+	request: IRequest,
+	urlResolver: IUrlResolver,
+	logger?: ITelemetryBaseLogger,
+): Promise<T> {
+	let req: IRequest = request;
+	const childLogger = createChildLogger({ logger, namespace: "LocationRedirection" });
+	for (;;) {
+		try {
+			return await api(req);
+		} catch (error: any) {
+			if (!isLocationRedirectionError(error)) {
+				throw error;
+			}
+			childLogger.sendTelemetryEvent({ eventName: "LocationRedirectionError" });
+			const resolvedUrl = error.redirectUrl;
+			// Generate the new request with new location details from the resolved url. For datastore/relative path,
+			// we don't need to pass "/" as host could have asked for a specific data store. So driver need to
+			// extract it from the resolved url.
+			const absoluteUrl = await urlResolver.getAbsoluteUrl(resolvedUrl, "", undefined);
+			req = { url: absoluteUrl, headers: req.headers };
+		}
+	}
+}

package/src/packageVersion.ts

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

package/src/protocol.ts

@@ -13,16 +13,12 @@ import {
 import {
 	IDocumentAttributes,
 	IProcessMessageResult,
-	ISequencedClient,
 	ISequencedDocumentMessage,
 	ISignalClient,
 	ISignalMessage,
 	MessageType,
 } from "@fluidframework/protocol-definitions";
 
-// "term" was an experimental feature that is being removed.  The only safe value to use is 1.
-export const OnlyValidTermValue = 1 as const;
-
 // ADO: #1986: Start using enum from protocol-base.
 export enum SignalType {
 	ClientJoin = "join", // same value as MessageType.ClientJoin,
@@ -75,11 +71,11 @@ export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandl
 		message: ISequencedDocumentMessage,
 		local: boolean,
 	): IProcessMessageResult {
-		const client: ISequencedClient | undefined = this.quorum.getMember(message.clientId);
-
 		// Check and report if we're getting messages from a clientId that we previously
 		// flagged as shouldHaveLeft, or from a client that's not in the quorum but should be
 		if (message.clientId != null) {
+			const client = this.quorum.getMember(message.clientId);
+
 			if (client === undefined && message.type !== MessageType.ClientJoin) {
 				// pre-0.58 error message: messageClientIdMissingFromQuorum
 				throw new Error("Remote message's clientId is missing from the quorum");

package/src/retriableDocumentStorageService.ts

@@ -23,13 +23,19 @@ import { runWithRetry } from "@fluidframework/driver-utils";
 
 export class RetriableDocumentStorageService implements IDocumentStorageService, IDisposable {
 	private _disposed = false;
+	private internalStorageService: IDocumentStorageService | undefined;
 	constructor(
-		private readonly internalStorageService: IDocumentStorageService,
+		private readonly internalStorageServiceP: Promise<IDocumentStorageService>,
 		private readonly logger: ITelemetryLoggerExt,
-	) {}
+	) {
+		this.internalStorageServiceP.then((s) => (this.internalStorageService = s)).catch(() => {});
+	}
 
 	public get policies(): IDocumentStorageServicePolicies | undefined {
-		return this.internalStorageService.policies;
+		if (this.internalStorageService) {
+			return this.internalStorageService.policies;
+		}
+		throw new Error("storage service not yet instantiated");
 	}
 	public get disposed() {
 		return this._disposed;
@@ -39,7 +45,10 @@ export class RetriableDocumentStorageService implements IDocumentStorageService,
 	}
 
 	public get repositoryUrl(): string {
-		return this.internalStorageService.repositoryUrl;
+		if (this.internalStorageService) {
+			return this.internalStorageService.repositoryUrl;
+		}
+		throw new Error("storage service not yet instantiated");
 	}
 
 	public async getSnapshotTree(
@@ -47,14 +56,17 @@ export class RetriableDocumentStorageService implements IDocumentStorageService,
 		scenarioName?: string,
 	): Promise<ISnapshotTree | null> {
 		return this.runWithRetry(
-			async () => this.internalStorageService.getSnapshotTree(version, scenarioName),
+			async () =>
+				this.internalStorageServiceP.then(async (s) =>
+					s.getSnapshotTree(version, scenarioName),
+				),
 			"storage_getSnapshotTree",
 		);
 	}
 
 	public async readBlob(id: string): Promise<ArrayBufferLike> {
 		return this.runWithRetry(
-			async () => this.internalStorageService.readBlob(id),
+			async () => this.internalStorageServiceP.then(async (s) => s.readBlob(id)),
 			"storage_readBlob",
 		);
 	}
@@ -67,11 +79,8 @@ export class RetriableDocumentStorageService implements IDocumentStorageService,
 	): Promise<IVersion[]> {
 		return this.runWithRetry(
 			async () =>
-				this.internalStorageService.getVersions(
-					versionId,
-					count,
-					scenarioName,
-					fetchSource,
+				this.internalStorageServiceP.then(async (s) =>
+					s.getVersions(versionId, count, scenarioName, fetchSource),
 				),
 			"storage_getVersions",
 		);
@@ -95,26 +104,31 @@ export class RetriableDocumentStorageService implements IDocumentStorageService,
 			0x251 /* "creation summary has to have seq=0 && handle === undefined" */,
 		);
 		if (context.referenceSequenceNumber !== 0) {
-			return this.internalStorageService.uploadSummaryWithContext(summary, context);
+			return this.internalStorageServiceP.then(async (s) =>
+				s.uploadSummaryWithContext(summary, context),
+			);
 		}
 
 		// Creation flow with attachment blobs - need to do retries!
 		return this.runWithRetry(
-			async () => this.internalStorageService.uploadSummaryWithContext(summary, context),
+			async () =>
+				this.internalStorageServiceP.then(async (s) =>
+					s.uploadSummaryWithContext(summary, context),
+				),
 			"storage_uploadSummaryWithContext",
 		);
 	}
 
 	public async downloadSummary(handle: ISummaryHandle): Promise<ISummaryTree> {
 		return this.runWithRetry(
-			async () => this.internalStorageService.downloadSummary(handle),
+			async () => this.internalStorageServiceP.then(async (s) => s.downloadSummary(handle)),
 			"storage_downloadSummary",
 		);
 	}
 
 	public async createBlob(file: ArrayBufferLike): Promise<ICreateBlobResponse> {
 		return this.runWithRetry(
-			async () => this.internalStorageService.createBlob(file),
+			async () => this.internalStorageServiceP.then(async (s) => s.createBlob(file)),
 			"storage_createBlob",
 		);
 	}

package/src/utils.ts

@@ -23,9 +23,23 @@ export interface ISnapshotTreeWithBlobContents extends ISnapshotTree {
 	trees: { [path: string]: ISnapshotTreeWithBlobContents };
 }
 
+/**
+ * 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
+ */
 export interface IParsedUrl {
+	/**
+	 * It is combination of tenantid/docId part of the url.
+	 */
 	id: string;
+	/**
+	 * It is the deep link path in the url.
+	 */
 	path: string;
+	/**
+	 * Query string part of the url.
+	 */
 	query: string;
 	/**
 	 * Null means do not use snapshots, undefined means load latest snapshot
@@ -35,7 +49,15 @@ export interface IParsedUrl {
 	version: string | null | undefined;
 }
 
-export function parseUrl(url: string): IParsedUrl | undefined {
+/**
+ * Utility api to parse the IResolvedUrl.url into specific parts like querystring, path to get
+ * deep link info etc.
+ * Warning - This function may not be compatible with any Url Resolver's resolved url. It works
+ * 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
+ */
+export function tryParseCompatibleResolvedUrl(url: string): IParsedUrl | undefined {
 	const parsed = parse(url, true);
 	if (typeof parsed.pathname !== "string") {
 		throw new LoggingError("Failed to parse pathname");