Client Changes in Fluid Server Cluster Discovery Feature

api-report/routerlicious-driver.api.md

@@ -76,7 +76,7 @@ export class DocumentService implements api.IDocumentService {
 
 // @public (undocumented)
 export class DocumentStorageService extends DocumentStorageServiceProxy {
-    constructor(id: string, manager: GitManager, logger: ITelemetryLogger, policies?: IDocumentStorageServicePolicies, driverPolicies?: IRouterliciousDriverPolicies, blobCache?: ICache<ArrayBufferLike>, snapshotTreeCache?: ICache<ISnapshotTreeVersion>);
+    constructor(id: string, manager: GitManager, logger: ITelemetryLogger, policies?: IDocumentStorageServicePolicies, driverPolicies?: IRouterliciousDriverPolicies, blobCache?: ICache<ArrayBufferLike>, snapshotTreeCache?: ICache<ISnapshotTreeVersion>, noCacheGitManager?: GitManager | undefined);
     // (undocumented)
     getSnapshotTree(version?: IVersion): Promise<ISnapshotTree | null>;
     // (undocumented)
@@ -85,11 +85,14 @@ export class DocumentStorageService extends DocumentStorageServiceProxy {
     get logTailSha(): string | undefined;
     // (undocumented)
     manager: GitManager;
+    // (undocumented)
+    noCacheGitManager?: GitManager | undefined;
 }
 
 // @public (undocumented)
 export interface IRouterliciousDriverPolicies {
     aggregateBlobsSmallerThanBytes: number | undefined;
+    enableDiscovery?: boolean;
     enablePrefetch: boolean;
     enableRestLess: boolean;
     enableWholeSummaryUpload: boolean;
@@ -143,7 +146,7 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
     constructor(tokenProvider: ITokenProvider, driverPolicies?: Partial<IRouterliciousDriverPolicies>);
     // (undocumented)
     createContainer(createNewSummary: ISummaryTree | undefined, resolvedUrl: IResolvedUrl, logger?: ITelemetryBaseLogger, clientIsSummarizer?: boolean): Promise<IDocumentService>;
-    createDocumentService(resolvedUrl: IResolvedUrl, logger?: ITelemetryBaseLogger, clientIsSummarizer?: boolean): Promise<IDocumentService>;
+    createDocumentService(resolvedUrl: IResolvedUrl, logger?: ITelemetryBaseLogger, clientIsSummarizer?: boolean, isCreateContainer?: boolean): Promise<IDocumentService>;
     // (undocumented)
     readonly protocolName = "fluid:";
     }

packages/drivers/local-driver/src/localDocumentService.ts

@@ -33,7 +33,7 @@ export class LocalDocumentService implements api.IDocumentService {
         private readonly innerDocumentService?: api.IDocumentService,
     ) { }
 
-    public dispose() {}
+    public dispose() { }
 
     /**
      * Creates and returns a document storage service for local use.
@@ -43,7 +43,11 @@ export class LocalDocumentService implements api.IDocumentService {
             this.documentId,
             new GitManager(new TestHistorian(this.localDeltaConnectionServer.testDbFactory.testDatabase)),
             new TelemetryNullLogger(),
-            { minBlobSize: 2048 }); // Test blob aggregation.
+            { minBlobSize: 2048 }, // Test blob aggregation.
+            undefined,
+            undefined,
+            undefined,
+            new GitManager(new TestHistorian(this.localDeltaConnectionServer.testDbFactory.testDatabase)));
     }
 
     /**

packages/drivers/routerlicious-driver/src/contracts.ts

@@ -0,0 +1,14 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+// Session information that includes the server urls and session status in the document's metadata
+export interface ISession {
+    // Orderer url of the session
+    ordererUrl: string;
+    // Historian url of the session
+    historianUrl: string;
+    // Session status
+    isSessionAlive: boolean;
+}

packages/drivers/routerlicious-driver/src/documentService.ts

@@ -74,6 +74,12 @@ export class DocumentService implements api.IDocumentService {
             false,
             storageRestWrapper);
         const gitManager = new GitManager(historian);
+        const noCacheHistorian = new Historian(
+            this.gitUrl,
+            true,
+            true,
+            storageRestWrapper);
+        const noCacheGitManager = new GitManager(noCacheHistorian);
         const documentStorageServicePolicies: api.IDocumentStorageServicePolicies = {
             caching: this.driverPolicies.enablePrefetch
                 ? api.LoaderCachingPolicy.Prefetch
@@ -88,7 +94,8 @@ export class DocumentService implements api.IDocumentService {
             documentStorageServicePolicies,
             this.driverPolicies,
             this.blobCache,
-            this.snapshotTreeCache);
+            this.snapshotTreeCache,
+            noCacheGitManager);
         return this.documentStorageService;
     }
 

packages/drivers/routerlicious-driver/src/documentServiceFactory.ts

@@ -23,16 +23,18 @@ import { IRouterliciousDriverPolicies } from "./policies";
 import { ITokenProvider } from "./tokens";
 import { RouterliciousOrdererRestWrapper } from "./restWrapper";
 import { convertSummaryToCreateNewSummary } from "./createNewUtils";
-import { parseFluidUrl, replaceDocumentIdInPath } from "./urlUtils";
+import { parseFluidUrl, replaceDocumentIdInPath, getDiscoveredFluidResolvedUrl } from "./urlUtils";
 import { InMemoryCache } from "./cache";
 import { pkgVersion as driverVersion } from "./packageVersion";
 import { ISnapshotTreeVersion } from "./definitions";
+import { ISession } from "./contracts";
 
 const defaultRouterliciousDriverPolicies: IRouterliciousDriverPolicies = {
     enablePrefetch: true,
     maxConcurrentStorageRequests: 100,
     maxConcurrentOrdererRequests: 100,
     aggregateBlobsSmallerThanBytes: undefined,
+    enableDiscovery: false,
     enableWholeSummaryUpload: false,
     enableRestLess: true,
 };
@@ -66,7 +68,7 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
         ensureFluidResolvedUrl(resolvedUrl);
         assert(!!createNewSummary, 0x204 /* "create empty file not supported" */);
         assert(!!resolvedUrl.endpoints.ordererUrl, 0x0b2 /* "Missing orderer URL!" */);
-        const parsedUrl = parseFluidUrl(resolvedUrl.url);
+        let parsedUrl = parseFluidUrl(resolvedUrl.url);
         if (!parsedUrl.pathname) {
             throw new Error("Parsed url should contain tenant and doc Id!!");
         }
@@ -92,15 +94,14 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
             resolvedUrl.endpoints.ordererUrl,
         );
 
