@fluidframework/routerlicious-driver 1.2.2 → 1.2.3

package/src/documentService.ts

@@ -7,8 +7,9 @@ import { assert } from "@fluidframework/common-utils";
 import * as api from "@fluidframework/driver-definitions";
 import { RateLimiter } from "@fluidframework/driver-utils";
 import { IClient } from "@fluidframework/protocol-definitions";
-import { GitManager, Historian } from "@fluidframework/server-services-client";
+import { GitManager, Historian, RestWrapper } from "@fluidframework/server-services-client";
 import io from "socket.io-client";
+import { PerformanceEvent } from "@fluidframework/telemetry-utils";
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { DeltaStorageService, DocumentDeltaStorageService } from "./deltaStorageService";
 import { DocumentStorageService } from "./documentStorageService";
@@ -20,16 +21,35 @@ import { IRouterliciousDriverPolicies } from "./policies";
 import { ICache } from "./cache";
 import { ISnapshotTreeVersion } from "./definitions";
 
+/**
+ * Amount of time between discoveries within which we don't need to rediscover on re-connect.
+ * Currently, R11s defines session length at 10 minutes. To avoid any weird unknown edge-cases though,
+ * we set the limit to 5 minutes here.
+ * In the future, we likely want to retrieve this information from service's "inactive session" definition.
+ */
+const RediscoverAfterTimeSinceDiscoveryMs = 5 * 60000; // 5 minute
+
 /**
  * The DocumentService manages the Socket.IO connection and manages routing requests to connected
- * clients
+ * clients.
  */
 export class DocumentService implements api.IDocumentService {
+    private lastDiscoveredAt: number = Date.now();
+    private discoverP: Promise<void> | undefined;
+
+    private storageManager: GitManager | undefined;
+    private noCacheStorageManager: GitManager | undefined;
+    private ordererRestWrapper: RestWrapper | undefined;
+
+    public get resolvedUrl() {
+        return this._resolvedUrl;
+    }
+
     constructor(
-        public readonly resolvedUrl: api.IResolvedUrl,
+        private _resolvedUrl: api.IResolvedUrl,
         protected ordererUrl: string,
-        private readonly deltaStorageUrl: string,
-        private readonly gitUrl: string,
+        private deltaStorageUrl: string,
+        private storageUrl: string,
         private readonly logger: ITelemetryLogger,
         protected tokenProvider: ITokenProvider,
         protected tenantId: string,
@@ -37,6 +57,7 @@ export class DocumentService implements api.IDocumentService {
         private readonly driverPolicies: IRouterliciousDriverPolicies,
         private readonly blobCache: ICache<ArrayBufferLike>,
         private readonly snapshotTreeCache: ICache<ISnapshotTreeVersion>,
+        private readonly discoverFluidResolvedUrl: () => Promise<api.IFluidResolvedUrl>,
     ) {
     }
 
@@ -54,32 +75,45 @@ export class DocumentService implements api.IDocumentService {
             return this.documentStorageService;
         }
 
-        if (this.gitUrl === undefined) {
+        if (this.storageUrl === undefined) {
             return new NullBlobStorageService();
         }
 
-        const rateLimiter = new RateLimiter(this.driverPolicies.maxConcurrentStorageRequests);
-        const storageRestWrapper = await RouterliciousStorageRestWrapper.load(
-            this.tenantId,
-            this.documentId,
-            this.tokenProvider,
-            this.logger,
-            rateLimiter,
-            this.driverPolicies.enableRestLess,
-            this.gitUrl,
-        );
-        const historian = new Historian(
-            this.gitUrl,
-            true,
-            false,
-            storageRestWrapper);
-        const gitManager = new GitManager(historian);
-        const noCacheHistorian = new Historian(
-            this.gitUrl,
-            true,
-            true,
-            storageRestWrapper);
-        const noCacheGitManager = new GitManager(noCacheHistorian);
+        const getStorageManager = async (disableCache?: boolean): Promise<GitManager> => {
+            const shouldUpdateDiscoveredSessionInfo = this.shouldUpdateDiscoveredSessionInfo();
+            if (shouldUpdateDiscoveredSessionInfo) {
+                await this.refreshDiscovery();
+            }
+            if (!this.storageManager || !this.noCacheStorageManager || shouldUpdateDiscoveredSessionInfo) {
+                const rateLimiter = new RateLimiter(this.driverPolicies.maxConcurrentStorageRequests);
+                const storageRestWrapper = await RouterliciousStorageRestWrapper.load(
+                    this.tenantId,
+                    this.documentId,
+                    this.tokenProvider,
+                    this.logger,
+                    rateLimiter,
+                    this.driverPolicies.enableRestLess,
+                    this.storageUrl,
+                );
+                const historian = new Historian(
+                    this.storageUrl,
+                    true,
+                    false,
+                    storageRestWrapper);
+                this.storageManager = new GitManager(historian);
+                const noCacheHistorian = new Historian(
+                    this.storageUrl,
+                    true,
+                    true,
+                    storageRestWrapper);
+                this.noCacheStorageManager = new GitManager(noCacheHistorian);
+            }
+
+            return disableCache ? this.noCacheStorageManager : this.storageManager;
+        };
+        // Initialize storageManager and noCacheStorageManager
+        const storageManager = await getStorageManager();
+        const noCacheStorageManager = await getStorageManager(true);
         const documentStorageServicePolicies: api.IDocumentStorageServicePolicies = {
             caching: this.driverPolicies.enablePrefetch
                 ? api.LoaderCachingPolicy.Prefetch
@@ -89,13 +123,14 @@ export class DocumentService implements api.IDocumentService {
 
         this.documentStorageService = new DocumentStorageService(
             this.documentId,
-            gitManager,
+            storageManager,
             this.logger,
             documentStorageServicePolicies,
             this.driverPolicies,
             this.blobCache,
             this.snapshotTreeCache,
-            noCacheGitManager);
+            noCacheStorageManager,
+            getStorageManager);
         return this.documentStorageService;
     }
 
@@ -108,18 +143,38 @@ export class DocumentService implements api.IDocumentService {
         await this.connectToStorage();
         assert(!!this.documentStorageService, 0x0b1 /* "Storage service not initialized" */);
 
-        const rateLimiter = new RateLimiter(this.driverPolicies.maxConcurrentOrdererRequests);
-        const ordererRestWrapper = await RouterliciousOrdererRestWrapper.load(
+        const getRestWrapper = async (): Promise<RestWrapper> => {
+            const shouldUpdateDiscoveredSessionInfo = this.shouldUpdateDiscoveredSessionInfo();
+            if (shouldUpdateDiscoveredSessionInfo) {
+                await this.refreshDiscovery();
+            }
+            if (!this.ordererRestWrapper || shouldUpdateDiscoveredSessionInfo) {
+                const rateLimiter = new RateLimiter(this.driverPolicies.maxConcurrentOrdererRequests);
+                this.ordererRestWrapper = await RouterliciousOrdererRestWrapper.load(
+                    this.tenantId,
+                    this.documentId,
+                    this.tokenProvider,
+                    this.logger,
+                    rateLimiter,
+                    this.driverPolicies.enableRestLess,
+                );
+            }
+            return this.ordererRestWrapper;
+        };
+        const restWrapper = await getRestWrapper();
+        const deltaStorageService = new DeltaStorageService(
+            this.deltaStorageUrl,
+            restWrapper,
+            this.logger,
+            getRestWrapper,
+            () => this.deltaStorageUrl,
+        );
+        return new DocumentDeltaStorageService(
             this.tenantId,
             this.documentId,
-            this.tokenProvider,
-            this.logger,
-            rateLimiter,
-            this.driverPolicies.enableRestLess,
+            deltaStorageService,
+            this.documentStorageService,
         );
-        const deltaStorage = new DeltaStorageService(this.deltaStorageUrl, ordererRestWrapper, this.logger);
-        return new DocumentDeltaStorageService(this.tenantId, this.documentId,
-            deltaStorage, this.documentStorageService);
     }
 
     /**
@@ -129,6 +184,9 @@ export class DocumentService implements api.IDocumentService {
      */
     public async connectToDeltaStream(client: IClient): Promise<api.IDocumentDeltaConnection> {
         const connect = async (refreshToken?: boolean) => {
+            if (this.shouldUpdateDiscoveredSessionInfo()) {
+                await this.refreshDiscovery();
+            }
             const ordererToken = await this.tokenProvider.fetchOrdererToken(
                 this.tenantId,
                 this.documentId,
@@ -147,16 +205,58 @@ export class DocumentService implements api.IDocumentService {
 
         // Attempt to establish connection.
         // Retry with new token on authorization error; otherwise, allow container layer to handle.
+        let connection: api.IDocumentDeltaConnection;
         try {
-            const connection = await connect();
-            return connection;
+            connection = await connect();
         } catch (error: any) {
             if (error?.statusCode === 401) {
                 // Fetch new token and retry once,
                 // otherwise 401 will be bubbled up as non-retriable AuthorizationError.
-                return connect(true /* refreshToken */);
+                connection = await connect(true /* refreshToken */);
             }
             throw error;
         }
+        return connection;
+    }
+
+    /**
+     * Re-discover session URLs if necessary.
+     */
+    private async refreshDiscovery(): Promise<void> {
+        if (!this.discoverP) {
+            this.discoverP = PerformanceEvent.timedExecAsync(
+                this.logger,
+                {
+                    eventName: "refreshSessionDiscovery",
+                },
+                async () => this.refreshDiscoveryCore(),
+            );
+        }
+        return this.discoverP;
+    }
+
+    private async refreshDiscoveryCore(): Promise<void> {
+        const fluidResolvedUrl = await this.discoverFluidResolvedUrl();
+        this._resolvedUrl = fluidResolvedUrl;
+        this.storageUrl = fluidResolvedUrl.endpoints.storageUrl;
+        this.ordererUrl = fluidResolvedUrl.endpoints.ordererUrl;
+        this.deltaStorageUrl = fluidResolvedUrl.endpoints.deltaStorageUrl;
+        this.lastDiscoveredAt = Date.now();
+    }
+
+    /**
+     * Whether enough time has passed since last disconnect to warrant a new discovery call on reconnect.
+     */
+    private shouldUpdateDiscoveredSessionInfo(): boolean {
+        if (!this.driverPolicies.enableDiscovery) {
+            return false;
+        }
+        const now = Date.now();
+        // When connection is disconnected, we cannot know if session has moved or document has been deleted
+        // without re-doing discovery on the next attempt to connect.
+        // Disconnect event is not so reliable in local testing. To ensure re-discovery when necessary,
+        // re-discover if enough time has passed since last discovery.
+        const pastLastDiscoveryTimeThreshold = (now - this.lastDiscoveredAt) > RediscoverAfterTimeSinceDiscoveryMs;
+        return pastLastDiscoveryTimeThreshold;
     }
 }

package/src/documentServiceFactory.ts

@@ -7,6 +7,7 @@ import { assert } from "@fluidframework/common-utils";
 import {
     IDocumentService,
     IDocumentServiceFactory,
+    IFluidResolvedUrl,
     IResolvedUrl,
 } from "@fluidframework/driver-definitions";
 import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
@@ -121,20 +122,14 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
         let documentId: string;
         let token: string | undefined;
         let session: ISession | undefined;
-        let fluidResolvedUrl: IResolvedUrl;
         if (typeof res === "string") {
             documentId = res;
         } else {
             documentId = res.id;
             token = res.token;
-            session = res.session;
+            session = this.driverPolicies.enableDiscovery ? res.session : undefined;
         }
-        if (session && this.driverPolicies.enableDiscovery) {
-            fluidResolvedUrl = getDiscoveredFluidResolvedUrl(resolvedUrl, session);
-        } else {
-            fluidResolvedUrl = resolvedUrl;
-        }
-        parsedUrl = parseFluidUrl(fluidResolvedUrl.url);
+        parsedUrl = parseFluidUrl(resolvedUrl.url);
 
         // @TODO: Remove token from the condition, checking the documentPostCreateCallback !== undefined
         // is sufficient to determine if the token will be undefined or not.
@@ -147,7 +142,7 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
         }
 
         parsedUrl.set("pathname", replaceDocumentIdInPath(parsedUrl.pathname, documentId));
-        const deltaStorageUrl = fluidResolvedUrl.endpoints.deltaStorageUrl;
+        const deltaStorageUrl = resolvedUrl.endpoints.deltaStorageUrl;
         if (!deltaStorageUrl) {
             throw new Error(
                 `All endpoints urls must be provided. [deltaStorageUrl:${deltaStorageUrl}]`);
@@ -157,22 +152,22 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
 
         return this.createDocumentService(
             {
-                ...fluidResolvedUrl,
+                ...resolvedUrl,
                 url: parsedUrl.toString(),
                 id: documentId,
                 endpoints: {
-                    ...fluidResolvedUrl.endpoints,
+                    ...resolvedUrl.endpoints,
                     deltaStorageUrl: parsedDeltaStorageUrl.toString(),
                 },
             },
             logger,
             clientIsSummarizer,
-            true,
+            session,
         );
     }
 
     /**
-     * {@inheritDoc @fluidframework/driver-definitions#IDocumentServiceFactory.createContainer}
+     * {@inheritDoc @fluidframework/driver-definitions#IDocumentServiceFactory.createDocumentService}
      *
      * @returns Routerlicious document service.
      */
@@ -180,7 +175,7 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
         resolvedUrl: IResolvedUrl,
         logger?: ITelemetryBaseLogger,
         clientIsSummarizer?: boolean,
-        isCreateContainer?: boolean,
+        session?: ISession,
     ): Promise<IDocumentService> {
         ensureFluidResolvedUrl(resolvedUrl);
 
@@ -192,8 +187,10 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
         }
         const logger2 = ChildLogger.create(logger, "RouterliciousDriver", { all: { driverVersion } });
 
-        let fluidResolvedUrl: IResolvedUrl;
-        if (!isCreateContainer && this.driverPolicies.enableDiscovery) {
+        const discoverFluidResolvedUrl = async (): Promise<IFluidResolvedUrl> => {
+            if (!this.driverPolicies.enableDiscovery) {
+                return resolvedUrl;
+            }
             const rateLimiter = new RateLimiter(this.driverPolicies.maxConcurrentOrdererRequests);
             const ordererRestWrapper = await RouterliciousOrdererRestWrapper.load(
                 tenantId,
@@ -204,15 +201,15 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
                 this.driverPolicies.enableRestLess,
                 resolvedUrl.endpoints.ordererUrl,
             );
-
-            // the backend responds with the actual document session associated with the container.
-            const session: ISession = await ordererRestWrapper.get<ISession>(
+            // The service responds with the current document session associated with the container.
+            const discoveredSession = await ordererRestWrapper.get<ISession>(
                 `/documents/${tenantId}/session/${documentId}`,
             );
-            fluidResolvedUrl = getDiscoveredFluidResolvedUrl(resolvedUrl, session);
-        } else {
-            fluidResolvedUrl = resolvedUrl;
-        }
+            return getDiscoveredFluidResolvedUrl(resolvedUrl, discoveredSession);
+        };
+        const fluidResolvedUrl: IFluidResolvedUrl = session !== undefined
+            ? getDiscoveredFluidResolvedUrl(resolvedUrl, session)
+            : await discoverFluidResolvedUrl();
 
         const storageUrl = fluidResolvedUrl.endpoints.storageUrl;
         const ordererUrl = fluidResolvedUrl.endpoints.ordererUrl;
@@ -233,7 +230,8 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
             documentId,
             this.driverPolicies,
             this.blobCache,
-            this.snapshotTreeCache);
+            this.snapshotTreeCache,
+            discoverFluidResolvedUrl);
     }
 }
 
@@ -248,7 +246,7 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
  * - How would a user delete the created document?
  * - What would a retry pattern look like here?
  */
- export class DocumentPostCreateError extends Error {
+export class DocumentPostCreateError extends Error {
     public constructor(
         /**
          * Inner error being wrapped.

package/src/documentStorageService.ts

@@ -8,7 +8,7 @@ import {
     IDocumentStorageService,
     IDocumentStorageServicePolicies,
     LoaderCachingPolicy,
- } from "@fluidframework/driver-definitions";
+} from "@fluidframework/driver-definitions";
 import {
     ISnapshotTree,
     IVersion,
@@ -38,7 +38,9 @@ export class DocumentStorageService extends DocumentStorageServiceProxy {
         driverPolicies?: IRouterliciousDriverPolicies,
         blobCache?: ICache<ArrayBufferLike>,
         snapshotTreeCache?: ICache<ISnapshotTreeVersion>,
-        noCacheGitManager?: GitManager): IDocumentStorageService {
+        noCacheGitManager?: GitManager,
+        getStorageManager?: (disableCache?: boolean) => Promise<GitManager>,
+    ): IDocumentStorageService {
         const storageService = driverPolicies?.enableWholeSummaryUpload ?
             new WholeSummaryDocumentStorageService(
                 id,
@@ -49,6 +51,7 @@ export class DocumentStorageService extends DocumentStorageServiceProxy {
                 blobCache,
                 snapshotTreeCache,
                 noCacheGitManager,
+                getStorageManager,
             ) :
             new ShreddedSummaryDocumentStorageService(
                 id,
@@ -58,6 +61,7 @@ export class DocumentStorageService extends DocumentStorageServiceProxy {
                 driverPolicies,
                 blobCache,
                 snapshotTreeCache,
+                getStorageManager,
             );
         // TODO: worth prefetching latest summary making version + snapshot call with WholeSummary storage?
         if (!driverPolicies?.enableWholeSummaryUpload && policies.caching === LoaderCachingPolicy.Prefetch) {
@@ -74,7 +78,9 @@ export class DocumentStorageService extends DocumentStorageServiceProxy {
         driverPolicies?: IRouterliciousDriverPolicies,
         blobCache?: ICache<ArrayBufferLike>,
         snapshotTreeCache?: ICache<ISnapshotTreeVersion>,
-        public noCacheGitManager?: GitManager) {
+        public noCacheGitManager?: GitManager,
+        getStorageManager?: (disableCache?: boolean) => Promise<GitManager>,
+    ) {
         super(DocumentStorageService.loadInternalDocumentStorageService(
             id,
             manager,
@@ -84,6 +90,7 @@ export class DocumentStorageService extends DocumentStorageServiceProxy {
             blobCache,
             snapshotTreeCache,
             noCacheGitManager,
+            getStorageManager,
         ));
     }
 

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/routerlicious-driver";
-export const pkgVersion = "1.2.2";
+export const pkgVersion = "1.2.3";

package/src/shreddedSummaryDocumentStorageService.ts

@@ -12,7 +12,7 @@ import {
     IDocumentStorageService,
     ISummaryContext,
     IDocumentStorageServicePolicies,
- } from "@fluidframework/driver-definitions";
+} from "@fluidframework/driver-definitions";
 import { buildHierarchy } from "@fluidframework/protocol-base";
 import {
     ICreateBlobResponse,
@@ -45,12 +45,20 @@ export class ShreddedSummaryDocumentStorageService implements IDocumentStorageSe
     protected readonly blobsShaCache = new Map<string, string>();
     private readonly blobCache: ICache<ArrayBufferLike> | undefined;
     private readonly snapshotTreeCache: ICache<ISnapshotTreeVersion> | undefined;
-    private readonly summaryUploadManager: ISummaryUploadManager;
 
     public get repositoryUrl(): string {
         return "";
     }
 
+    private async getSummaryUploadManager(): Promise<ISummaryUploadManager> {
+        const manager = await this.getStorageManager();
+        return new SummaryTreeUploadManager(
+            new RetriableGitManager(manager, this.logger),
+            this.blobsShaCache,
+            this.getPreviousFullSnapshot.bind(this),
+        );
+    }
+
     constructor(
         protected readonly id: string,
         protected readonly manager: GitManager,
@@ -58,12 +66,9 @@ export class ShreddedSummaryDocumentStorageService implements IDocumentStorageSe
         public readonly policies: IDocumentStorageServicePolicies = {},
         driverPolicies?: IRouterliciousDriverPolicies,
         blobCache?: ICache<ArrayBufferLike>,
-        snapshotTreeCache?: ICache<ISnapshotTreeVersion>) {
-        this.summaryUploadManager = new SummaryTreeUploadManager(
-                new RetriableGitManager(manager, logger),
-                this.blobsShaCache,
-                this.getPreviousFullSnapshot.bind(this),
-            );
+        snapshotTreeCache?: ICache<ISnapshotTreeVersion>,
+        private readonly getStorageManager: (disableCache?: boolean) => Promise<GitManager> = async () => this.manager,
+    ) {
         if (driverPolicies?.enableRestLess === true || isNode) {
             this.blobCache = blobCache ?? new InMemoryCache();
             this.snapshotTreeCache = snapshotTreeCache ?? new InMemoryCache();
@@ -79,7 +84,10 @@ export class ShreddedSummaryDocumentStorageService implements IDocumentStorageSe
                 versionId: id,
                 count,
             },
-            async () => this.manager.getCommits(id, count),
+            async () => {
+                const manager = await this.getStorageManager();
+                return manager.getCommits(id, count);
+            },
         );
         return commits.map((commit) => ({
             date: commit.commit.author.date,
@@ -111,7 +119,8 @@ export class ShreddedSummaryDocumentStorageService implements IDocumentStorageSe
                 treeId: requestVersion.treeId,
             },
             async (event) => {
-                const response = await this.manager.getTree(requestVersion!.treeId);
+                const manager = await this.getStorageManager();
+                const response = await manager.getTree(requestVersion!.treeId);
                 event.end({
                     size: response.tree.length,
                 });
@@ -136,7 +145,8 @@ export class ShreddedSummaryDocumentStorageService implements IDocumentStorageSe
                 blobId,
             },
             async (event) => {
-                const response = await this.manager.getBlob(blobId);
+                const manager = await this.getStorageManager();
+                const response = await manager.getBlob(blobId);
                 event.end({
                     size: response.size,
                 });
@@ -155,7 +165,10 @@ export class ShreddedSummaryDocumentStorageService implements IDocumentStorageSe
             {
                 eventName: "uploadSummaryWithContext",
             },
-            async () => this.summaryUploadManager.writeSummaryTree(summary, context.ackHandle ?? "", "channel"),
+            async () => {
+                const summaryUploadManager = await this.getSummaryUploadManager();
+                return summaryUploadManager.writeSummaryTree(summary, context.ackHandle ?? "", "channel");
+            },
         );
         return summaryHandle;
     }
@@ -173,7 +186,8 @@ export class ShreddedSummaryDocumentStorageService implements IDocumentStorageSe
                 size: uint8ArrayFile.length,
             },
             async (event) => {
-                const response = await this.manager.createBlob(
+                const manager = await this.getStorageManager();
+                const response = await manager.createBlob(
                     Uint8ArrayToString(
                         uint8ArrayFile, "base64"),
                     "base64").then((r) => ({ id: r.sha, url: r.url }));

package/src/wholeSummaryDocumentStorageService.ts

@@ -16,7 +16,7 @@ import {
 } from "@fluidframework/driver-definitions";
 import {
     convertSnapshotAndBlobsToSummaryTree,
- } from "@fluidframework/driver-utils";
+} from "@fluidframework/driver-utils";
 import {
     ICreateBlobResponse,
     ISnapshotTree,
@@ -38,13 +38,17 @@ import { IRouterliciousDriverPolicies } from "./policies";
 const latestSnapshotId: string = "latest";
 
 export class WholeSummaryDocumentStorageService implements IDocumentStorageService {
-    private readonly summaryUploadManager: ISummaryUploadManager;
     private firstVersionsCall: boolean = true;
 
     public get repositoryUrl(): string {
         return "";
     }
 
+    private async getSummaryUploadManager(): Promise<ISummaryUploadManager> {
+        const manager = await this.getStorageManager();
+        return new WholeSummaryUploadManager(manager);
+    }
+
     constructor(
         protected readonly id: string,
         protected readonly manager: GitManager,
@@ -53,8 +57,10 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
         private readonly driverPolicies?: IRouterliciousDriverPolicies,
         private readonly blobCache: ICache<ArrayBufferLike> = new InMemoryCache(),
         private readonly snapshotTreeCache: ICache<ISnapshotTreeVersion> = new InMemoryCache(),
-        protected readonly noCacheGitManager?: GitManager) {
-        this.summaryUploadManager = new WholeSummaryUploadManager(manager);
+        private readonly noCacheGitManager?: GitManager,
+        private readonly getStorageManager: (disableCache?: boolean) => Promise<GitManager> = async (disableCache) =>
+            disableCache && this.noCacheGitManager !== undefined ? this.noCacheGitManager : this.manager,
+    ) {
     }
 
     public async getVersions(versionId: string | null, count: number): Promise<IVersion[]> {
@@ -87,7 +93,10 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
                 versionId: id,
                 count,
             },
-            async () => this.manager.getCommits(id, count),
+            async () => {
+                const manager = await this.getStorageManager();
+                return manager.getCommits(id, count);
+            },
         );
         return commits.map((commit) => ({
             date: commit.commit.author.date,
@@ -123,7 +132,8 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
                 blobId,
             },
             async (event) => {
-                const response = await this.manager.getBlob(blobId);
+                const manager = await this.getStorageManager();
+                const response = await manager.getBlob(blobId);
                 event.end({
                     size: response.size,
                 });
@@ -143,7 +153,10 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
             {
                 eventName: "uploadSummaryWithContext",
             },
-            async () => this.summaryUploadManager.writeSummaryTree(summary, context.ackHandle ?? "", "channel"),
+            async () => {
+                const summaryUploadManager = await this.getSummaryUploadManager();
+                return summaryUploadManager.writeSummaryTree(summary, context.ackHandle ?? "", "channel");
+            },
         );
         return summaryHandle;
     }
@@ -156,7 +169,8 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
                 treeId: summaryHandle.handle,
             },
             async (event) => {
-                const response = await this.manager.getSummary(summaryHandle.handle);
+                const manager = await this.getStorageManager();
+                const response = await manager.getSummary(summaryHandle.handle);
                 event.end({
                     size: response.trees[0]?.entries.length,
                 });
@@ -177,7 +191,8 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
                 size: uint8ArrayFile.length,
             },
             async (event) => {
-                const response = await this.manager.createBlob(
+                const manager = await this.getStorageManager();
+                const response = await manager.createBlob(
                     Uint8ArrayToString(
                         uint8ArrayFile, "base64"),
                     "base64").then((r) => ({ id: r.sha, url: r.url }));
@@ -202,9 +217,8 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
                 treeId: versionId,
             },
             async (event) => {
-                const response = disableCache && this.noCacheGitManager !== undefined ?
-                    await this.noCacheGitManager.getSummary(versionId) :
-                    await this.manager.getSummary(versionId);
+                const manager = await this.getStorageManager(disableCache);
+                const response = await manager.getSummary(versionId);
                 event.end({
                     size: response.trees[0]?.entries.length,
                 });