@fluidframework/odsp-driver 0.59.4001 → 1.1.0-75972

package/src/odspError.ts

@@ -4,20 +4,33 @@
  */
 
 import { createOdspNetworkError } from "@fluidframework/odsp-doclib-utils";
+import { DriverErrorType } from "@fluidframework/driver-definitions";
+import { NonRetryableError } from "@fluidframework/driver-utils";
+import { OdspError } from "@fluidframework/odsp-driver-definitions";
+import { IFluidErrorBase } from "@fluidframework/telemetry-utils";
 import { IOdspSocketError } from "./contracts";
+import { pkgVersion as driverVersion } from "./packageVersion";
 
 /**
  * Returns network error based on error object from ODSP socket (IOdspSocketError)
  */
-export function errorObjectFromSocketError(socketError: IOdspSocketError, handler: string) {
-    // pre-0.58 error message prefix: OdspSocketError
-    const message = `ODSP socket error (${handler}): ${socketError.message}`;
-    const error = createOdspNetworkError(
-        message,
-        socketError.code,
-        socketError.retryAfter);
+export function errorObjectFromSocketError(socketError: IOdspSocketError, handler: string):
+    IFluidErrorBase & OdspError {
+    // Make sure we always return something, and do not throw.
+    try {
+        // pre-0.58 error message prefix: OdspSocketError
+        const message = `ODSP socket error (${handler}): ${socketError.message}`;
+        const error = createOdspNetworkError(
+            message,
+            socketError.code,
+            socketError.retryAfter);
 
-    error.addTelemetryProperties({ odspError: true, relayServiceError: true });
-
-    return error;
+        error.addTelemetryProperties({ odspError: true, relayServiceError: true });
+        return error;
+    } catch (error) {
+        return new NonRetryableError(
+            "Internal error: errorObjectFromSocketError",
+            DriverErrorType.fileNotFoundOrAccessDeniedError,
+            { driverVersion });
+    }
 }

package/src/odspPublicUtils.ts

@@ -4,8 +4,25 @@
  */
 
 import { hashFile, IsoBuffer } from "@fluidframework/common-utils";
+import { ISequencedDocumentMessage, ISnapshotTree } from "@fluidframework/protocol-definitions";
 
 export async function getHashedDocumentId(driveId: string, itemId: string): Promise<string> {
     const buffer = IsoBuffer.from(`${driveId}_${itemId}`);
     return encodeURIComponent(await hashFile(buffer, "SHA-256", "base64"));
 }
+
+export interface ISnapshotContents {
+    snapshotTree: ISnapshotTree;
+    blobs: Map<string, ArrayBuffer>;
+    ops: ISequencedDocumentMessage[];
+
+    /**
+     * Sequence number of the snapshot
+     */
+    sequenceNumber: number | undefined;
+
+    /**
+     * Sequence number for the latest op/snapshot for the file in ODSP
+     */
+    latestSequenceNumber: number | undefined;
+}

package/src/odspSnapshotParser.ts

@@ -6,7 +6,7 @@
 import { assert, stringToBuffer } from "@fluidframework/common-utils";
 import * as api from "@fluidframework/protocol-definitions";
 import { IOdspSnapshot, IOdspSnapshotCommit, ISnapshotTreeEx } from "./contracts";
-import { ISnapshotContents } from "./odspUtils";
+import { ISnapshotContents } from "./odspPublicUtils";
 
 /**
  * Build a tree hierarchy base on a flat tree
@@ -51,7 +51,7 @@ function buildHierarchy(flatTree: IOdspSnapshotCommit): api.ISnapshotTree {
  * Converts existing IOdspSnapshot to snapshot tree, blob array and ops
  * @param odspSnapshot - snapshot
  */
-export function convertOdspSnapshotToSnapsohtTreeAndBlobs(
+export function convertOdspSnapshotToSnapshotTreeAndBlobs(
     odspSnapshot: IOdspSnapshot,
 ): ISnapshotContents {
     const blobsWithBufferContent = new Map<string, ArrayBuffer>();
@@ -62,11 +62,16 @@ export function convertOdspSnapshotToSnapsohtTreeAndBlobs(
             blobsWithBufferContent.set(blob.id, stringToBuffer(blob.content, blob.encoding ?? "utf8"));
         });
     }
+
+    const sequenceNumber = odspSnapshot?.trees[0].sequenceNumber;
+
     const val: ISnapshotContents = {
         blobs: blobsWithBufferContent,
         ops: odspSnapshot.ops?.map((op) => op.op) ?? [],
-        sequenceNumber: odspSnapshot?.trees[0].sequenceNumber,
+        sequenceNumber,
         snapshotTree: buildHierarchy(odspSnapshot.trees[0]),
+        latestSequenceNumber: (odspSnapshot.ops && odspSnapshot.ops.length > 0) ?
+            odspSnapshot.ops[odspSnapshot.ops.length - 1].sequenceNumber : sequenceNumber,
     };
     return val;
 }

package/src/odspSummaryUploadManager.ts