-        // the backend responds with the actual document ID associated with the new container.
-
         // @TODO: Remove returned "string" type when removing back-compat code
-        const res = await ordererRestWrapper.post<{ id: string, token?: string } | string>(
+        const res = await ordererRestWrapper.post<{ id: string, token?: string, session?: ISession } | string>(
             `/documents/${tenantId}`,
             {
                 summary: convertSummaryToCreateNewSummary(appSummary),
                 sequenceNumber: documentAttributes.sequenceNumber,
                 values: quorumValues,
+                enableDiscovery: this.driverPolicies.enableDiscovery,
                 generateToken: this.tokenProvider.documentPostCreateCallback !== undefined,
             },
         );
@@ -111,13 +112,21 @@ 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;
         }
+        if (session && this.driverPolicies.enableDiscovery) {
+            fluidResolvedUrl = getDiscoveredFluidResolvedUrl(resolvedUrl, session);
+        } else {
+            fluidResolvedUrl = resolvedUrl;
+        }
+        parsedUrl = parseFluidUrl(fluidResolvedUrl.url);
 
         // @TODO: Remove token from the condition, checking the documentPostCreateCallback !== undefined
         // is sufficient to determine if the token will be undefined or not.
@@ -126,7 +135,7 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
         }
 
         parsedUrl.set("pathname", replaceDocumentIdInPath(parsedUrl.pathname, documentId));
