@fluidframework/odsp-driver 2.0.0-dev-rc.1.0.0.228517 → 2.0.0-dev-rc.2.0.0.245554

package/src/epochTracker.ts

@@ -20,6 +20,7 @@ import {
 	LocationRedirectionError,
 } from "@fluidframework/driver-utils";
 import {
+	OdspErrorTypes,
 	snapshotKey,
 	ICacheEntry,
 	IEntry,
@@ -28,20 +29,21 @@ import {
 	IOdspError,
 	IOdspErrorAugmentations,
 	IOdspResolvedUrl,
+	maximumCacheDurationMs,
+	type HostStoragePolicy,
 } from "@fluidframework/odsp-driver-definitions";
-import { DriverErrorType } from "@fluidframework/driver-definitions";
 import {
 	fetchAndParseAsJSONHelper,
 	fetchArray,
 	fetchHelper,
 	getOdspResolvedUrl,
 	IOdspResponse,
-} from "./odspUtils";
-import { IOdspCache, INonPersistentCache, IPersistedFileCache } from "./odspCache";
-import { IVersionedValueWithEpoch, persistedCacheValueVersion } from "./contracts";
-import { ClpCompliantAppHeader } from "./contractsPublic";
-import { pkgVersion as driverVersion } from "./packageVersion";
-import { patchOdspResolvedUrl } from "./odspLocationRedirection";
+} from "./odspUtils.js";
+import { IOdspCache, INonPersistentCache, IPersistedFileCache } from "./odspCache.js";
+import { IVersionedValueWithEpoch, persistedCacheValueVersion } from "./contracts.js";
+import { ClpCompliantAppHeader } from "./contractsPublic.js";
+import { pkgVersion as driverVersion } from "./packageVersion.js";
+import { patchOdspResolvedUrl } from "./odspLocationRedirection.js";
 
 /**
  * @alpha
@@ -66,9 +68,6 @@ export type FetchTypeInternal = FetchType | "cache";
 
 export const Odsp409Error = "Odsp409Error";
 
-// Must be less than policy of 5 days
-export const defaultCacheExpiryTimeoutMs: number = 2 * 24 * 60 * 60 * 1000; // 2 days in ms
-
 /**
  * In ODSP, the concept of "epoch" refers to binary updates to files. For example, this might include using
  * version restore, or if the user downloads a Fluid file and then uploads it again. These result in the epoch
@@ -98,6 +97,7 @@ export class EpochTracker implements IPersistedFileCache {
 		protected readonly fileEntry: IFileEntry,
 		protected readonly logger: ITelemetryLoggerExt,
 		protected readonly clientIsSummarizer?: boolean,
+		protected readonly hostPolicy?: HostStoragePolicy,
 	) {
 		// Limits the max number of concurrent requests to 24.
 		this.rateLimiter = new RateLimiter(24);
@@ -107,11 +107,11 @@ export class EpochTracker implements IPersistedFileCache {
 			"Fluid.Driver.Odsp.TestOverride.DisableSnapshotCache",
 		)
 			? 0
-			: defaultCacheExpiryTimeoutMs;
+			: maximumCacheDurationMs;
 	}
 
 	// public for UT purposes only!
-	public setEpoch(epoch: string, fromCache: boolean, fetchType: FetchTypeInternal) {
+	public setEpoch(epoch: string, fromCache: boolean, fetchType: FetchTypeInternal): void {
 		assert(this._fluidEpoch === undefined, 0x1db /* "epoch exists" */);
 		this._fluidEpoch = epoch;
 
@@ -123,9 +123,12 @@ export class EpochTracker implements IPersistedFileCache {
 		});
 	}
 
