@fluidframework/odsp-driver 1.2.7 → 2.0.0-dev.1.3.0.96595

package/src/createFile.ts

@@ -15,6 +15,9 @@ import {
     InstrumentedStorageTokenFetcher,
     IOdspResolvedUrl,
     OdspErrorType,
+    ShareLinkInfoType,
+    ISharingLinkKind,
+    ShareLinkTypes,
 } from "@fluidframework/odsp-driver-definitions";
 import { DriverErrorType } from "@fluidframework/driver-definitions";
 import {
@@ -26,6 +29,7 @@ import {
 } from "./contracts";
 import { getUrlAndHeadersWithAuth } from "./getUrlAndHeadersWithAuth";
 import {
+    buildOdspShareLinkReqParams,
     createCacheSnapshotKey,
     getWithRetryForTokenRefresh,
     INewFileInfo,
@@ -61,6 +65,8 @@ export async function createNewFluidFile(
     createNewCaching: boolean,
     forceAccessTokenViaAuthorizationHeader: boolean,
     isClpCompliantApp?: boolean,
+    enableSingleRequestForShareLinkWithCreate?: boolean,
+    enableShareLinkWithCreate?: boolean,
 ): Promise<IOdspResolvedUrl> {
     // Check for valid filename before the request to create file is actually made.
     if (isInvalidFileName(newFileInfo.filename)) {
@@ -71,8 +77,7 @@ export async function createNewFluidFile(
 
     let itemId: string;
     let summaryHandle: string = "";
-    let sharingLink: string | undefined;
-    let sharingLinkErrorReason: string | undefined;
+    let shareLinkInfo: ShareLinkInfoType | undefined;
     if (createNewSummary === undefined) {
         itemId = await createNewEmptyFluidFile(
             getStorageToken, newFileInfo, logger, epochTracker, forceAccessTokenViaAuthorizationHeader);
@@ -87,8 +92,12 @@ export async function createNewFluidFile(
         );
         itemId = content.itemId;
         summaryHandle = content.id;
-        sharingLink = content.sharingLink;
-        sharingLinkErrorReason = content.sharingLinkErrorReason;
+
+        shareLinkInfo = extractShareLinkData(
+            newFileInfo.createLinkType,
+            content,
+            enableSingleRequestForShareLinkWithCreate,
+            enableShareLinkWithCreate);
     }
 
     const odspUrl = createOdspUrl({ ...newFileInfo, itemId, dataStorePath: "/" });
@@ -100,15 +109,7 @@ export async function createNewFluidFile(
     fileEntry.docId = odspResolvedUrl.hashedDocumentId;
     fileEntry.resolvedUrl = odspResolvedUrl;
 
-    if (sharingLink || sharingLinkErrorReason) {
-        odspResolvedUrl.shareLinkInfo = {
-            createLink: {
-                type: newFileInfo.createLinkType,
-                link: sharingLink,
-                error: sharingLinkErrorReason,
-            },
-        };
-    }
+    odspResolvedUrl.shareLinkInfo = shareLinkInfo;
 
     if (createNewSummary !== undefined && createNewCaching) {
         assert(summaryHandle !== undefined, 0x203 /* "Summary handle is undefined" */);
@@ -120,6 +121,61 @@ export async function createNewFluidFile(
     return odspResolvedUrl;
 }
 
+/**
+ * If user requested creation of a sharing link along with the creation of the file by providing either
+ * createLinkType (now deprecated) or createLinkScope in the request parameters, extract and save
+ * sharing link information from the response if it is available.
+ * In case there was an error in creation of the sharing link, error is provided back in the response,
+ * and does not impact the creation of file in ODSP.
+ * @param requestedSharingLinkKind - Kind of sharing link requested to be created along with the creation of file.
+ * @param response - Response object received from the /snapshot api call
+ * @returns Sharing link information received in the response from a successful creation of a file.
+ */
+function extractShareLinkData(
+    requestedSharingLinkKind: ShareLinkTypes | ISharingLinkKind | undefined,
+    response: ICreateFileResponse,
+    enableSingleRequestForShareLinkWithCreate?: boolean,
+    enableShareLinkWithCreate?: boolean,
+): ShareLinkInfoType | undefined {
+    if (!requestedSharingLinkKind) {
+        return;
+    }
+    let shareLinkInfo: ShareLinkInfoType | undefined;
+    if (enableSingleRequestForShareLinkWithCreate) {
+        const { sharing } = response;
+        if (!sharing) {
+            return;
+        }
+        shareLinkInfo = {
+            createLink: {
+                type: requestedSharingLinkKind,
+                link: sharing.sharingLink ? {
+                    scope: sharing.sharingLink.scope,
+                    role: sharing.sharingLink.type,
+                    webUrl: sharing.sharingLink.webUrl,
+                    ...sharing.sharingLink,
+                } : undefined,
+                error: sharing.error,
+                shareId: sharing.shareId,
+            },
+        };
+    } else if (enableShareLinkWithCreate) {
+        const { sharing, sharingLink, sharingLinkErrorReason } = response;
+        if (!sharingLink && !sharingLinkErrorReason) {
+            return;
+        }
+        shareLinkInfo = {
+            createLink: {
+                type: requestedSharingLinkKind,
+                link: sharingLink,
+                error: sharingLinkErrorReason,
+                shareId: sharing?.shareId,
+            },
+        };
+    }
+    return shareLinkInfo;
+}
+
 export async function createNewEmptyFluidFile(
     getStorageToken: InstrumentedStorageTokenFetcher,
     newFileInfo: INewFileInfo,
@@ -192,8 +248,12 @@ export async function createNewFluidFileFromSummary(
         `${filePath}/${encodedFilename}`;
 
     const containerSnapshot = convertSummaryIntoContainerSnapshot(createNewSummary);
-    const initialUrl = `${baseUrl}:/opStream/snapshots/snapshot${newFileInfo.createLinkType ?
-        `?createLinkType=${newFileInfo.createLinkType}` : ""}`;
+
+    // Build share link parameter based on the createLinkType provided so that the
+    // snapshot api can create and return the share link along with creation of file in the response.
+    const createShareLinkParam = buildOdspShareLinkReqParams(newFileInfo.createLinkType);
+    const initialUrl =
+        `${baseUrl}:/opStream/snapshots/snapshot${createShareLinkParam ? `?${createShareLinkParam}` : ""}`;
 
     return getWithRetryForTokenRefresh(async (options) => {
         const storageToken = await getStorageToken(options, "CreateNewFile");

package/src/createNewUtils.ts

@@ -4,11 +4,10 @@
  */
 
 import { v4 as uuid } from "uuid";
-import { ISummaryTree, SummaryType } from "@fluidframework/protocol-definitions";
+import { ISummaryTree, SummaryType, ISnapshotTree } from "@fluidframework/protocol-definitions";
 import { getDocAttributesFromProtocolSummary } from "@fluidframework/driver-utils";
 import { stringToBuffer, unreachableCase } from "@fluidframework/common-utils";
 import { ISnapshotContents } from "./odspPublicUtils";
-import { ISnapshotTreeEx } from "./contracts";
 
 /**
  * Converts a summary(ISummaryTree) taken in detached container to snapshot tree and blobs
@@ -35,10 +34,9 @@ function convertCreateNewSummaryTreeToTreeAndBlobsCore(
     summary: ISummaryTree,
     blobs: Map<string, ArrayBuffer>,
 ) {
-    const treeNode: ISnapshotTreeEx = {
+    const treeNode: ISnapshotTree = {
         blobs: {},
         trees: {},
-        commits: {},
         unreferenced: summary.unreferenced,
     };
     const keys = Object.keys(summary.tree);

package/src/createOdspCreateContainerRequest.ts

@@ -4,7 +4,8 @@
  */
 import { IRequest } from "@fluidframework/core-interfaces";
 import { DriverHeader } from "@fluidframework/driver-definitions";
-import { ShareLinkTypes } from "@fluidframework/odsp-driver-definitions";
+import { ShareLinkTypes, ISharingLinkKind } from "@fluidframework/odsp-driver-definitions";
+import { buildOdspShareLinkReqParams } from "./odspUtils";
 
 /**
  * Create the request object with url and headers for creating a new file on OneDrive Sharepoint
@@ -12,19 +13,21 @@ import { ShareLinkTypes } from "@fluidframework/odsp-driver-definitions";
  * @param driveId - drive identifier
  * @param filePath - path where file needs to be created
  * @param fileName - name of the new file to be created
- * @param createLinkType - type of sharing link you would like to create for this file
+ * @param createShareLinkType - type of sharing link you would like to create for this file. ShareLinkTypes
+ * will be deprecated soon, so for any new implementation please provide createShareLinkType of type ShareLink
  */
 export function createOdspCreateContainerRequest(
     siteUrl: string,
     driveId: string,
     filePath: string,
     fileName: string,
-    createLinkType?: ShareLinkTypes,
+    createShareLinkType?: ShareLinkTypes | ISharingLinkKind,
 ): IRequest {
+    const shareLinkRequestParams = buildOdspShareLinkReqParams(createShareLinkType);
     const createNewRequest: IRequest = {
         url: `${siteUrl}?driveId=${encodeURIComponent(
             driveId,
-        )}&path=${encodeURIComponent(filePath)}${createLinkType ? `&createLinkType=${createLinkType}` : ""}`,
+        )}&path=${encodeURIComponent(filePath)}${shareLinkRequestParams ? `&${shareLinkRequestParams}` : ""}`,
         headers: {
             [DriverHeader.createNew]: {
                 fileName,

package/src/epochTracker.ts

@@ -6,7 +6,12 @@
 import { v4 as uuid } from "uuid";
 import { assert, Deferred } from "@fluidframework/common-utils";
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { ThrottlingError, RateLimiter, NonRetryableError } from "@fluidframework/driver-utils";
+import {
+    ThrottlingError,
+    RateLimiter,
+    NonRetryableError,
+    LocationRedirectionError,
+} from "@fluidframework/driver-utils";
 import { IConnected } from "@fluidframework/protocol-definitions";
 import {
     snapshotKey,
@@ -15,9 +20,16 @@ import {
     IFileEntry,
     IPersistedCache,
     IOdspError,
+    IOdspErrorAugmentations,
+    IOdspResolvedUrl,
 } from "@fluidframework/odsp-driver-definitions";
 import { DriverErrorType } from "@fluidframework/driver-definitions";
-import { PerformanceEvent, isFluidError, normalizeError } from "@fluidframework/telemetry-utils";
+import {
+    PerformanceEvent,
+    isFluidError,
+    normalizeError,
+    loggerToMonitoringContext,
+} from "@fluidframework/telemetry-utils";
 import { fetchAndParseAsJSONHelper, fetchArray, fetchHelper, getOdspResolvedUrl, IOdspResponse } from "./odspUtils";
 import {
     IOdspCache,
@@ -27,6 +39,7 @@ import {
 import { IVersionedValueWithEpoch, persistedCacheValueVersion } from "./contracts";
 import { ClpCompliantAppHeader } from "./contractsPublic";
 import { pkgVersion as driverVersion } from "./packageVersion";
+import { patchOdspResolvedUrl } from "./odspLocationRedirection";
 
 export type FetchType = "blob" | "createBlob" | "createFile" | "joinSession" | "ops" | "test" | "snapshotTree" |
     "treesLatest" | "uploadSummary" | "push" | "versions";
@@ -47,6 +60,7 @@ export const defaultCacheExpiryTimeoutMs: number = 2 * 24 * 60 * 60 * 1000;
 export class EpochTracker implements IPersistedFileCache {
     private _fluidEpoch: string | undefined;
 
+    private readonly snapshotCacheExpiryTimeoutMs: number;
     public readonly rateLimiter: RateLimiter;
     private readonly driverId = uuid();
     // This tracks the request number made by the driver instance.
@@ -59,6 +73,12 @@ export class EpochTracker implements IPersistedFileCache {
     ) {
         // Limits the max number of concurrent requests to 24.
         this.rateLimiter = new RateLimiter(24);
+
+        // We need this for GC testing until we properly plumb through the snapshot expiration policy (see PR #11168)
+        this.snapshotCacheExpiryTimeoutMs =
+            loggerToMonitoringContext(logger).config.getBoolean("Fluid.Driver.Odsp.TestOverride.DisableSnapshotCache")
+                ? 0
+                : defaultCacheExpiryTimeoutMs;
     }
 
     // public for UT purposes only!
@@ -95,17 +115,17 @@ export class EpochTracker implements IPersistedFileCache {
             } else if (this._fluidEpoch !== value.fluidEpoch) {
                 return undefined;
             }
-            // Expire the cached snapshot if it's older than the defaultCacheExpiryTimeoutMs and immediately
+            // 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) {
                 const cacheTime = value.value?.cacheEntryTime;
                 const currentTime = Date.now();
-                if (cacheTime === undefined || currentTime - cacheTime >= defaultCacheExpiryTimeoutMs) {
+                if (cacheTime === undefined || currentTime - cacheTime >= this.snapshotCacheExpiryTimeoutMs) {
                     this.logger.sendTelemetryEvent(
                         {
                             eventName: "odspVersionsCacheExpired",
                             duration: currentTime - cacheTime,
-                            maxCacheAgeMs: defaultCacheExpiryTimeoutMs,
+                            maxCacheAgeMs: this.snapshotCacheExpiryTimeoutMs,
                         });
                     await this.removeEntries();
                     return undefined;
@@ -121,8 +141,8 @@ export class EpochTracker implements IPersistedFileCache {
 
     public async put(entry: IEntry, value: any) {
         assert(this._fluidEpoch !== undefined, 0x1dd /* "no epoch" */);
-        // For snapshots, the value should have the cacheEntryTime. This will be used to expire snapshots older
-        // than the defaultCacheExpiryTimeoutMs.
+        // For snapshots, the value should have the cacheEntryTime.
+        // This will be used to expire snapshots older than snapshotCacheExpiryTimeoutMs.
         if (entry.type === snapshotKey) {
             value.cacheEntryTime = value.cacheEntryTime ?? Date.now();
         }
@@ -224,6 +244,26 @@ export class EpochTracker implements IPersistedFileCache {
             }
             await this.checkForEpochError(error, epochFromResponse, fetchType);
             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(
+                        error.message,
+                        redirectUrl,
+                        { driverVersion, redirectLocation },
+                    );
+                    locationRedirectionError.addTelemetryProperties(error.getTelemetryProperties());
+                    throw locationRedirectionError;
+                }
+            }
+            throw error;
         }).catch((error) => {
             const fluidError = normalizeError(error, { props: { XRequestStatsHeader: clientCorrelationId } });
             throw fluidError;

package/src/fetchSnapshot.ts

@@ -16,7 +16,7 @@ import {
     InstrumentedStorageTokenFetcher,
 } from "@fluidframework/odsp-driver-definitions";
 import { ISnapshotTree } from "@fluidframework/protocol-definitions";
-import { isRuntimeMessage, NonRetryableError } from "@fluidframework/driver-utils";
+import { DriverErrorTelemetryProps, isRuntimeMessage, NonRetryableError } from "@fluidframework/driver-utils";
 import { IOdspSnapshot, ISnapshotCachedEntry, IVersionedValueWithEpoch, persistedCacheValueVersion } from "./contracts";
 import { getQueryString } from "./getQueryString";
 import { getUrlAndHeadersWithAuth } from "./getUrlAndHeadersWithAuth";
@@ -30,7 +30,6 @@ import {
 import { ISnapshotContents } from "./odspPublicUtils";
 import { convertOdspSnapshotToSnapshotTreeAndBlobs } from "./odspSnapshotParser";
 import { currentReadVersion, parseCompactSnapshotResponse } from "./compactSnapshotParser";
-import { ReadBuffer } from "./ReadBufferUtils";
 import { EpochTracker } from "./epochTracker";
 import { pkgVersion } from "./packageVersion";
 
@@ -49,7 +48,6 @@ export enum SnapshotFormatSupportType {
  * @param token - token used for authorization in the request
  * @param storageFetchWrapper - Implementation of the get/post methods used to fetch the snapshot
  * @param versionId - id of specific snapshot to be fetched
- * @param fetchFullSnapshot - whether we want to fetch full snapshot(with blobs)
  * @param forceAccessTokenViaAuthorizationHeader - whether to force passing given token via authorization header
  * @returns A promise of the snapshot and the status code of the response
  */
@@ -57,22 +55,14 @@ export async function fetchSnapshot(
     snapshotUrl: string,
     token: string | null,
     versionId: string,
-    fetchFullSnapshot: boolean,
     forceAccessTokenViaAuthorizationHeader: boolean,
     logger: ITelemetryLogger,
     snapshotDownloader: (url: string, fetchOptions: { [index: string]: any; }) => Promise<IOdspResponse<unknown>>,
 ): Promise<ISnapshotContents> {
     const path = `/trees/${versionId}`;
-    let queryParams: ISnapshotOptions = {};
-
-    if (fetchFullSnapshot) {
-        if (versionId !== "latest") {
-            queryParams = { channels: 1, blobs: 2 };
-        } else {
-            queryParams = { deltas: 1, channels: 1, blobs: 2 };
-        }
-    }
-
+    // We just want to fetch tree here. So explicitly set to not fetch blobs and deltas
+    // as by default server will send that.
+    const queryParams: ISnapshotOptions = { deltas: 0, blobs: 0 };
     const queryString = getQueryString(queryParams);
     const { url, headers } = getUrlAndHeadersWithAuth(
         `${snapshotUrl}${path}${queryString}`, token, forceAccessTokenViaAuthorizationHeader);
@@ -234,18 +224,28 @@ async function fetchLatestSnapshotCore(
                     snapshotOptions,
                     controller,
                 );
+
                 const odspResponse = response.odspResponse;
                 const contentType = odspResponse.headers.get("content-type");
-                odspResponse.propsToLog = {
+
+                const propsToLog: DriverErrorTelemetryProps = {
                     ...odspResponse.propsToLog,
                     contentType,
                     accept: response.requestHeaders.accept,
+                    driverVersion: pkgVersion,
                 };
+
+                // Measure how much time we spend processing payload
+                const snapshotParseEvent = PerformanceEvent.start(logger, {
+                    eventName: "SnapshotParse",
+                    ...propsToLog,
+                });
+
                 let parsedSnapshotContents: IOdspResponse<ISnapshotContents> | undefined;
                 let contentTypeToRead: string | undefined;
-                if (contentType?.indexOf("application/ms-fluid") !== -1) {
+                if (contentType?.includes("application/ms-fluid")) {
                     contentTypeToRead = "application/ms-fluid";
-                } else if (contentType?.indexOf("application/json") !== -1) {
+                } else if (contentType?.includes("application/json")) {
                     contentTypeToRead = "application/json";
                 }
 
@@ -253,7 +253,7 @@ async function fetchLatestSnapshotCore(
                     switch (contentTypeToRead) {
                         case "application/json": {
                             const text = await odspResponse.content.text();
-                            odspResponse.propsToLog.bodySize = text.length;
+                            propsToLog.bodySize = text.length;
                             const content: IOdspSnapshot = JSON.parse(text);
                             validateBlobsAndTrees(content);
                             const snapshotContents: ISnapshotContents =
@@ -263,15 +263,16 @@ async function fetchLatestSnapshotCore(
                         }
                         case "application/ms-fluid": {
                             const content = await odspResponse.content.arrayBuffer();
-                            odspResponse.propsToLog.bodySize = content.byteLength;
+                            propsToLog.bodySize = content.byteLength;
                             const snapshotContents: ISnapshotContents = parseCompactSnapshotResponse(
-                                new ReadBuffer(new Uint8Array(content)));
+                                new Uint8Array(content),
+                                logger);
                             if (snapshotContents.snapshotTree.trees === undefined ||
                                 snapshotContents.snapshotTree.blobs === undefined) {
                                     throw new NonRetryableError(
                                         "Returned odsp snapshot is malformed. No trees or blobs!",
                                         DriverErrorType.incorrectServerResponse,
-                                        { driverVersion: pkgVersion, ...odspResponse.propsToLog },
+                                        propsToLog,
                                     );
                                 }
                             parsedSnapshotContents = { ...odspResponse, content: snapshotContents };
@@ -281,12 +282,12 @@ async function fetchLatestSnapshotCore(
                             throw new NonRetryableError(
                                 "Unknown snapshot content type",
                                 DriverErrorType.incorrectServerResponse,
-                                { driverVersion: pkgVersion, ...odspResponse.propsToLog },
+                                propsToLog,
                             );
                     }
                 } catch (error) {
                     if (isFluidError(error)) {
-                        error.addTelemetryProperties({ driverVersion: pkgVersion, ...odspResponse.propsToLog });
+                        error.addTelemetryProperties(propsToLog);
                         throw error;
                     }
                     const enhancedError = wrapError(
@@ -294,11 +295,14 @@ async function fetchLatestSnapshotCore(
                         (errorMessage) => new NonRetryableError(
                             `Error parsing snapshot response: ${errorMessage}`,
                             DriverErrorType.genericError,
-                            { driverVersion: pkgVersion, ...odspResponse.propsToLog }));
+                            propsToLog));
                     throw enhancedError;
                 }
+
                 assert(parsedSnapshotContents !== undefined, 0x312 /* snapshot should be parsed */);
                 const snapshot = parsedSnapshotContents.content;
+                const { trees, numBlobs, encodedBlobsSize } = evalBlobsAndTrees(snapshot);
+
                 // From: https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming
                 // fetchStart: immediately before the browser starts to fetch the resource.
                 // requestStart: immediately before the browser starts requesting the resource from the server
@@ -351,9 +355,6 @@ async function fetchLatestSnapshotCore(
                     }
                 }
 
-                const { numTrees, numBlobs, encodedBlobsSize } =
-                    evalBlobsAndTrees(parsedSnapshotContents.content);
-
                 // There are some scenarios in ODSP where we cannot cache, trees/latest will explicitly tell us when we
                 // cannot cache using an HTTP response header.
                 const canCache =
@@ -382,8 +383,11 @@ async function fetchLatestSnapshotCore(
                     // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     putInCache(valueWithEpoch);
                 }
+
+                snapshotParseEvent.end();
+
                 event.end({
-                    trees: numTrees,
+                    trees,
                     blobs: snapshot.blobs?.size ?? 0,
                     leafNodes: numBlobs,
                     encodedBlobsSize,
@@ -413,7 +417,7 @@ async function fetchLatestSnapshotCore(
                     // Azure Fluid Relay service is the redeem status (S means success), and FRP is a flag to indicate
                     // if the permission has changed.
                     sltelemetry: odspResponse.headers.get("x-fluid-sltelemetry"),
-                    ...odspResponse.propsToLog,
+                    ...propsToLog,
                 });
                 return snapshot;
             },
@@ -473,13 +477,13 @@ function getFormBodyAndHeaders(
 }
 
 function evalBlobsAndTrees(snapshot: ISnapshotContents) {
-    const numTrees = countTreesInSnapshotTree(snapshot.snapshotTree);
+    const trees = countTreesInSnapshotTree(snapshot.snapshotTree);
     const numBlobs = snapshot.blobs.size;
     let encodedBlobsSize = 0;
     for (const [_, blobContent] of snapshot.blobs) {
         encodedBlobsSize += blobContent.byteLength;
     }
-    return { numTrees, numBlobs, encodedBlobsSize };
+    return { trees, numBlobs, encodedBlobsSize };
 }
 
 export function validateBlobsAndTrees(snapshot: IOdspSnapshot) {

package/src/getFileLink.ts

@@ -4,19 +4,15 @@
  */
 
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { assert, delay } from "@fluidframework/common-utils";
-import { canRetryOnError, getRetryDelayFromError, NonRetryableError } from "@fluidframework/driver-utils";
+import { assert } from "@fluidframework/common-utils";
+import { canRetryOnError, NonRetryableError } from "@fluidframework/driver-utils";
 import { PerformanceEvent } from "@fluidframework/telemetry-utils";
 import { DriverErrorType } from "@fluidframework/driver-definitions";
-import {
-    IOdspUrlParts,
-    OdspResourceTokenFetchOptions,
-    IdentityType,
-    TokenFetcher,
-} from "@fluidframework/odsp-driver-definitions";
+import { IOdspUrlParts, OdspResourceTokenFetchOptions, TokenFetcher } from "@fluidframework/odsp-driver-definitions";
 import { getUrlAndHeadersWithAuth } from "./getUrlAndHeadersWithAuth";
 import { fetchHelper, getWithRetryForTokenRefresh, toInstrumentedOdspTokenFetcher } from "./odspUtils";
 import { pkgVersion as driverVersion } from "./packageVersion";
+import { runWithRetry } from "./retryUtils";
 
 // Store cached responses for the lifetime of web session as file link remains the same for given file item
 const fileLinkCache = new Map<string, Promise<string>>();
@@ -28,17 +24,13 @@ const fileLinkCache = new Map<string, Promise<string>>();
  * throttling error. In future, we are thinking of app allowing to pass some cancel token, with which
  * we would be able to stop retrying.
  * @param getToken - used to fetch access tokens needed to execute operation
- * @param siteUrl - url of the site that contains the file
- * @param driveId - drive where file is stored
- * @param itemId - file id
- * @param identityType - type of client account
+ * @param odspUrlParts - object describing file storage identity
  * @param logger - used to log results of operation, including any error
  * @returns Promise which resolves to file link url when successful; otherwise, undefined.
  */
 export async function getFileLink(
     getToken: TokenFetcher<OdspResourceTokenFetchOptions>,
     odspUrlParts: IOdspUrlParts,
-    identityType: IdentityType,
     logger: ITelemetryLogger,
 ): Promise<string> {
     const cacheKey = `${odspUrlParts.siteUrl}_${odspUrlParts.driveId}_${odspUrlParts.itemId}`;
@@ -47,33 +39,29 @@ export async function getFileLink(
         return maybeFileLinkCacheEntry;
     }
 
-    const valueGenerator = async function() {
-        let result: string | undefined;
-        let success = false;
-        let retryAfterMs = 1000;
-        do {
-            try {
-                result = await getFileLinkCore(getToken, odspUrlParts, identityType, logger);
-                success = true;
-            } catch (err) {
-                // If it is not retriable, then just throw
-                if (!canRetryOnError(err)) {
-                    // Delete from the cache to permit retrying later.
-                    fileLinkCache.delete(cacheKey);
-                    throw err;
-                }
-                // If the error is throttling error, then wait for the specified time before retrying.
-                // If the waitTime is not specified, then we start with retrying immediately to max of 8s.
-                retryAfterMs = getRetryDelayFromError(err) ?? Math.min(retryAfterMs * 2, 8000);
-                await delay(retryAfterMs);
+    const fileLinkGenerator = async function() {
+        let fileLinkCore: string;
+        try {
+            fileLinkCore = await runWithRetry(
+                async () => getFileLinkCore(getToken, odspUrlParts, logger),
+                "getFileLinkCore",
+                logger,
+            );
+        } catch (err) {
+            // runWithRetry throws a non retriable error after it hits the max # of attempts
+            // or encounters an unexpected error type
+            if (!canRetryOnError(err)) {
+                // Delete from the cache to permit retrying later.
+                fileLinkCache.delete(cacheKey);
             }
-        } while (!success);
+            throw err;
+        }
 
         // We are guaranteed to run the getFileLinkCore at least once with successful result (which must be a string)
-        assert(result !== undefined, 0x292 /* "Unexpected undefined result from getFileLinkCore" */);
-        return result;
+        assert(fileLinkCore !== undefined, 0x292 /* "Unexpected undefined result from getFileLinkCore" */);
+        return fileLinkCore;
     };
-    const fileLink = valueGenerator();
+    const fileLink = fileLinkGenerator();
     fileLinkCache.set(cacheKey, fileLink);
     return fileLink;
 }
@@ -81,10 +69,9 @@ export async function getFileLink(
 async function getFileLinkCore(
     getToken: TokenFetcher<OdspResourceTokenFetchOptions>,
     odspUrlParts: IOdspUrlParts,
-    identityType: IdentityType,
     logger: ITelemetryLogger,
 ): Promise<string> {
-    const fileItem = await getFileItemLite(getToken, odspUrlParts, logger, identityType === "Consumer");
+    const fileItem = await getFileItemLite(getToken, odspUrlParts, logger, true);
 
     // ODSP link requires extra call to return link that is resistant to file being renamed or moved to different folder
     return PerformanceEvent.timedExecAsync(
@@ -110,7 +97,7 @@ async function getFileLinkCore(
                         encodeURIComponent(`'${fileItem.webDavUrl}'`)
                     }`,
                     storageToken,
-                    false,
+                    true,
                 );
                 const requestInit = {
                     method: "POST",

package/src/index.ts

@@ -32,6 +32,4 @@ export * from "./odspDriverUrlResolver";
 // It's used by URL resolve code, but also has some public functions
 export * from "./odspFluidFileLink";
 
-// Wire format related
-export * from "./compactSnapshotParser";
-export * from "./ReadBufferUtils";
+export { parseCompactSnapshotResponse } from "./compactSnapshotParser";

package/src/localOdspDriver/localOdspDocumentStorageManager.ts

@@ -13,7 +13,6 @@ import { ISnapshotContents } from "../odspPublicUtils";
 import { IOdspSnapshot } from "../contracts";
 import { convertOdspSnapshotToSnapshotTreeAndBlobs } from "../odspSnapshotParser";
 import { parseCompactSnapshotResponse } from "../compactSnapshotParser";
-import { ReadBuffer } from "../ReadBufferUtils";
 
 /**
  * ODSP document storage service that works on a provided snapshot for all its processing.
@@ -48,7 +47,8 @@ export class LocalOdspDocumentStorageService extends OdspDocumentStorageServiceB
             snapshotContents = convertOdspSnapshotToSnapshotTreeAndBlobs(content);
         } else {
             snapshotContents = parseCompactSnapshotResponse(
-                new ReadBuffer(this.localSnapshot));
+                this.localSnapshot,
+                this.logger);
         }
 
         this.snapshotTreeId = this.initializeFromSnapshot(snapshotContents);