-        const deltaStorageUrl = resolvedUrl.endpoints.deltaStorageUrl;
+        const deltaStorageUrl = fluidResolvedUrl.endpoints.deltaStorageUrl;
         if (!deltaStorageUrl) {
             throw new Error(
                 `All endpoints urls must be provided. [deltaStorageUrl:${deltaStorageUrl}]`);
@@ -136,16 +145,17 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
 
         return this.createDocumentService(
             {
-                ...resolvedUrl,
+                ...fluidResolvedUrl,
                 url: parsedUrl.toString(),
                 id: documentId,
                 endpoints: {
-                    ...resolvedUrl.endpoints,
+                    ...fluidResolvedUrl.endpoints,
                     deltaStorageUrl: parsedDeltaStorageUrl.toString(),
                 },
             },
             logger,
             clientIsSummarizer,
+            true,
         );
     }
 
@@ -159,10 +169,40 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
         resolvedUrl: IResolvedUrl,
         logger?: ITelemetryBaseLogger,
         clientIsSummarizer?: boolean,
+        isCreateContainer?: boolean,
     ): Promise<IDocumentService> {
         ensureFluidResolvedUrl(resolvedUrl);
 
-        const fluidResolvedUrl = resolvedUrl;
+        const parsedUrl = parseFluidUrl(resolvedUrl.url);
+        const [, tenantId, documentId] = parsedUrl.pathname.split("/");
+        if (!documentId || !tenantId) {
+            throw new Error(
+                `Couldn't parse documentId and/or tenantId. [documentId:${documentId}][tenantId:${tenantId}]`);
+        }
+        const logger2 = ChildLogger.create(logger, "RouterliciousDriver", { all: { driverVersion }});
+
+        let fluidResolvedUrl: IResolvedUrl;
+        if (!isCreateContainer && this.driverPolicies.enableDiscovery) {
+            const rateLimiter = new RateLimiter(this.driverPolicies.maxConcurrentOrdererRequests);
+            const ordererRestWrapper = await RouterliciousOrdererRestWrapper.load(
+                tenantId,
+                documentId,
+                this.tokenProvider,
+                logger2,
+                rateLimiter,
+                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>(
+                `/documents/${tenantId}/session/${documentId}`,
+            );
+            fluidResolvedUrl = getDiscoveredFluidResolvedUrl(resolvedUrl, session);
+        } else {
+            fluidResolvedUrl = resolvedUrl;
+        }
+
         const storageUrl = fluidResolvedUrl.endpoints.storageUrl;
         const ordererUrl = fluidResolvedUrl.endpoints.ordererUrl;
         const deltaStorageUrl = fluidResolvedUrl.endpoints.deltaStorageUrl;
@@ -171,15 +211,6 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
                 `All endpoints urls must be provided. [ordererUrl:${ordererUrl}][deltaStorageUrl:${deltaStorageUrl}]`);
         }
 
