@fluidframework/routerlicious-driver 2.0.0-internal.2.2.1 → 2.0.0-internal.2.3.0

package/src/documentService.ts

@@ -40,7 +40,6 @@ export class DocumentService implements api.IDocumentService {
 
     private storageManager: GitManager | undefined;
     private noCacheStorageManager: GitManager | undefined;
-    private ordererRestWrapper: RestWrapper | undefined;
 
     public get resolvedUrl() {
         return this._resolvedUrl;
@@ -56,6 +55,8 @@ export class DocumentService implements api.IDocumentService {
         protected tokenProvider: ITokenProvider,
         protected tenantId: string,
         protected documentId: string,
+        protected ordererRestWrapper: RouterliciousOrdererRestWrapper,
+        private readonly documentStorageServicePolicies: api.IDocumentStorageServicePolicies,
         private readonly driverPolicies: IRouterliciousDriverPolicies,
         private readonly blobCache: ICache<ArrayBufferLike>,
         private readonly snapshotTreeCache: ICache<ISnapshotTreeVersion>,
@@ -116,18 +117,11 @@ export class DocumentService implements api.IDocumentService {
         // Initialize storageManager and noCacheStorageManager
         const storageManager = await getStorageManager();
         const noCacheStorageManager = await getStorageManager(true);
-        const documentStorageServicePolicies: api.IDocumentStorageServicePolicies = {
-            caching: this.driverPolicies.enablePrefetch
-                ? api.LoaderCachingPolicy.Prefetch
-                : api.LoaderCachingPolicy.NoCaching,
-            minBlobSize: this.driverPolicies.aggregateBlobsSmallerThanBytes,
-        };
-
         this.documentStorageService = new DocumentStorageService(
             this.documentId,
             storageManager,
             this.logger,
-            documentStorageServicePolicies,
+            this.documentStorageServicePolicies,
             this.driverPolicies,
             this.blobCache,
             this.snapshotTreeCache,
@@ -147,10 +141,9 @@ export class DocumentService implements api.IDocumentService {
 
         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,
@@ -187,27 +180,32 @@ export class DocumentService implements api.IDocumentService {
      */
     public async connectToDeltaStream(client: IClient): Promise<api.IDocumentDeltaConnection> {
         const connect = async (refreshToken?: boolean) => {
+            let ordererToken = this.ordererRestWrapper.getToken();
             if (this.shouldUpdateDiscoveredSessionInfo()) {
                 await this.refreshDiscovery();
             }
 
-            const ordererToken = await PerformanceEvent.timedExecAsync(
-                this.logger,
-                {
-                    eventName: "GetDeltaStreamToken",
-                    docId: this.documentId,
-                    details: JSON.stringify({
-                        refreshToken,
-                    }),
-                },
-                async () => {
-                    return this.tokenProvider.fetchOrdererToken(
-                        this.tenantId,
-                        this.documentId,
-                        refreshToken,
-                    );
-                }
-            );
+            if (refreshToken) {
+                ordererToken = await PerformanceEvent.timedExecAsync(
+                    this.logger,
+                    {
+                        eventName: "GetDeltaStreamToken",
+                        docId: this.documentId,
+                        details: JSON.stringify({
+                            refreshToken,
+                        }),
+                    },
+                    async () => {
+                        const newOrdererToken = await this.tokenProvider.fetchOrdererToken(
+                            this.tenantId,
+                            this.documentId,
+                            refreshToken,
+                        );
+                        this.ordererRestWrapper.setToken(newOrdererToken);
+                        return newOrdererToken;
+                    }
+                );
+            }
 
             return PerformanceEvent.timedExecAsync(
                 this.logger,

package/src/documentServiceFactory.ts

@@ -5,10 +5,13 @@
 
 import { assert } from "@fluidframework/common-utils";
 import {
+    FiveDaysMs,
     IDocumentService,
     IDocumentServiceFactory,
+    IDocumentStorageServicePolicies,
     IFluidResolvedUrl,
     IResolvedUrl,
+    LoaderCachingPolicy,
 } from "@fluidframework/driver-definitions";
 import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
 import { ISummaryTree } from "@fluidframework/protocol-definitions";
@@ -30,6 +33,8 @@ import { ICache, InMemoryCache, NullCache } from "./cache";
 import { pkgVersion as driverVersion } from "./packageVersion";
 import { ISnapshotTreeVersion } from "./definitions";
 
+const maximumSnapshotCacheDurationMs: FiveDaysMs = 432_000_000; // 5 days in ms
+
 const defaultRouterliciousDriverPolicies: IRouterliciousDriverPolicies = {
     enablePrefetch: true,
     maxConcurrentStorageRequests: 100,
@@ -55,13 +60,16 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
         private readonly tokenProvider: ITokenProvider,
         driverPolicies: Partial<IRouterliciousDriverPolicies> = {},
     ) {
+        // Use the maximum allowed by the policy (IDocumentStorageServicePolicies.maximumCacheDurationMs set below)
+        const snapshotCacheExpiryMs: FiveDaysMs = maximumSnapshotCacheDurationMs;
+
         this.driverPolicies = {
             ...defaultRouterliciousDriverPolicies,
             ...driverPolicies,
         };
         this.blobCache = new InMemoryCache<ArrayBufferLike>();
         this.snapshotTreeCache = this.driverPolicies.enableInternalSummaryCaching
-            ? new InMemoryCache<ISnapshotTreeVersion>()
+            ? new InMemoryCache<ISnapshotTreeVersion>(snapshotCacheExpiryMs)
             : new NullCache<ISnapshotTreeVersion>();
     }
 
@@ -209,7 +217,6 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
         session?: ISession,
     ): Promise<IDocumentService> {
         ensureFluidResolvedUrl(resolvedUrl);
-
         const parsedUrl = parseFluidUrl(resolvedUrl.url);
         const [, tenantId, documentId] = parsedUrl.pathname.split("/");
         if (!documentId || !tenantId) {
@@ -218,20 +225,20 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
         }
         const logger2 = ChildLogger.create(logger, "RouterliciousDriver", { all: { driverVersion } });
 
+        const rateLimiter = new RateLimiter(this.driverPolicies.maxConcurrentOrdererRequests);
+        const ordererRestWrapper = await RouterliciousOrdererRestWrapper.load(
+            tenantId,
+            documentId,
+            this.tokenProvider,
+            logger2,
+            rateLimiter,
+            this.driverPolicies.enableRestLess,
+        );
+
         const discoverFluidResolvedUrl = async (): Promise<IFluidResolvedUrl> => {
             if (!this.driverPolicies.enableDiscovery) {
                 return resolvedUrl;
             }
-            const rateLimiter = new RateLimiter(this.driverPolicies.maxConcurrentOrdererRequests);
-            const ordererRestWrapper = await RouterliciousOrdererRestWrapper.load(
-                tenantId,
-                documentId,
-                this.tokenProvider,
-                logger2,
-                rateLimiter,
-                this.driverPolicies.enableRestLess,
-                resolvedUrl.endpoints.ordererUrl,
-            );
 
             const discoveredSession = await PerformanceEvent.timedExecAsync(
                 logger2,
@@ -242,7 +249,7 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
                 async () => {
                     // The service responds with the current document session associated with the container.
                     return ordererRestWrapper.get<ISession>(
-                        `/documents/${tenantId}/session/${documentId}`);
+                        `${resolvedUrl.endpoints.ordererUrl}/documents/${tenantId}/session/${documentId}`);
                 });
             return getDiscoveredFluidResolvedUrl(resolvedUrl, discoveredSession);
         };
@@ -259,6 +266,14 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
                 `All endpoints urls must be provided. [ordererUrl:${ordererUrl}][deltaStorageUrl:${deltaStorageUrl}]`);
         }
 
+        const documentStorageServicePolicies: IDocumentStorageServicePolicies = {
+            caching: this.driverPolicies.enablePrefetch
+                ? LoaderCachingPolicy.Prefetch
+                : LoaderCachingPolicy.NoCaching,
+            minBlobSize: this.driverPolicies.aggregateBlobsSmallerThanBytes,
+            maximumCacheDurationMs: maximumSnapshotCacheDurationMs,
+        };
+
         return new DocumentService(
             fluidResolvedUrl,
             ordererUrl,
@@ -269,6 +284,8 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
             this.tokenProvider,
             tenantId,
             documentId,
+            ordererRestWrapper,
+            documentStorageServicePolicies,
             this.driverPolicies,
             this.blobCache,
             this.snapshotTreeCache,

package/src/documentStorageService.ts

@@ -74,7 +74,7 @@ export class DocumentStorageService extends DocumentStorageServiceProxy {
         public readonly id: string,
         public manager: GitManager,
         logger: ITelemetryLogger,
-        policies: IDocumentStorageServicePolicies = {},
+        policies: IDocumentStorageServicePolicies,
         driverPolicies?: IRouterliciousDriverPolicies,
         blobCache?: ICache<ArrayBufferLike>,
         snapshotTreeCache?: ICache<ISnapshotTreeVersion>,

package/src/errorUtils.ts

@@ -14,6 +14,7 @@ import { pkgVersion as driverVersion } from "./packageVersion";
 
 export enum R11sErrorType {
     fileNotFoundOrAccessDeniedError = "fileNotFoundOrAccessDeniedError",
+    sslCertError = "sslCertError",
 }
 
 /**
@@ -65,8 +66,12 @@ export function createR11sNetworkError(
             // If a service is temporarily down or a browser resource limit is reached, RestWrapper will throw
             // a network error with no status code (e.g. err:ERR_CONN_REFUSED or err:ERR_FAILED) and
             // the error message will start with NetworkError as defined in restWrapper.ts
-            return new GenericNetworkError(
-                errorMessage, errorMessage.startsWith("NetworkError"), props);
+            // If there exists a self-signed SSL certificates error, throw a NonRetryableError
+            // TODO: instead of relying on string matching, filter error based on the error code like we do for websocket connections
+            if (errorMessage.includes("failed, reason: self signed certificate")) {
+                return new NonRetryableError(errorMessage, R11sErrorType.sslCertError, props);
+            }
+            return new GenericNetworkError(errorMessage, errorMessage.startsWith("NetworkError"), props);
         case 401:
             // The first 401 is manually retried in RouterliciousRestWrapper with a refreshed token,
             // so we treat repeat 401s the same as 403.

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/routerlicious-driver";
-export const pkgVersion = "2.0.0-internal.2.2.1";
+export const pkgVersion = "2.0.0-internal.2.3.0";

package/src/restWrapper.ts

@@ -21,10 +21,11 @@ import type { AxiosRequestConfig, AxiosRequestHeaders } from "axios";
 import safeStringify from "json-stringify-safe";
 import { v4 as uuid } from "uuid";
 import { throwR11sNetworkError } from "./errorUtils";
-import { ITokenProvider } from "./tokens";
+import { ITokenProvider, ITokenResponse } from "./tokens";
 import { pkgVersion as driverVersion } from "./packageVersion";
 
-type AuthorizationHeaderGetter = (refresh?: boolean) => Promise<string | undefined>;
+type AuthorizationHeaderGetter = (token: ITokenResponse) => string;
+type TokenFetcher = (refresh?: boolean) => Promise<ITokenResponse>;
 
 const axiosRequestConfigToFetchRequestConfig = (requestConfig: AxiosRequestConfig): [RequestInfo, RequestInit] => {
     const requestInfo: string = requestConfig.baseURL !== undefined
@@ -41,12 +42,13 @@ const axiosRequestConfigToFetchRequestConfig = (requestConfig: AxiosRequestConfi
 };
 
 export class RouterliciousRestWrapper extends RestWrapper {
-    private authorizationHeader: string | undefined;
     private readonly restLess = new RestLessClient();
 
     constructor(
         logger: ITelemetryLogger,
         private readonly rateLimiter: RateLimiter,
+        private token: ITokenResponse,
+        private readonly fetchRefreshedToken: TokenFetcher,
         private readonly getAuthorizationHeader: AuthorizationHeaderGetter,
         private readonly useRestLess: boolean,
         baseurl?: string,
@@ -55,10 +57,6 @@ export class RouterliciousRestWrapper extends RestWrapper {
         super(baseurl, defaultQueryString);
     }
 
-    public async load() {
-        this.authorizationHeader = await this.getAuthorizationHeader();
-    }
-
     protected async request<T>(requestConfig: AxiosRequestConfig, statusCode: number, canRetry = true): Promise<T> {
         const config = {
             ...requestConfig,
@@ -88,7 +86,7 @@ export class RouterliciousRestWrapper extends RestWrapper {
         // Failure
         if (response.status === 401 && canRetry) {
             // Refresh Authorization header and retry once
-            this.authorizationHeader = await this.getAuthorizationHeader(true /* refreshToken */);
+            this.token = await this.fetchRefreshedToken(true /* refreshToken */);
             return this.request<T>(config, statusCode, false);
         }
         if (response.status === 429 && responseBody?.retryAfter > 0) {
@@ -120,21 +118,31 @@ export class RouterliciousRestWrapper extends RestWrapper {
             "x-correlation-id": correlationId as string,
             "x-driver-version": driverVersion,
             // NOTE: If this.authorizationHeader is undefined, should "Authorization" be removed entirely?
-            "Authorization": this.authorizationHeader!,
+            "Authorization": this.getAuthorizationHeader(this.token),
         };
     }
+
+    public getToken(): ITokenResponse {
+        return this.token;
+    }
+
+    public setToken(token: ITokenResponse) {
+        this.token = token;
+    }
 }
 
 export class RouterliciousStorageRestWrapper extends RouterliciousRestWrapper {
     private constructor(
         logger: ITelemetryLogger,
         rateLimiter: RateLimiter,
+        token: ITokenResponse,
+        fetchToken: TokenFetcher,
         getAuthorizationHeader: AuthorizationHeaderGetter,
         useRestLess: boolean,
         baseurl?: string,
         defaultQueryString: ParsedUrlQueryInput = {},
     ) {
-        super(logger, rateLimiter, getAuthorizationHeader, useRestLess, baseurl, defaultQueryString);
+        super(logger, rateLimiter, token, fetchToken, getAuthorizationHeader, useRestLess, baseurl, defaultQueryString);
     }
 
     public static async load(
@@ -149,7 +157,8 @@ export class RouterliciousStorageRestWrapper extends RouterliciousRestWrapper {
         const defaultQueryString = {
             token: `${fromUtf8ToBase64(tenantId)}`,
         };
-        const getAuthorizationHeader: AuthorizationHeaderGetter = async (refreshToken?: boolean): Promise<string> => {
+
+        const fetchStorageToken = async (refreshToken?: boolean): Promise<ITokenResponse> => {
             return PerformanceEvent.timedExecAsync(
                 logger,
                 {
@@ -163,25 +172,26 @@ export class RouterliciousStorageRestWrapper extends RouterliciousRestWrapper {
                         documentId,
                         refreshToken
                     );
-                    const credentials = {
-                        password: storageToken.jwt,
-                        user: tenantId,
-                    };
-                    return getAuthorizationTokenFromCredentials(credentials);
+
+                    return storageToken;
                 }
             );
         };
 
+        const getAuthorizationHeader: AuthorizationHeaderGetter = (token: ITokenResponse): string => {
+            const credentials = {
+                password: token.jwt,
+                user: tenantId,
+            };
+            return getAuthorizationTokenFromCredentials(credentials);
+        };
+
+        const storagetoken = await fetchStorageToken();
+
         const restWrapper = new RouterliciousStorageRestWrapper(
-            logger, rateLimiter, getAuthorizationHeader, useRestLess, baseurl, defaultQueryString);
-        try {
-            await restWrapper.load();
-        } catch (e) {
-            logger.sendErrorEvent({
-                eventName: "R11sRestWrapperLoadFailure",
-            }, e);
-            await restWrapper.load();
-        }
+            logger, rateLimiter, storagetoken, 
+                fetchStorageToken, getAuthorizationHeader, useRestLess, baseurl, defaultQueryString);
+
         return restWrapper;
     }
 }
@@ -190,12 +200,14 @@ export class RouterliciousOrdererRestWrapper extends RouterliciousRestWrapper {
     private constructor(
         logger: ITelemetryLogger,
         rateLimiter: RateLimiter,
+        token: ITokenResponse,
+        fetchToken: TokenFetcher,
         getAuthorizationHeader: AuthorizationHeaderGetter,
         useRestLess: boolean,
         baseurl?: string,
         defaultQueryString: ParsedUrlQueryInput = {},
     ) {
-        super(logger, rateLimiter, getAuthorizationHeader, useRestLess, baseurl, defaultQueryString);
+        super(logger, rateLimiter, token, fetchToken, getAuthorizationHeader, useRestLess, baseurl, defaultQueryString);
     }
 
     public static async load(
@@ -207,7 +219,11 @@ export class RouterliciousOrdererRestWrapper extends RouterliciousRestWrapper {
         useRestLess: boolean,
         baseurl?: string,
     ): Promise<RouterliciousOrdererRestWrapper> {
-        const getAuthorizationHeader: AuthorizationHeaderGetter = async (refreshToken?: boolean): Promise<string> => {
+        const getAuthorizationHeader: AuthorizationHeaderGetter = (token: ITokenResponse): string => {
+            return `Basic ${token.jwt}`;
+        };
+
+        const fetchOrdererToken = async (refreshToken?: boolean): Promise<ITokenResponse> => {
             return PerformanceEvent.timedExecAsync(
                 logger,
                 {
@@ -220,21 +236,17 @@ export class RouterliciousOrdererRestWrapper extends RouterliciousRestWrapper {
                         documentId,
                         refreshToken,
                     );
-                    return `Basic ${ordererToken.jwt}`;
+
+                    return ordererToken;
                 }
             );
         };
 
+        const newtoken = await fetchOrdererToken();
+
         const restWrapper = new RouterliciousOrdererRestWrapper(
-            logger, rateLimiter, getAuthorizationHeader, useRestLess, baseurl);
-        try {
-            await restWrapper.load();
-        } catch (e) {
-            logger.sendErrorEvent({
-                eventName: "R11sRestWrapperLoadFailure",
-            }, e);
-            await restWrapper.load();
-        }
+            logger, rateLimiter, newtoken, fetchOrdererToken, getAuthorizationHeader, useRestLess, baseurl);
+
         return restWrapper;
     }
 }

package/src/shreddedSummaryDocumentStorageService.ts

@@ -63,7 +63,7 @@ export class ShreddedSummaryDocumentStorageService implements IDocumentStorageSe
         protected readonly id: string,
         protected readonly manager: GitManager,
         protected readonly logger: ITelemetryLogger,
-        public readonly policies: IDocumentStorageServicePolicies = {},
+        public readonly policies: IDocumentStorageServicePolicies,
         driverPolicies?: IRouterliciousDriverPolicies,
         blobCache?: ICache<ArrayBufferLike>,
         snapshotTreeCache?: ICache<ISnapshotTreeVersion>,

package/src/wholeSummaryDocumentStorageService.ts

@@ -53,7 +53,7 @@ export class WholeSummaryDocumentStorageService implements IDocumentStorageServi
         protected readonly id: string,
         protected readonly manager: GitManager,
         protected readonly logger: ITelemetryLogger,
-        public readonly policies: IDocumentStorageServicePolicies = {},
+        public readonly policies: IDocumentStorageServicePolicies,
         private readonly driverPolicies?: IRouterliciousDriverPolicies,
         private readonly blobCache: ICache<ArrayBufferLike> = new InMemoryCache(),
         private readonly snapshotTreeCache: ICache<ISnapshotTreeVersion> = new InMemoryCache(),