@fluidframework/odsp-driver 1.1.0 → 1.2.0

package/src/odspDocumentStorageManager.ts

@@ -15,8 +15,6 @@ import {
 import * as api from "@fluidframework/protocol-definitions";
 import {
     ISummaryContext,
-    IDocumentStorageService,
-    LoaderCachingPolicy,
     DriverErrorType,
 } from "@fluidframework/driver-definitions";
 import { RateLimiter, NonRetryableError } from "@fluidframework/driver-utils";
@@ -40,10 +38,11 @@ import {
     getWithRetryForTokenRefresh,
 } from "./odspUtils";
 import { ISnapshotContents } from "./odspPublicUtils";
-import { defaultCacheExpiryTimeoutMs, EpochTracker } from "./epochTracker";
+import { EpochTracker } from "./epochTracker";
 import { OdspSummaryUploadManager } from "./odspSummaryUploadManager";
 import { FlushResult } from "./odspDocumentDeltaConnection";
 import { pkgVersion as driverVersion } from "./packageVersion";
+import { OdspDocumentStorageServiceBase } from "./odspDocumentStorageServiceBase";
 
 export const defaultSummarizerCacheExpiryTimeout: number = 60 * 1000; // 60 seconds.
 
@@ -58,134 +57,15 @@ async function promiseRaceWithWinner<T>(promises: Promise<T>[]): Promise<{ index
     });
 }
 
-class BlobCache {
-    // Save the timeout so we can cancel and reschedule it as needed
-    private blobCacheTimeout: ReturnType<typeof setTimeout> | undefined;
-    // If the defer flag is set when the timeout fires, we'll reschedule rather than clear immediately
-    // This deferral approach is used (rather than clearing/resetting the timer) as current calling patterns trigger
-    // too many calls to setTimeout/clearTimeout.
-    private deferBlobCacheClear: boolean = false;
-
-    private readonly _blobCache: Map<string, ArrayBuffer> = new Map();
-
-    // Tracks all blob IDs evicted from cache
-    private readonly blobsEvicted: Set<string> = new Set();
-
-    // Initial time-out to purge data from cache
-    // If this time out is very small, then we purge blobs from cache too soon and that results in a lot of
-    // requests to storage, which brings down perf and may trip protection limits causing 429s
-    private blobCacheTimeoutDuration = 2 * 60 * 1000;
-
-    // SPO does not keep old snapshots around for long, so we are running chances of not
-    // being able to rehydrate data store / DDS in the future if we purge anything (and with blob de-duping,
-    // even if blob read by runtime, it could be read again in the future)
-    // So for now, purging is disabled.
-    private readonly purgeEnabled = false;
-
-    public get value() {
-        return this._blobCache;
-    }
-
-    public addBlobs(blobs: Map<string, ArrayBuffer>) {
-        blobs.forEach((value, blobId) => {
-            this._blobCache.set(blobId, value);
-        });
-        // Reset the timer on cache set
-        this.scheduleClearBlobsCache();
-    }
-
-    /**
-     * Schedule a timer for clearing the blob cache or defer the current one.
-     */
-    private scheduleClearBlobsCache() {
-        if (this.blobCacheTimeout !== undefined) {
-            // If we already have an outstanding timer, just signal that we should defer the clear
-            this.deferBlobCacheClear = true;
-        } else if (this.purgeEnabled) {
-            // If we don't have an outstanding timer, set a timer
-            // When the timer runs out, we'll decide whether to proceed with the cache clear or reset the timer
-            const clearCacheOrDefer = () => {
-                this.blobCacheTimeout = undefined;
-                if (this.deferBlobCacheClear) {
-                    this.deferBlobCacheClear = false;
-                    this.scheduleClearBlobsCache();
-                } else {
-                    // NOTE: Slightly better algorithm here would be to purge either only big blobs,
-                    // or sort them by size and purge enough big blobs to leave only 256Kb of small blobs in cache
-                    // Purging is optimizing memory footprint. But count controls potential number of storage requests
-                    // We want to optimize both - memory footprint and number of future requests to storage.
-                    // Note that Container can realize data store or DDS on-demand at any point in time, so we do not
-                    // control when blobs will be used.
-                    this._blobCache.forEach((_, blobId) => this.blobsEvicted.add(blobId));
-                    this._blobCache.clear();
-                }
-            };
-            this.blobCacheTimeout = setTimeout(clearCacheOrDefer, this.blobCacheTimeoutDuration);
-            // any future storage reads that get into the cache should be cleared from cache rather quickly -
-            // there is not much value in keeping them longer
-            this.blobCacheTimeoutDuration = 10 * 1000;
-        }
-    }
-
-    public getBlob(blobId: string) {
-        // Reset the timer on attempted cache read
-        this.scheduleClearBlobsCache();
-        const blobContent = this._blobCache.get(blobId);
-        const evicted = this.blobsEvicted.has(blobId);
-        return { blobContent, evicted };
-    }
-
-    public setBlob(blobId: string, blob: ArrayBuffer) {
-        // This API is called as result of cache miss and reading blob from storage.
-        // Runtime never reads same blob twice.
-        // The only reason we may get read request for same blob is blob de-duping in summaries.
-        // Note that the bigger the size, the less likely blobs are the same, so there is very little benefit of caching big blobs.
-        // Images are the only exception - user may insert same image twice. But we currently do not de-dup them - only snapshot
-        // blobs are de-duped.
-        const size = blob.byteLength;
-        if (size < 256 * 1024) {
-            // Reset the timer on cache set
-            this.scheduleClearBlobsCache();
-            return this._blobCache.set(blobId, blob);
-        } else {
-            // we evicted it here by not caching.
-            this.blobsEvicted.add(blobId);
-        }
-    }
-}
-
 interface GetVersionsTelemetryProps {
     cacheEntryAge?: number;
     cacheSummarizerExpired?: boolean;
 }