-        const parsedUrl = parseFluidUrl(fluidResolvedUrl.url);
-        const [, tenantId, documentId] = parsedUrl.pathname.split("/");
-        if (!documentId || !tenantId) {
-            throw new Error(
-                `Couldn't parse documentId and/or tenantId. [documentId:${documentId}][tenantId:${tenantId}]`);
-        }
-
-        const logger2 = ChildLogger.create(logger, "RouterliciousDriver", { all: { driverVersion }});
-
         return new DocumentService(
             fluidResolvedUrl,
             ordererUrl,

packages/drivers/routerlicious-driver/src/documentStorageService.ts

@@ -37,15 +37,18 @@ export class DocumentStorageService extends DocumentStorageServiceProxy {
         policies: IDocumentStorageServicePolicies,
         driverPolicies?: IRouterliciousDriverPolicies,
         blobCache?: ICache<ArrayBufferLike>,
-        snapshotTreeCache?: ICache<ISnapshotTreeVersion>): IDocumentStorageService {
+        snapshotTreeCache?: ICache<ISnapshotTreeVersion>,
+        noCacheGitManager?: GitManager): IDocumentStorageService {
         const storageService = driverPolicies?.enableWholeSummaryUpload ?
             new WholeSummaryDocumentStorageService(
                 id,
                 manager,
                 logger,
                 policies,
+                driverPolicies,
                 blobCache,
                 snapshotTreeCache,
+                noCacheGitManager,
             ) :
             new ShreddedSummaryDocumentStorageService(
                 id,
@@ -70,7 +73,8 @@ export class DocumentStorageService extends DocumentStorageServiceProxy {
         policies: IDocumentStorageServicePolicies = {},
         driverPolicies?: IRouterliciousDriverPolicies,
         blobCache?: ICache<ArrayBufferLike>,
-        snapshotTreeCache?: ICache<ISnapshotTreeVersion>) {
+        snapshotTreeCache?: ICache<ISnapshotTreeVersion>,
+        public noCacheGitManager?: GitManager) {
         super(DocumentStorageService.loadInternalDocumentStorageService(
             id,
             manager,
@@ -79,6 +83,7 @@ export class DocumentStorageService extends DocumentStorageServiceProxy {
             driverPolicies,
             blobCache,
             snapshotTreeCache,
+            noCacheGitManager,
         ));
     }
 

packages/drivers/routerlicious-driver/src/policies.ts

@@ -32,6 +32,11 @@ export interface IRouterliciousDriverPolicies {
      * Default: false
      */
     enableWholeSummaryUpload: boolean;
+    /**
+     * Enable service endpoint discovery when creating or joining a session.
+     * Default: false
+     */
+    enableDiscovery?: boolean;
     /**
      * Enable using RestLess which avoids CORS preflight requests.
      * Default: true

packages/drivers/routerlicious-driver/src/urlUtils.ts

@@ -3,7 +3,9 @@
  * Licensed under the MIT License.
  */
 
+import { IFluidResolvedUrl } from "@fluidframework/driver-definitions";
 import URLParse from "url-parse";
+import { ISession } from "./contracts";
 
 export const parseFluidUrl = (fluidUrl: string): URLParse => {
     return new URLParse(fluidUrl, true);
@@ -17,3 +19,32 @@ export const parseFluidUrl = (fluidUrl: string): URLParse => {
  */
 export const replaceDocumentIdInPath = (urlPath: string, documentId: string): string =>
     urlPath.split("/").slice(0, -1).concat([documentId]).join("/");
+
+export const getDiscoveredFluidResolvedUrl = (resolvedUrl: IFluidResolvedUrl, session: ISession): IFluidResolvedUrl => {
+    if (session) {
+        const discoveredOrdererUrl = new URLParse(session.ordererUrl);
+        const deltaStorageUrl = new URLParse(resolvedUrl.endpoints.deltaStorageUrl);
+        deltaStorageUrl.set("host", discoveredOrdererUrl.host);
+
+        const discoveredStorageUrl = new URLParse(session.historianUrl);
+        const storageUrl = new URLParse(resolvedUrl.endpoints.storageUrl);
+        storageUrl.set("host", discoveredStorageUrl.host);
+
+        const parsedUrl = parseFluidUrl(resolvedUrl.url);
+        const discoveredResolvedUrl: IFluidResolvedUrl = {
+            endpoints: {
+                deltaStorageUrl: deltaStorageUrl.toString(),
+                ordererUrl: session.ordererUrl,
+                storageUrl: storageUrl.toString(),
+            },
+            id: resolvedUrl.id,
+            tokens: resolvedUrl.tokens,
+            type: resolvedUrl.type,
+            url: new URLParse(`fluid://${discoveredOrdererUrl.host}${parsedUrl.pathname}`).toString(),
+        };
+
+        return discoveredResolvedUrl;
+    } else {
+        return resolvedUrl;
+    }
+};