@@ -69,9 +69,7 @@ export class OdspSummaryUploadManager {
         referenceSequenceNumber: number,
         tree: api.ISummaryTree,
     ): Promise<IWriteSummaryResponse> {
-        const enableContainerTypeSummaryUpload = this.mc.config.getBoolean("Fluid.Driver.Odsp.EnableContainerTypeSummaryUpload");
-        const containsProtocolTree = enableContainerTypeSummaryUpload &&
-            Object.keys(tree.tree).includes(".protocol");
+        const containsProtocolTree = Object.keys(tree.tree).includes(".protocol");
         const { snapshotTree, blobs } = await this.convertSummaryToSnapshotTree(
             parentHandle,
             tree,
@@ -112,7 +110,6 @@ export class OdspSummaryUploadManager {
                     size: postBody.length,
                     referenceSequenceNumber,
                     type: snapshot.type,
-                    enableContainerTypeSummaryUpload,
                 },
                 async () => {
                     const response = await this.epochTracker.fetchAndParseAsJSON<IWriteSummaryResponse>(

package/src/odspUtils.ts

@@ -13,7 +13,6 @@ import {
     NetworkErrorBasic,
 } 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,
@@ -43,13 +42,6 @@ export const getWithRetryForTokenRefreshRepeat = "getWithRetryForTokenRefreshRep
 /** Parse the given url and return the origin (host name) */
 export const getOrigin = (url: string) => new URL(url).origin;
 
-export interface ISnapshotContents {
-    snapshotTree: ISnapshotTree;
-    blobs: Map<string, ArrayBuffer>;
-    ops: ISequencedDocumentMessage[];
-    sequenceNumber: number | undefined;
-}
-
 export interface IOdspResponse<T> {
     content: T;
     headers: Map<string, string>;
@@ -243,7 +235,8 @@ export const createOdspLogger = (logger?: ITelemetryBaseLogger) =>
     ChildLogger.create(
         logger,
         "OdspDriver",
-        { all:
+        {
+            all:
             {
                 driverVersion,
             },
@@ -307,7 +300,7 @@ export function toInstrumentedOdspTokenFetcher(
                 if (token === null && throwOnNullToken) {
                     throw new NonRetryableError(
                         // pre-0.58 error message: Token is null for ${name} call
-                        `The Host-provided token fetcher for ${name} call returned null`,
+                        `The Host-provided token fetcher returned null`,
                         OdspErrorType.fetchTokenError,
                         { method: name, driverVersion });
                 }
@@ -319,7 +312,7 @@ export function toInstrumentedOdspTokenFetcher(
                 const tokenError = wrapError(
                     error,
                     (errorMessage) => new NetworkErrorBasic(
-                        `The Host-provided token fetcher for ${name} call threw an error: ${errorMessage}`,
+                        `The Host-provided token fetcher threw an error: ${errorMessage}`,
                         OdspErrorType.fetchTokenError,
                         typeof rawCanRetry === "boolean" ? rawCanRetry : false /* canRetry */,
                         { method: name, driverVersion }));

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/odsp-driver";
-export const pkgVersion = "0.59.4001";
+export const pkgVersion = "1.1.0-75972";

package/src/retryErrorsStorageAdapter.ts

@@ -14,7 +14,6 @@ import {
     ISnapshotTree,
     ISummaryHandle,
     ISummaryTree,
-    ITree,
     IVersion,
 } from "@fluidframework/protocol-definitions";
 import { IDisposable, ITelemetryLogger } from "@fluidframework/common-definitions";
@@ -61,13 +60,6 @@ export class RetryErrorsStorageAdapter implements IDocumentStorageService, IDisp
         );
     }
 
-    public async write(tree: ITree, parents: string[], message: string, ref: string): Promise<IVersion> {
-        return this.runWithRetry(
-            async () => this.internalStorageService.write(tree, parents, message, ref),
-            "storage_write",
-        );
-    }
-
     public async uploadSummaryWithContext(summary: ISummaryTree, context: ISummaryContext): Promise<string> {
         // Creation flow with attachment blobs - need to do retries!
         return this.runWithRetry(

package/src/retryUtils.ts

@@ -4,7 +4,7 @@
  */
 
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { assert, delay, performance } from "@fluidframework/common-utils";
+import { delay, performance } from "@fluidframework/common-utils";
 import { canRetryOnError } from "@fluidframework/driver-utils";
 import { OdspErrorType } from "@fluidframework/odsp-driver-definitions";
 import { Odsp409Error } from "./epochTracker";
@@ -43,8 +43,8 @@ export async function runWithRetry<T>(
 
             const coherencyError = error?.[Odsp409Error] === true;
             const serviceReadonlyError = error?.errorType === OdspErrorType.serviceReadOnly;
-            // Retry for 409 coherency errors or serviceReadOnly errors.
-            if (!(coherencyError || serviceReadonlyError)) {
+            // Retry for retriable 409 coherency errors or serviceReadOnly errors.
+            if (!(coherencyError || serviceReadonlyError || canRetry)) {
                 throw error;
             }
 
@@ -66,7 +66,6 @@ export async function runWithRetry<T>(
                 throw error;
             }
 
-            assert(canRetry, 0x24d /* "can retry" */);
             await delay(Math.floor(retryAfter));
             retryAfter += retryAfter / 4 * (1 + Math.random());
             lastError = error;