-export class OdspDocumentStorageService implements IDocumentStorageService {
-    readonly policies = {
-        // By default, ODSP tells the container not to prefetch/cache.
-        caching: LoaderCachingPolicy.NoCaching,
-
-        // ODSP storage works better if it has less number of blobs / edges
-        // Runtime creating many small blobs results in sub-optimal perf.
-        // 2K seems like the sweat spot:
-        // The smaller the number, less blobs we aggregate. Most storages are very likely to have notion
-        // of minimal "cluster" size, so having small blobs is wasteful
-        // At the same time increasing the limit ensure that more blobs with user content are aggregated,
-        // reducing possibility for de-duping of same blobs (i.e. .attributes rolled into aggregate blob
-        // are not reused across data stores, or even within data store, resulting in duplication of content)
-        // Note that duplication of content should not have significant impact for bytes over wire as
-        // compression of http payload mostly takes care of it, but it does impact storage size and in-memory sizes.
-        minBlobSize: 2048,
-        maximumCacheDurationMs: defaultCacheExpiryTimeoutMs,
-    };
-
-    private readonly commitCache: Map<string, api.ISnapshotTree> = new Map();
-
-    private readonly attributesBlobHandles: Set<string> = new Set();
 
+export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
     private readonly odspSummaryUploadManager: OdspSummaryUploadManager;
-    private _ops: api.ISequencedDocumentMessage[] | undefined;
 
     private firstVersionCall = true;
-    private _snapshotSequenceNumber: number | undefined;
 
     private readonly documentId: string;
     private readonly snapshotUrl: string | undefined;
@@ -203,21 +83,6 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
     // limits the amount of parallel "attachment" blob uploads
     private readonly createBlobRateLimiter = new RateLimiter(1);
 
-    private readonly blobCache = new BlobCache();
-
-    public set ops(ops: api.ISequencedDocumentMessage[] | undefined) {
-        assert(this._ops === undefined, 0x0a5 /* "Trying to set ops when they are already set!" */);
-        this._ops = ops;
-    }
-
-    public get ops(): api.ISequencedDocumentMessage[] | undefined {
-        return this._ops;
-    }
-
-    public get snapshotSequenceNumber() {
-        return this._snapshotSequenceNumber;
-    }
-
     constructor(
         private readonly odspResolvedUrl: IOdspResolvedUrl,
         private readonly getStorageToken: InstrumentedStorageTokenFetcher,
@@ -229,10 +94,13 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
         private readonly flushCallback: () => Promise<FlushResult>,
         private readonly snapshotFormatFetchType?: SnapshotFormatSupportType,
     ) {
+        super();
+
         this.documentId = this.odspResolvedUrl.hashedDocumentId;
         this.snapshotUrl = this.odspResolvedUrl.endpoints.snapshotStorageUrl;
         this.attachmentPOSTUrl = this.odspResolvedUrl.endpoints.attachmentPOSTStorageUrl;
         this.attachmentGETUrl = this.odspResolvedUrl.endpoints.attachmentGETStorageUrl;
+
         this.odspSummaryUploadManager = new OdspSummaryUploadManager(
             this.snapshotUrl,
             getStorageToken,
@@ -242,10 +110,6 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
         );
     }
 
-    public get repositoryUrl(): string {
-        return "";
-    }
-
     public async createBlob(file: ArrayBufferLike): Promise<api.ICreateBlobResponse> {
         this.checkAttachmentPOSTUrl();
 
@@ -288,95 +152,56 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
         return response.content;
     }
 
-    private async readBlobCore(blobId: string): Promise<ArrayBuffer> {
-        const { blobContent, evicted } = this.blobCache.getBlob(blobId);
-        let blob = blobContent;
-
-        if (blob === undefined) {
-            this.checkAttachmentGETUrl();
+    protected async fetchBlobFromStorage(blobId: string, evicted: boolean): Promise<ArrayBuffer> {
+        this.checkAttachmentGETUrl();
 
-            blob = await getWithRetryForTokenRefresh(async (options) => {
-                const storageToken = await this.getStorageToken(options, "GetBlob");
-                const unAuthedUrl = `${this.attachmentGETUrl}/${encodeURIComponent(blobId)}/content`;
-                const { url, headers } = getUrlAndHeadersWithAuth(
-                    unAuthedUrl,
-                    storageToken,
-                    !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader,
-                );
+        const blob = await getWithRetryForTokenRefresh(async (options) => {
+            const storageToken = await this.getStorageToken(options, "GetBlob");
+            const unAuthedUrl = `${this.attachmentGETUrl}/${encodeURIComponent(blobId)}/content`;
+            const { url, headers } = getUrlAndHeadersWithAuth(
+                unAuthedUrl,
+                storageToken,
+                !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader,
+            );
 
-                return PerformanceEvent.timedExecAsync(
-                    this.logger,
-                    {
-                        eventName: "readDataBlob",
-                        blobId,
-                        evicted,
-                        headers: Object.keys(headers).length !== 0 ? true : undefined,
+            return PerformanceEvent.timedExecAsync(
+                this.logger,
+                {
+                    eventName: "readDataBlob",
+                    blobId,
+                    evicted,
+                    headers: Object.keys(headers).length !== 0 ? true : undefined,
+                    waitQueueLength: this.epochTracker.rateLimiter.waitQueueLength,
+                },
+                async (event) => {
+                    const res = await this.epochTracker.fetchArray(url, { headers }, "blob");
+                    event.end({
                         waitQueueLength: this.epochTracker.rateLimiter.waitQueueLength,
-                    },
-                    async (event) => {
-                        const res = await this.epochTracker.fetchArray(url, { headers }, "blob");
-                        event.end({
-                            waitQueueLength: this.epochTracker.rateLimiter.waitQueueLength,
+                        ...res.propsToLog,
+                        attempts: options.refresh ? 2 : 1,
+                    });
+                    const cacheControl = res.headers.get("cache-control");
+                    if (cacheControl === undefined || !(cacheControl.includes("private") || cacheControl.includes("public"))) {
+                        this.logger.sendErrorEvent({
+                            eventName: "NonCacheableBlob",
+                            cacheControl,
+                            blobId,
                             ...res.propsToLog,
-                            attempts: options.refresh ? 2 : 1,
                         });
-                        const cacheControl = res.headers.get("cache-control");
-                        if (cacheControl === undefined || !(cacheControl.includes("private") || cacheControl.includes("public"))) {
-                            this.logger.sendErrorEvent({
-                                eventName: "NonCacheableBlob",
-                                cacheControl,
-                                blobId,
-                                ...res.propsToLog,
-                            });
-                        }
-                        return res.content;
-                    },
-                );
-            });
-            this.blobCache.setBlob(blobId, blob);
-        }
-
+                    }
+                    return res.content;
+                },
+            );
+        });
+        this.blobCache.setBlob(blobId, blob);
         return blob;
     }
 
-    public async readBlob(blobId: string): Promise<ArrayBufferLike> {
-        return this.readBlobCore(blobId);
-    }
-
     public async getSnapshotTree(version?: api.IVersion, scenarioName?: string): Promise<api.ISnapshotTree | null> {
         if (!this.snapshotUrl) {
             return null;
         }
-
-        let id: string;
-        if (!version || !version.id) {
-            const versions = await this.getVersions(null, 1, scenarioName);
-            if (!versions || versions.length === 0) {
-                return null;
-            }
-            id = versions[0].id;
-        } else {
-            id = version.id;
-        }
-
-        const snapshotTree = await this.readTree(id, scenarioName);
-        if (!snapshotTree) {
-            return null;
-        }
-
-        if (snapshotTree.blobs) {
-            const attributesBlob = snapshotTree.blobs.attributes;
-            if (attributesBlob) {
-                this.attributesBlobHandles.add(attributesBlob);
-            }
-        }
-
-        // When we upload the container snapshot, we upload appTree in ".app" and protocol tree in ".protocol"
-        // So when we request the snapshot we get ".app" as tree and not as commit node as in the case just above.
-        const appTree = snapshotTree.trees[".app"];
-        const protocolTree = snapshotTree.trees[".protocol"];
-
-        return this.combineProtocolAndAppSnapshotTree(appTree, protocolTree);
+        return super.getSnapshotTree(version, scenarioName);
     }
 
     public async getVersions(blobid: string | null, count: number, scenarioName?: string): Promise<api.IVersion[]> {
@@ -491,21 +316,8 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
 
             // Successful call, make network calls only
             this.firstVersionCall = false;
+            const id = this.initializeFromSnapshot(odspSnapshotCacheValue);
 
-            this._snapshotSequenceNumber = odspSnapshotCacheValue.sequenceNumber;
-            const { snapshotTree, blobs, ops } = odspSnapshotCacheValue;
-            // id should be undefined in case of just ops in snapshot.
-            let id: string | undefined;
-            if (snapshotTree) {
-                id = snapshotTree.id;
-                assert(id !== undefined, 0x221 /* "Root tree should contain the id" */);
-                this.setRootTree(id, snapshotTree);
-            }
-            if (blobs) {
-                this.initBlobsCache(blobs);
-            }
-
-            this.ops = ops;
             return id ? [{ id, treeId: undefined! }] : [];
         }
 
@@ -648,15 +460,14 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
 
         // Enable flushing only if we have single commit summary and this is not the initial summary for an empty file
         if (".protocol" in summary.tree && context.ackHandle !== undefined) {
-            let retry = 0;
-            for (; ;) {
+            let retry = 1;
+            for (;;) {
                 const result = await this.flushCallback();
                 const seq = result.lastPersistedSequenceNumber;
                 if (seq !== undefined && seq >= context.referenceSequenceNumber) {
                     break;
                 }
 
-                retry++;
                 if (retry > 3) {
                     this.logger.sendErrorEvent({
                         eventName: "FlushFailure",
@@ -674,6 +485,7 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                     referenceSequenceNumber: context.referenceSequenceNumber,
                 });
 
+                retry++;
                 await delay(1000 * (result.retryAfter ?? 1));
             }
         }
@@ -682,18 +494,6 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
         return id;
     }
 
-    public async downloadSummary(commit: api.ISummaryHandle): Promise<api.ISummaryTree> {
-        throw new Error("Not implemented yet");
-    }
-
-    private setRootTree(id: string, tree: api.ISnapshotTree) {
-        this.commitCache.set(id, tree);
-    }
-
-    private initBlobsCache(blobs: Map<string, ArrayBuffer>) {
-        this.blobCache.addBlobs(blobs);
-    }
-
     private checkSnapshotUrl() {
         if (!this.snapshotUrl) {
             throw new NonRetryableError(
@@ -721,71 +521,40 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
         }
     }
 
-    private async readTree(id: string, scenarioName?: string): Promise<api.ISnapshotTree | null> {
-        if (!this.snapshotUrl) {
-            return null;
-        }
-        let tree = this.commitCache.get(id);
-        if (!tree) {
-            tree = await getWithRetryForTokenRefresh(async (options) => {
-                const storageToken = await this.getStorageToken(options, "ReadCommit");
-                const snapshotDownloader = async (url: string, fetchOptions: { [index: string]: any; }) => {
-                    return this.epochTracker.fetchAndParseAsJSON(
-                        url,
-                        fetchOptions,
-                        "snapshotTree",
-                        undefined,
-                        scenarioName,
-                    );
-                };
-                const snapshot = await fetchSnapshot(
-                    this.snapshotUrl!,
-                    storageToken,
-                    id,
-                    this.fetchFullSnapshot,
-                    !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader,
-                    this.logger,
-                    snapshotDownloader,
+    protected async fetchTreeFromSnapshot(id: string, scenarioName?: string): Promise<api.ISnapshotTree | undefined> {
+        return getWithRetryForTokenRefresh(async (options) => {
+            const storageToken = await this.getStorageToken(options, "ReadCommit");
+            const snapshotDownloader = async (url: string, fetchOptions: { [index: string]: any; }) => {
+                return this.epochTracker.fetchAndParseAsJSON(
+                    url,
+                    fetchOptions,
+                    "snapshotTree",
+                    undefined,
+                    scenarioName,
                 );
-                let treeId = "";
-                if (snapshot.snapshotTree) {
-                    assert(snapshot.snapshotTree.id !== undefined, 0x222 /* "Root tree should contain the id!!" */);
-                    treeId = snapshot.snapshotTree.id;
-                    this.setRootTree(treeId, snapshot.snapshotTree);
-                }
-                if (snapshot.blobs) {
-                    this.initBlobsCache(snapshot.blobs);
-                }
-                // If the version id doesn't match with the id of the tree, then use the id of first tree which in that case
-                // will be the actual id of tree to be fetched.
-                return this.commitCache.get(id) ?? this.commitCache.get(treeId);
-            });
-        }
-
-        if (!tree) {
-            return null;
-        }
-
-        return tree;
-    }
-
-    private combineProtocolAndAppSnapshotTree(
-        hierarchicalAppTree: api.ISnapshotTree,
-        hierarchicalProtocolTree: api.ISnapshotTree,
-    ) {
-        const summarySnapshotTree: api.ISnapshotTree = {
-            blobs: {
-                ...hierarchicalAppTree.blobs,
-            },
-            trees: {
-                ...hierarchicalAppTree.trees,
-                // the app tree could have a .protocol
-                // in that case we want to server protocol to override it
-                ".protocol": hierarchicalProtocolTree,
-            },
-        };
-
-        return summarySnapshotTree;
+            };
+            const snapshot = await fetchSnapshot(
+                this.snapshotUrl!,
+                storageToken,
+                id,
+                this.fetchFullSnapshot,
+                !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader,
+                this.logger,
+                snapshotDownloader,
+            );
+            let treeId = "";
+            if (snapshot.snapshotTree) {
+                assert(snapshot.snapshotTree.id !== undefined, 0x222 /* "Root tree should contain the id!!" */);
+                treeId = snapshot.snapshotTree.id;
+                this.setRootTree(treeId, snapshot.snapshotTree);
+            }
+            if (snapshot.blobs) {
+                this.initBlobsCache(snapshot.blobs);
+            }
+            // If the version id doesn't match with the id of the tree, then use the id of first tree which in that case
+            // will be the actual id of tree to be fetched.
+            return this.commitCache.get(id) ?? this.commitCache.get(treeId);
+        });
     }
 }