+	// TODO: return a stronger type
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	public async get(entry: IEntry): Promise<any> {
 		try {
 			// Return undefined so that the ops/snapshots are grabbed from the server instead of the cache
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 			const value: IVersionedValueWithEpoch = await this.cache.get(
 				this.fileEntryFromEntry(entry),
 			);
@@ -145,6 +148,7 @@ export class EpochTracker implements IPersistedFileCache {
 			// Expire the cached snapshot if it's older than snapshotCacheExpiryTimeoutMs and immediately
 			// expire all old caches that do not have cacheEntryTime
 			if (entry.type === snapshotKey) {
+				// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
 				const cacheTime = value.value?.cacheEntryTime;
 				const currentTime = Date.now();
 				if (
@@ -168,14 +172,18 @@ export class EpochTracker implements IPersistedFileCache {
 		}
 	}
 
-	public async put(entry: IEntry, value: any) {
+	// TODO: take a stronger type or `unknown`
+	// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+	public async put(entry: IEntry, value: any): Promise<void> {
 		assert(this._fluidEpoch !== undefined, 0x1dd /* "no epoch" */);
 		// For snapshots, the value should have the cacheEntryTime.
 		// This will be used to expire snapshots older than snapshotCacheExpiryTimeoutMs.
 		if (entry.type === snapshotKey) {
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
 			value.cacheEntryTime = value.cacheEntryTime ?? Date.now();
 		}
 		const data: IVersionedValueWithEpoch = {
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 			value,
 			version: persistedCacheValueVersion,
 			fluidEpoch: this._fluidEpoch,
@@ -194,11 +202,11 @@ export class EpochTracker implements IPersistedFileCache {
 		}
 	}
 
-	public get fluidEpoch() {
+	public get fluidEpoch(): string | undefined {
 		return this._fluidEpoch;
 	}
 
-	public async validateEpoch(epoch: string | undefined, fetchType: FetchType) {
+	public async validateEpoch(epoch: string | undefined, fetchType: FetchType): Promise<void> {
 		assert(epoch !== undefined, 0x584 /* response should contain epoch */);
 		try {
 			this.validateEpochFromResponse(epoch, fetchType);
@@ -247,7 +255,7 @@ export class EpochTracker implements IPersistedFileCache {
 		fetchType: FetchType,
 		addInBody: boolean = false,
 		fetchReason?: string,
-	) {
+	): Promise<IOdspResponse<Response>> {
 		return this.fetchCore<Response>(
 			url,
 			fetchOptions,
@@ -260,12 +268,12 @@ export class EpochTracker implements IPersistedFileCache {
 
 	private async fetchCore<T>(
 		url: string,
-		fetchOptions: { [index: string]: any },
-		fetcher: (url: string, fetchOptions: { [index: string]: any }) => Promise<IOdspResponse<T>>,
+		fetchOptions: RequestInit,
+		fetcher: (url: string, fetchOptions: RequestInit) => Promise<IOdspResponse<T>>,
 		fetchType: FetchType,
 		addInBody: boolean = false,
 		fetchReason?: string,
-	) {
+	): Promise<IOdspResponse<T>> {
 		const clientCorrelationId = this.formatClientCorrelationId(fetchReason);
 		// Add epoch in fetch request.
 		this.addEpochInRequest(fetchOptions, addInBody, clientCorrelationId);
@@ -288,29 +296,48 @@ export class EpochTracker implements IPersistedFileCache {
 				throw error;
 			})
 			.catch((error) => {
-				// If the error is about location redirection, then we need to generate new resolved url with correct
-				// location info.
-				if (
-					isFluidError(error) &&
-					error.errorType === DriverErrorType.fileNotFoundOrAccessDeniedError
-				) {
-					const redirectLocation = (error as IOdspErrorAugmentations).redirectLocation;
-					if (redirectLocation !== undefined) {
-						const redirectUrl: IOdspResolvedUrl = patchOdspResolvedUrl(
-							this.fileEntry.resolvedUrl,
-							redirectLocation,
-						);
-						const locationRedirectionError = new LocationRedirectionError(
+				if (isFluidError(error)) {
+					// If the error is about location redirection, then we need to generate new resolved url with correct
+					// location info.
+					if (error.errorType === OdspErrorTypes.fileNotFoundOrAccessDeniedError) {
+						const redirectLocation = (error as IOdspErrorAugmentations)
+							.redirectLocation;
+						if (redirectLocation !== undefined) {
+							const redirectUrl: IOdspResolvedUrl = patchOdspResolvedUrl(
+								this.fileEntry.resolvedUrl,
+								redirectLocation,
+							);
+							const locationRedirectionError = new LocationRedirectionError(
+								error.message,
+								redirectUrl,
+								{ driverVersion, redirectLocation },
+							);
+							locationRedirectionError.addTelemetryProperties(
+								error.getTelemetryProperties(),
+							);
+							throw locationRedirectionError;
+						}
+					}
+					// If the hostPolicy disallows retries for throttling errors, then we throw a NonRetryableError
+					else if (
+						error.errorType === OdspErrorTypes.throttlingError &&
+						this.hostPolicy?.disableRetriesOnStorageThrottlingError
+					) {
+						const nonRetriableThrottlingError = new NonRetryableError(
 							error.message,
-							redirectUrl,
-							{ driverVersion, redirectLocation },
+							OdspErrorTypes.throttlingError,
+							{
+								driverVersion,
+							},
 						);
-						locationRedirectionError.addTelemetryProperties(
+						// This step ensures all the telemetry props are preserved including the retryAfterSeconds from the original error
+						nonRetriableThrottlingError.addTelemetryProperties(
 							error.getTelemetryProperties(),
 						);
-						throw locationRedirectionError;
+						throw nonRetriableThrottlingError;
 					}
 				}
+
 				throw error;
 			})
 			.catch((error) => {
@@ -331,11 +358,11 @@ export class EpochTracker implements IPersistedFileCache {
 	 */
 	public async fetchArray(
 		url: string,
-		fetchOptions: { [index: string]: any },
+		fetchOptions: { [index: string]: RequestInit },
 		fetchType: FetchType,
 		addInBody: boolean = false,
 		fetchReason?: string,
-	) {
+	): Promise<IOdspResponse<ArrayBuffer>> {
 		return this.fetchCore<ArrayBuffer>(
 			url,
 			fetchOptions,
@@ -350,7 +377,7 @@ export class EpochTracker implements IPersistedFileCache {
 		fetchOptions: RequestInit,
 		addInBody: boolean,
 		clientCorrelationId: string,
-	) {
+	): void {
 		const isClpCompliantApp = getOdspResolvedUrl(this.fileEntry.resolvedUrl).isClpCompliantApp;
 		if (addInBody) {
 			const headers: { [key: string]: string } = {};
@@ -363,7 +390,7 @@ export class EpochTracker implements IPersistedFileCache {
 			}
 			this.addParamInBody(fetchOptions, headers);
 		} else {
-			const addHeader = (key: string, val: string) => {
+			const addHeader = (key: string, val: string): void => {
 				fetchOptions.headers = {
 					...fetchOptions.headers,
 				};
@@ -383,7 +410,7 @@ export class EpochTracker implements IPersistedFileCache {
 		}
 	}
 
-	private addParamInBody(fetchOptions: RequestInit, headers: { [key: string]: string }) {
+	private addParamInBody(fetchOptions: RequestInit, headers: { [key: string]: string }): void {
 		// We use multi part form request for post body where we want to use this.
 		// So extract the form boundary to mark the end of form.
 		const body = fetchOptions.body;
@@ -392,16 +419,16 @@ export class EpochTracker implements IPersistedFileCache {
 		const firstLine = splitBody.shift();
 		assert(firstLine?.startsWith("--") === true, 0x21e /* "improper boundary format" */);
 		const formParams = [firstLine];
-		Object.entries(headers).forEach(([key, value]) => {
+		for (const [key, value] of Object.entries(headers)) {
 			formParams.push(`${key}: ${value}`);
-		});
-		splitBody.forEach((value: string) => {
+		}
+		for (const value of splitBody) {
 			formParams.push(value);
-		});
+		}
 		fetchOptions.body = formParams.join("\r\n");
 	}
 
-	private formatClientCorrelationId(fetchReason?: string) {
+	private formatClientCorrelationId(fetchReason?: string): string {
 		const items: string[] = [
 			`driverId=${this.driverId}`,
 			`RequestNumber=${this.networkCallNumber++}`,
@@ -418,15 +445,13 @@ export class EpochTracker implements IPersistedFileCache {
 		epochFromResponse: string | undefined,
 		fetchType: FetchTypeInternal,
 		fromCache: boolean = false,
-	) {
+	): void {
 		const error = this.checkForEpochErrorCore(epochFromResponse);
 		if (error !== undefined) {
 			throw error;
 		}
-		if (epochFromResponse !== undefined) {
-			if (this._fluidEpoch === undefined) {
-				this.setEpoch(epochFromResponse, fromCache, fetchType);
-			}
+		if (epochFromResponse !== undefined && this._fluidEpoch === undefined) {
+			this.setEpoch(epochFromResponse, fromCache, fetchType);
 		}
 	}
 
@@ -435,8 +460,8 @@ export class EpochTracker implements IPersistedFileCache {
 		epochFromResponse: string | null | undefined,
 		fetchType: FetchTypeInternal,
 		fromCache: boolean = false,
-	) {
-		if (isFluidError(error) && error.errorType === DriverErrorType.fileOverwrittenInStorage) {
+	): Promise<void> {
+		if (isFluidError(error) && error.errorType === OdspErrorTypes.fileOverwrittenInStorage) {
 			const epochError = this.checkForEpochErrorCore(epochFromResponse);
 			if (epochError !== undefined) {
 				epochError.addTelemetryProperties({
@@ -461,7 +486,9 @@ export class EpochTracker implements IPersistedFileCache {
 		}
 	}
 
-	private checkForEpochErrorCore(epochFromResponse: string | null | undefined) {
+	private checkForEpochErrorCore(
+		epochFromResponse: string | null | undefined,
+	): NonRetryableError<"fileOverwrittenInStorage"> | undefined {
 		// If epoch is undefined, then don't compare it because initially for createNew or TreesLatest
 		// initializes this value. Sometimes response does not contain epoch as it is still in
 		// implementation phase at server side. In that case also, don't compare it with our epoch value.
@@ -470,7 +497,7 @@ export class EpochTracker implements IPersistedFileCache {
 			// Difference - client detected mismatch, instead of server detecting it.
 			return new NonRetryableError(
 				"Epoch mismatch",
-				DriverErrorType.fileOverwrittenInStorage,
+				OdspErrorTypes.fileOverwrittenInStorage,
 				{ driverVersion, serverEpoch: epochFromResponse, clientEpoch: this.fluidEpoch },
 			);
 		}
@@ -489,8 +516,9 @@ export class EpochTrackerWithRedemption extends EpochTracker {
 		protected readonly fileEntry: IFileEntry,
 		protected readonly logger: ITelemetryLoggerExt,
 		protected readonly clientIsSummarizer?: boolean,
+		protected readonly hostPolicy?: HostStoragePolicy,
 	) {
-		super(cache, fileEntry, logger, clientIsSummarizer);
+		super(cache, fileEntry, logger, clientIsSummarizer, hostPolicy);
 		// Handles the rejected promise within treesLatestDeferral.
 		this.treesLatestDeferral.promise.catch(() => {});
 	}
@@ -499,7 +527,7 @@ export class EpochTrackerWithRedemption extends EpochTracker {
 		epochFromResponse: string | undefined,
 		fetchType: FetchType,
 		fromCache: boolean = false,
-	) {
+	): void {
 		super.validateEpochFromResponse(epochFromResponse, fetchType, fromCache);
 
 		// Any successful call means we have access to a file, i.e. any redemption that was required already happened.
@@ -508,6 +536,8 @@ export class EpochTrackerWithRedemption extends EpochTracker {
 		this.treesLatestDeferral.resolve();
 	}
 
+	// TODO: return a stronger type
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	public async get(entry: IEntry): Promise<any> {
 		let result = super.get(entry);
 
@@ -533,7 +563,7 @@ export class EpochTrackerWithRedemption extends EpochTracker {
 
 	public async fetchAndParseAsJSON<T>(
 		url: string,
-		fetchOptions: { [index: string]: any },
+		fetchOptions: { [index: string]: RequestInit },
 		fetchType: FetchType,
 		addInBody: boolean = false,
 		fetchReason?: string,
@@ -550,6 +580,7 @@ export class EpochTrackerWithRedemption extends EpochTracker {
 				addInBody,
 				fetchReason,
 			);
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
 		} catch (error: any) {
 			// Only handling here treesLatest. If createFile failed, we should never try to do joinSession.
 			// Similar, if getVersions failed, we should not do any further storage calls.
@@ -559,7 +590,9 @@ export class EpochTrackerWithRedemption extends EpochTracker {
 			}
 			if (
 				fetchType !== "joinSession" ||
+				// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 				error.statusCode < 401 ||
+				// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 				error.statusCode > 404 ||
 				completed
 			) {
@@ -616,12 +649,14 @@ export function createOdspCacheAndTracker(
 	fileEntry: IFileEntry,
 	logger: ITelemetryLoggerExt,
 	clientIsSummarizer?: boolean,
+	hostPolicy?: HostStoragePolicy,
 ): ICacheAndTracker {
 	const epochTracker = new EpochTrackerWithRedemption(
 		persistedCacheArg,
 		fileEntry,
 		logger,
 		clientIsSummarizer,
+		hostPolicy,
 	);
 	return {
 		cache: {