@fluidframework/odsp-driver 0.51.3 → 0.53.0-46105

package/src/odspDocumentStorageManager.ts

@@ -7,8 +7,6 @@ import { default as AbortController } from "abort-controller";
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import {
     assert,
-    stringToBuffer,
-    bufferToString,
     delay,
 } from "@fluidframework/common-utils";
 import {
@@ -19,9 +17,9 @@ import {
     ISummaryContext,
     IDocumentStorageService,
     LoaderCachingPolicy,
+    DriverErrorType,
 } from "@fluidframework/driver-definitions";
-import { RateLimiter } from "@fluidframework/driver-utils";
-import { throwOdspNetworkError } from "@fluidframework/odsp-doclib-utils";
+import { RateLimiter, NonRetryableError } from "@fluidframework/driver-utils";
 import {
     IOdspResolvedUrl,
     ISnapshotOptions,
@@ -315,17 +313,7 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
             this.blobCache.setBlob(blobId, blob);
         }
 
-        if (!this.attributesBlobHandles.has(blobId)) {
-            return blob;
-        }
-        // ODSP document ids are random guids (different per session)
-        // fix the branch name in attributes
-        // this prevents issues when generating summaries
-        const documentAttributes: api.IDocumentAttributes = JSON.parse(bufferToString(blob, "utf8"));
-        documentAttributes.branch = this.documentId;
-        const content = JSON.stringify(documentAttributes);
-        const patchedBlob = stringToBuffer(content, "utf8");
-        return patchedBlob;
+        return blob;
     }
 
     public async readBlob(blobId: string): Promise<ArrayBufferLike> {
@@ -415,22 +403,31 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                 { eventName: "ObtainSnapshot" },
                 async (event: PerformanceEvent) => {
                     const props = {};
-                    let cachedSnapshot: ISnapshotContents | undefined;
+                    let retrievedSnapshot: ISnapshotContents | undefined;
+                    // Here's the logic to grab the persistent cache snapshot implemented by the host
+                    // Epoch tracker is responsible for communicating with the persistent cache, handling epochs and cache versions
                     const cachedSnapshotP: Promise<ISnapshotContents | undefined> =
                         this.epochTracker.get(createCacheSnapshotKey(this.odspResolvedUrl))
-                            .then((snapshotCachedEntry: ISnapshotCachedEntry) => {
+                            .then(async (snapshotCachedEntry: ISnapshotCachedEntry) => {
                                 if (snapshotCachedEntry !== undefined) {
                                     // If the cached entry does not contain the entry time, then assign it a default of 30 days old.
-                                    // eslint-disable-next-line @typescript-eslint/dot-notation
-                                    props["cacheEntryAge"] = Date.now() - (snapshotCachedEntry.cacheEntryTime ??
+                                    const age = Date.now() - (snapshotCachedEntry.cacheEntryTime ??
                                         (Date.now() - 30 * 24 * 60 * 60 * 1000));
+
+                                    // Record the cache age
+                                    // eslint-disable-next-line @typescript-eslint/dot-notation
+                                    props["cacheEntryAge"] = age;
                                 }
+
                                 return snapshotCachedEntry;
                         });
 
+                    // Based on the concurrentSnapshotFetch policy:
+                    // Either retrieve both the network and cache snapshots concurrently and pick the first to return,
+                    // or grab the cache value and then the network value if the cache value returns undefined.
                     let method: string;
                     if (this.hostPolicy.concurrentSnapshotFetch && !this.hostPolicy.summarizerClient) {
-                        const snapshotP = this.fetchSnapshot(hostSnapshotOptions);
+                        const networkSnapshotP = this.fetchSnapshot(hostSnapshotOptions);
 
                         // Ensure that failures on both paths are ignored initially.
                         // I.e. if cache fails for some reason, we will proceed with network result.
@@ -438,20 +435,20 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                         // do want to attempt to succeed with cached data!
                         const promiseRaceWinner = await promiseRaceWithWinner([
                             cachedSnapshotP.catch(() => undefined),
-                            snapshotP.catch(() => undefined),
+                            networkSnapshotP.catch(() => undefined),
                         ]);
-                        cachedSnapshot = promiseRaceWinner.value;
+                        retrievedSnapshot = promiseRaceWinner.value;
                         method = promiseRaceWinner.index === 0 ? "cache" : "network";
 
-                        if (cachedSnapshot === undefined) {
+                        if (retrievedSnapshot === undefined) {
                             // if network failed -> wait for cache ( then return network failure)
                             // If cache returned empty or failed -> wait for network (success of failure)
                             if (promiseRaceWinner.index === 1) {
-                                cachedSnapshot = await cachedSnapshotP;
+                                retrievedSnapshot = await cachedSnapshotP;
                                 method = "cache";
                             }
-                            if (cachedSnapshot === undefined) {
-                                cachedSnapshot = await snapshotP;
+                            if (retrievedSnapshot === undefined) {
+                                retrievedSnapshot = await networkSnapshotP;
                                 method = "network";
                             }
                         }
@@ -459,12 +456,12 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                         // Note: There's a race condition here - another caller may come past the undefined check
                         // while the first caller is awaiting later async code in this block.
 
-                        cachedSnapshot = await cachedSnapshotP;
+                        retrievedSnapshot = await cachedSnapshotP;
 
-                        method = cachedSnapshot !== undefined ? "cache" : "network";
+                        method = retrievedSnapshot !== undefined ? "cache" : "network";
 
-                        if (cachedSnapshot === undefined) {
-                            cachedSnapshot = await this.fetchSnapshot(hostSnapshotOptions);
+                        if (retrievedSnapshot === undefined) {
+                            retrievedSnapshot = await this.fetchSnapshot(hostSnapshotOptions);
                         }
                     }
                     if (method === "network") {
@@ -472,12 +469,11 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                         props["cacheEntryAge"] = undefined;
                     }
                     event.end({ ...props, method });
-                    return cachedSnapshot;
+                    return retrievedSnapshot;
                 },
-                {end: true, cancel: "error"},
             );
 
-            // Successful call, redirect future calls to getVersion only!
+            // Successful call, make network calls only
             this.firstVersionCall = false;
 
             this._snapshotSequenceNumber = odspSnapshotCacheValue.sequenceNumber;
@@ -512,10 +508,16 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
             );
             const versionsResponse = response.content;
             if (!versionsResponse) {
-                throwOdspNetworkError("getVersionsReturnedNoResponse", 400);
+                throw new NonRetryableError(
+                    "getVersionsReturnedNoResponse",
+                    "No response from /versions endpoint",
+                    DriverErrorType.genericNetworkError);
             }
             if (!Array.isArray(versionsResponse.value)) {
-                throwOdspNetworkError("getVersionsReturnedNonArrayResponse", 400);
+                throw new NonRetryableError(
+                    "getVersionsReturnedNonArrayResponse",
+                    "Incorrect response from /versions endpoint",
+                    DriverErrorType.genericNetworkError);
             }
             return versionsResponse.value.map((version) => {
                 // Parse the date from the message
@@ -687,19 +689,28 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
 
     private checkSnapshotUrl() {
         if (!this.snapshotUrl) {
-            throwOdspNetworkError("methodNotSupportedBecauseNoSnapshotUrlWasProvided", 400);
+            throw new NonRetryableError(
+                "noSnapshotUrlProvided",
+                "Method failed because no snapshot url was available",
+                DriverErrorType.genericError);
         }
     }
 
     private checkAttachmentPOSTUrl() {
         if (!this.attachmentPOSTUrl) {
-            throwOdspNetworkError("methodNotSupportedBecauseNoAttachmentPOSTUrlWasProvided", 400);
+            throw new NonRetryableError(
+                "noAttachmentPOSTUrlProvided",
+                "Method failed because no attachment POST url was available",
+                DriverErrorType.genericError);
         }
     }
 
     private checkAttachmentGETUrl() {
         if (!this.attachmentGETUrl) {
-            throwOdspNetworkError("methodNotSupportedBecauseNoAttachmentGETUrlWasProvided", 400);
+            throw new NonRetryableError(
+                "noAttachmentGETUrlWasProvided",
+                "Method failed because no attachment GET url was available",
+                DriverErrorType.genericError);
         }
     }
 

package/src/odspDriverUrlResolver.ts

@@ -7,7 +7,6 @@ import { assert } from "@fluidframework/common-utils";
 import { IFluidCodeDetails, IRequest, isFluidPackage } from "@fluidframework/core-interfaces";
 import { DriverHeader, IResolvedUrl, IUrlResolver } from "@fluidframework/driver-definitions";
 import { IOdspResolvedUrl, ShareLinkTypes, ShareLinkInfoType } from "@fluidframework/odsp-driver-definitions";
-import { createOdspCreateContainerRequest } from "./createOdspCreateContainerRequest";
 import { createOdspUrl } from "./createOdspUrl";
 import { getApiRoot } from "./odspUrlHelper";
 import { getOdspResolvedUrl } from "./odspUtils";
@@ -166,18 +165,6 @@ export class OdspDriverUrlResolver implements IUrlResolver {
             dataStorePath,
         });
     }
-
-    /**
-     * @deprecated - use createOdspCreateContainerRequest
-     */
-    public createCreateNewRequest(
-        siteUrl: string,
-        driveId: string,
-        filePath: string,
-        fileName: string,
-    ): IRequest {
-        return createOdspCreateContainerRequest(siteUrl, driveId, filePath, fileName);
-    }
 }
 
 function decodeOdspUrl(url: string): {

package/src/odspDriverUrlResolverForShareLink.ts

@@ -7,7 +7,7 @@ import { PromiseCache } from "@fluidframework/common-utils";
 import { IFluidCodeDetails, IRequest, isFluidPackage } from "@fluidframework/core-interfaces";
 import { IResolvedUrl, IUrlResolver } from "@fluidframework/driver-definitions";
 import { ITelemetryBaseLogger, ITelemetryLogger } from "@fluidframework/common-definitions";
-import { fetchTokenErrorCode, throwOdspNetworkError } from "@fluidframework/odsp-doclib-utils";
+import { NonRetryableError } from "@fluidframework/driver-utils";
 import { PerformanceEvent } from "@fluidframework/telemetry-utils";
 import {
     IOdspResolvedUrl,
@@ -15,6 +15,7 @@ import {
     isTokenFromCache,
     OdspResourceTokenFetchOptions,
     TokenFetcher,
+    OdspErrorType,
 } from "@fluidframework/odsp-driver-definitions";
 import {
     getLocatorFromOdspUrl,
@@ -22,8 +23,7 @@ import {
     encodeOdspFluidDataStoreLocator,
     locatorQueryParamName,
 } from "./odspFluidFileLink";
-import { OdspDocumentInfo, OdspFluidDataStoreLocator, SharingLinkHeader } from "./contractsPublic";
-import { createOdspCreateContainerRequest } from "./createOdspCreateContainerRequest";
+import { OdspFluidDataStoreLocator, SharingLinkHeader } from "./contractsPublic";
 import { createOdspUrl } from "./createOdspUrl";
 import { OdspDriverUrlResolver } from "./odspDriverUrlResolver";
 import { getOdspResolvedUrl, createOdspLogger } from "./odspUtils";
@@ -77,18 +77,6 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
         }
     }
 
-    /**
-     * @deprecated - use createOdspCreateContainerRequest
-     */
-    public createCreateNewRequest(
-        siteUrl: string,
-        driveId: string,
-        filePath: string,
-        fileName: string,
-    ) {
-        return createOdspCreateContainerRequest(siteUrl, driveId, filePath, fileName);
-    }
-
     /**
      * Takes an already generated data store url (from requestUrl) and appends a path to the
      * existing data store information.
@@ -175,7 +163,10 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
                 { eventName: "GetSharingLinkToken" },
                 async (event) => tokenFetcher(options).then((tokenResponse) => {
                     if (tokenResponse === null) {
-                        throwOdspNetworkError("shareLinkTokenIsNull", fetchTokenErrorCode);
+                        throw new NonRetryableError(
+                            "shareLinkTokenIsNull",
+                            "Token callback returned null",
+                            OdspErrorType.fetchTokenError);
                     }
                     event.end({ fromCache: isTokenFromCache(tokenResponse) });
                     return tokenResponse;
@@ -203,12 +194,8 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
             resolvedUrl,
             this.shareLinkFetcherProps.identityType,
             this.logger,
-        ).then((fileLink) => {
-            if (!fileLink) {
-                throw new Error("Failed to get share link");
-            }
-            return fileLink;
-        }).catch((error) => {
+        ).catch((error) => {
+            // This should imply that error is a non-retriable error.
             this.logger.sendErrorEvent({ eventName: "FluidFileUrlError" }, error);
             this.sharingLinkCache.remove(key);
             throw error;
@@ -254,7 +241,7 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
     /**
      * Crafts a supported document/driver URL
      */
-    public static createDocumentUrl(baseUrl: string, driverInfo: OdspDocumentInfo) {
+    public static createDocumentUrl(baseUrl: string, driverInfo: OdspFluidDataStoreLocator) {
         const url = new URL(baseUrl);
 
         storeLocatorInOdspUrl(url, driverInfo);

package/src/odspError.ts

@@ -11,9 +11,13 @@ import { IOdspSocketError } from "./contracts";
  */
 export function errorObjectFromSocketError(socketError: IOdspSocketError, handler: string) {
     const message = `OdspSocketError (${handler}): ${socketError.message}`;
-    return createOdspNetworkError(
+    const error = createOdspNetworkError(
         `odspSocketError [${handler}]`,
         message,
         socketError.code,
         socketError.retryAfter);
+
+    error.addTelemetryProperties({ odspError: true, relayServiceError: true });
+
+    return error;
 }

package/src/odspUtils.ts

@@ -5,19 +5,14 @@
 
 import { ITelemetryProperties, ITelemetryBaseLogger, ITelemetryLogger } from "@fluidframework/common-definitions";
 import { IResolvedUrl, DriverErrorType } from "@fluidframework/driver-definitions";
-import { isOnline, OnlineStatus } from "@fluidframework/driver-utils";
+import { isOnline, OnlineStatus, RetryableError, NonRetryableError } from "@fluidframework/driver-utils";
 import { assert, performance } from "@fluidframework/common-utils";
 import { ISequencedDocumentMessage, ISnapshotTree } from "@fluidframework/protocol-definitions";
 import { ChildLogger, PerformanceEvent, wrapError } from "@fluidframework/telemetry-utils";
 import {
     fetchIncorrectResponse,
-    offlineFetchFailureStatusCode,
-    fetchFailureStatusCode,
-    fetchTimeoutStatusCode,
     throwOdspNetworkError,
     getSPOAndGraphRequestIdsFromResponse,
-    fetchTokenErrorCode,
-    createOdspNetworkError,
 } from "@fluidframework/odsp-doclib-utils";
 import {
     IOdspResolvedUrl,
@@ -82,7 +77,7 @@ export async function getWithRetryForTokenRefresh<T>(get: (options: TokenFetchOp
             case DriverErrorType.authorizationError:
                 return get({ ...options, claims: e.claims, tenantId: e.tenantId });
 
-            case DriverErrorType.incorrectServerResponse: // fetchIncorrectResponse - some error on the wire, retry once
+            case DriverErrorType.incorrectServerResponse: // some error on the wire, retry once
             case OdspErrorType.fetchTokenError: // If the token was null, then retry once.
                 return get(options);
 
@@ -107,7 +102,10 @@ export async function fetchHelper(
         const response = fetchResponse as any as Response;
         // Let's assume we can retry.
         if (!response) {
-            throwOdspNetworkError("odspFetchErrorNoResponse", fetchIncorrectResponse);
+            throw new NonRetryableError(
+                "odspFetchErrorNoResponse",
+                "No response from fetch call",
+                DriverErrorType.incorrectServerResponse);
         }
         if (!response.ok || response.status < 200 || response.status >= 300) {
             throwOdspNetworkError(
@@ -130,11 +128,13 @@ export async function fetchHelper(
         if (errorText === "TypeError: Failed to fetch") {
             online = OnlineStatus.Offline;
         }
+        // This error is thrown by fetch() when AbortSignal is provided and it gets cancelled
         if (error.name === "AbortError") {
-            throwOdspNetworkError("timeoutDuringFetch", fetchTimeoutStatusCode);
+            throw new RetryableError("fetchAbort", "Fetch Timeout (AbortError)", OdspErrorType.fetchTimeout);
         }
+        // TCP/IP timeout
         if (errorText.indexOf("ETIMEDOUT") !== -1) {
-            throwOdspNetworkError("timeoutDuringFetch(ETIMEDOUT)", fetchTimeoutStatusCode);
+            throw new RetryableError("fetchETimedout", "Fetch Timeout (ETIMEDOUT)", OdspErrorType.fetchTimeout);
         }
 
         //
@@ -142,11 +142,11 @@ export async function fetchHelper(
         // It could container PII, like URI in message itself, or token in properties.
         // It is also non-serializable object due to circular references.
         //
-        const failureCode = online === OnlineStatus.Offline ? offlineFetchFailureStatusCode : fetchFailureStatusCode;
-        throwOdspNetworkError(
-            `odspFetchThrewError [${failureCode}]`,
-            failureCode,
-        );
+        if (online === OnlineStatus.Offline) {
+            throw new RetryableError("OdspFetchOffline", `Offline: ${errorText}`, DriverErrorType.offlineError);
+        } else {
+            throw new RetryableError("OdspFetchError", `Fetch error: ${errorText}`, DriverErrorType.fetchFailure);
+        }
     });
 }
 
@@ -181,30 +181,31 @@ export async function fetchAndParseAsJSONHelper<T>(
     requestInit: RequestInit | undefined,
 ): Promise<IOdspResponse<T>> {
     const { content, headers, commonSpoHeaders, duration } = await fetchHelper(requestInfo, requestInit);
-    // JSON.parse() can fail and message (that goes into telemetry) would container full request URI, including
-    // tokens... It fails for me with "Unexpected end of JSON input" quite often - an attempt to download big file
-    // (many ops) almost always ends up with this error - I'd guess 1% of op request end up here... It always
-    // succeeds on retry.
+    let text: string | undefined;
     try {
-        const text = await content.text();
-
-        commonSpoHeaders.bodySize = text.length;
-        const res = {
-            headers,
-            content: JSON.parse(text),
-            commonSpoHeaders,
-            duration,
-        };
-        return res;
+        text = await content.text();
     } catch (e) {
+        // JSON.parse() can fail and message would container full request URI, including
+        // tokens... It fails for me with "Unexpected end of JSON input" quite often - an attempt to download big file
+        // (many ops) almost always ends up with this error - I'd guess 1% of op request end up here... It always
+        // succeeds on retry.
+        // So do not log error object itself.
         throwOdspNetworkError(
             "errorWhileParsingFetchResponse",
             fetchIncorrectResponse,
-            content,
-            undefined,
-            { error: Object(e) },
+            content, // response
+            text,
         );
     }
+
+    commonSpoHeaders.bodySize = text.length;
+    const res = {
+        headers,
+        content: JSON.parse(text),
+        commonSpoHeaders,
+        duration,
+    };
+    return res;
 }
 
 export interface INewFileInfo {
@@ -293,14 +294,21 @@ export function toInstrumentedOdspTokenFetcher(
                     event.end({ fromCache: isTokenFromCache(tokenResponse), isNull: token === null });
                 }
                 if (token === null && throwOnNullToken) {
-                    throwOdspNetworkError("tokenIsNull", fetchTokenErrorCode, undefined, undefined, { method: name });
+                    throw new NonRetryableError(
+                        "storageTokenIsNull",
+                        `Token is null for ${name} call`,
+                        OdspErrorType.fetchTokenError,
+                        { method: name });
                 }
                 return token;
             }, (error) => {
                 const tokenError = wrapError(
                     error,
-                    (errorMessage) => createOdspNetworkError("tokenFetcherFailed", errorMessage, fetchTokenErrorCode));
-                // eslint-disable-next-line @typescript-eslint/no-throw-literal
+                    (errorMessage) => new NonRetryableError(
+                        "tokenFetcherFailed",
+                        errorMessage,
+                        OdspErrorType.fetchTokenError,
+                        { method: name }));
                 throw tokenError;
             }),
             { cancel: "generic" });

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/odsp-driver";
-export const pkgVersion = "0.51.3";
+export const pkgVersion = "0.53.0-46105";

package/src/zipItDataRepresentationUtils.ts

@@ -9,7 +9,8 @@
 */
 
 import { assert, IsoBuffer, Uint8ArrayToArrayBuffer, Uint8ArrayToString } from "@fluidframework/common-utils";
-import { createOdspNetworkError, fetchIncorrectResponse } from "@fluidframework/odsp-doclib-utils";
+import { NonRetryableError } from "@fluidframework/driver-utils";
+import { DriverErrorType } from "@fluidframework/driver-definitions";
 import { ReadBuffer } from "./ReadBufferUtils";
 
 // eslint-disable-next-line max-len
@@ -477,19 +478,14 @@ function throwBufferParseException(
     expectedNodeType: NodeType,
     message: string,
 ): never {
-    const error = createOdspNetworkError(
+    throw new NonRetryableError(
         "bufferParsingException",
         message,
-        fetchIncorrectResponse,
-        undefined,
-        undefined,
-        undefined,
+        DriverErrorType.incorrectServerResponse,
         {
             nodeType: getNodeType(node),
             expectedNodeType,
         });
-    // eslint-disable-next-line @typescript-eslint/no-throw-literal
-    throw error;
 }
 
 function getNodeType(value: NodeTypes): NodeType {