@fluidframework/odsp-driver 0.58.0-55561 → 0.58.1001

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluidframework/odsp-driver",
-  "version": "0.58.0-55561",
+  "version": "0.58.1001",
   "description": "Socket storage implementation for SPO and ODC",
   "homepage": "https://fluidframework.com",
   "repository": "https://github.com/microsoft/FluidFramework",
@@ -58,15 +58,15 @@
     "@fluidframework/common-definitions": "^0.20.1",
     "@fluidframework/common-utils": "^0.32.1",
     "@fluidframework/core-interfaces": "^0.42.0",
-    "@fluidframework/driver-base": "0.58.0-55561",
-    "@fluidframework/driver-definitions": "^0.45.0-0",
-    "@fluidframework/driver-utils": "0.58.0-55561",
-    "@fluidframework/gitresources": "^0.1034.0",
-    "@fluidframework/odsp-doclib-utils": "0.58.0-55561",
-    "@fluidframework/odsp-driver-definitions": "0.58.0-55561",
-    "@fluidframework/protocol-base": "^0.1034.0",
-    "@fluidframework/protocol-definitions": "^0.1026.0",
-    "@fluidframework/telemetry-utils": "0.58.0-55561",
+    "@fluidframework/driver-base": "^0.58.1001",
+    "@fluidframework/driver-definitions": "^0.45.1000",
+    "@fluidframework/driver-utils": "^0.58.1001",
+    "@fluidframework/gitresources": "^0.1035.1000",
+    "@fluidframework/odsp-doclib-utils": "^0.58.1001",
+    "@fluidframework/odsp-driver-definitions": "^0.58.1001",
+    "@fluidframework/protocol-base": "^0.1035.1000",
+    "@fluidframework/protocol-definitions": "^0.1027.1000",
+    "@fluidframework/telemetry-utils": "^0.58.1001",
     "abort-controller": "^3.0.0",
     "node-fetch": "^2.6.1",
     "socket.io-client": "^4.4.1",
@@ -74,8 +74,8 @@
   },
   "devDependencies": {
     "@fluidframework/build-common": "^0.23.0",
-    "@fluidframework/eslint-config-fluid": "^0.26.0-0",
-    "@fluidframework/mocha-test-setup": "0.58.0-55561",
+    "@fluidframework/eslint-config-fluid": "^0.26.0",
+    "@fluidframework/mocha-test-setup": "^0.58.1001",
     "@microsoft/api-extractor": "^7.16.1",
     "@rushstack/eslint-config": "^2.5.1",
     "@types/mocha": "^8.2.2",

package/src/contracts.ts

@@ -34,6 +34,11 @@ export interface ISocketStorageDiscovery {
      * passed as a parameter to `OdspDocumentService.create()` factory.
      */
     socketToken?: string;
+
+    /**
+     * This is the time within which client has to refresh the session on (ODSP) relay service.
+     */
+    refreshSessionDurationSeconds?: number;
 }
 
 /**

package/src/odspCache.ts

@@ -113,9 +113,8 @@ export class PromiseCacheWithOneHourSlidingExpiry<T> extends PromiseCache<string
 export interface INonPersistentCache {
     /**
      * Cache of joined/joining session info
-     * This cache will use a one hour sliding expiration window.
      */
-    readonly sessionJoinCache: PromiseCacheWithOneHourSlidingExpiry<ISocketStorageDiscovery>;
+    readonly sessionJoinCache: PromiseCache<string, {entryTime: number, joinSessionResponse: ISocketStorageDiscovery}>;
 
     /**
      * Cache of resolved/resolving file URLs
@@ -134,7 +133,8 @@ export interface IOdspCache extends INonPersistentCache {
 }
 
 export class NonPersistentCache implements INonPersistentCache {
-    public readonly sessionJoinCache = new PromiseCacheWithOneHourSlidingExpiry<ISocketStorageDiscovery>();
+    public readonly sessionJoinCache =
+        new PromiseCache<string, {entryTime: number, joinSessionResponse: ISocketStorageDiscovery}>();
 
     public readonly fileUrlCache = new PromiseCache<string, IOdspResolvedUrl>();
 }

package/src/odspDocumentService.ts

@@ -52,7 +52,8 @@ import { pkgVersion as driverVersion } from "./packageVersion";
  */
 export class OdspDocumentService implements IDocumentService {
     private _policies: IDocumentServicePolicies;
-
+    // Timer which runs and executes the join session call after intervals.
+    private joinSessionRefreshTimer: ReturnType<typeof setTimeout> | undefined;
     /**
      * @param resolvedUrl - resolved url identifying document that will be managed by returned service instance.
      * @param getStorageToken - function that can provide the storage token. This is is also referred to as
@@ -237,27 +238,7 @@ export class OdspDocumentService implements IDocumentService {
                 ? Promise.resolve(null)
                 : this.getWebsocketToken!(options);
 
-            const joinSessionPromise = this.joinSession(requestWebsocketTokenFromJoinSession, options).catch((e) => {
-                const likelyFacetCodes = e as IFacetCodes;
-                if (Array.isArray(likelyFacetCodes.facetCodes)) {
-                    for (const code of likelyFacetCodes.facetCodes) {
-                        switch (code) {
-                            case "sessionForbiddenOnPreservedFiles":
-                            case "sessionForbiddenOnModerationEnabledLibrary":
-                            case "sessionForbiddenOnRequireCheckout":
-                                // This document can only be opened in storage-only mode.
-                                // DeltaManager will recognize this error
-                                // and load without a delta stream connection.
-                                this._policies = {...this._policies,storageOnly: true};
-                                throw new DeltaStreamConnectionForbiddenError(code, { driverVersion });
-                            default:
-                                continue;
-                        }
-                    }
-                }
-                throw e;
-            });
-
+            const joinSessionPromise = this.joinSession(requestWebsocketTokenFromJoinSession, options);
             const [websocketEndpoint, websocketToken, io] =
                 await Promise.all([
                     joinSessionPromise,
@@ -286,6 +267,8 @@ export class OdspDocumentService implements IDocumentService {
                 // On disconnect with 401/403 error code, we can just clear the joinSession cache as we will again
                 // get the auth error on reconnecting and face latency.
                 connection.on("disconnect", (error: any) => {
+                    // Clear the join session refresh timer so that it can be restarted on reconnection.
+                    this.clearJoinSessionTimer();
                     if (typeof error === "object" && error !== null
                         && error.errorType === DriverErrorType.authorizationError) {
                         this.cache.sessionJoinCache.remove(this.joinSessionKey);
@@ -303,12 +286,59 @@ export class OdspDocumentService implements IDocumentService {
         });
     }
 
+    private clearJoinSessionTimer() {
+        if (this.joinSessionRefreshTimer !== undefined) {
+            clearTimeout(this.joinSessionRefreshTimer);
+            this.joinSessionRefreshTimer = undefined;
+        }
+    }
+
+    private async scheduleJoinSessionRefresh(delta: number) {
+        await new Promise<void>((resolve, reject) => {
+            this.joinSessionRefreshTimer = setTimeout(() => {
+                getWithRetryForTokenRefresh(async (options) => {
+                    await this.joinSession(false, options);
+                    resolve();
+                }).catch((error) => {
+                    reject(error);
+                });
+            }, delta);
+        });
+    }
+
     private async joinSession(
         requestSocketToken: boolean,
         options: TokenFetchOptionsEx,
+    ) {
+        return this.joinSessionCore(requestSocketToken, options).catch((e) => {
+            const likelyFacetCodes = e as IFacetCodes;
+            if (Array.isArray(likelyFacetCodes.facetCodes)) {
+                for (const code of likelyFacetCodes.facetCodes) {
+                    switch (code) {
+                        case "sessionForbiddenOnPreservedFiles":
+                        case "sessionForbiddenOnModerationEnabledLibrary":
+                        case "sessionForbiddenOnRequireCheckout":
+                            // This document can only be opened in storage-only mode.
+                            // DeltaManager will recognize this error
+                            // and load without a delta stream connection.
+                            this._policies = {...this._policies,storageOnly: true};
+                            throw new DeltaStreamConnectionForbiddenError(code, { driverVersion });
+                        default:
+                            continue;
+                    }
+                }
+            }
+            throw e;
+        });
+    }
+
+    private async joinSessionCore(
+        requestSocketToken: boolean,
+        options: TokenFetchOptionsEx,
     ): Promise<ISocketStorageDiscovery> {
-        const executeFetch = async () =>
-            fetchJoinSession(
+        const disableJoinSessionRefresh = this.mc.config.getBoolean("Fluid.Driver.Odsp.disableJoinSessionRefresh");
+        const executeFetch = async () => {
+            const joinSessionResponse = await fetchJoinSession(
                 this.odspResolvedUrl,
                 "opStream/joinSession",
                 "POST",
@@ -317,12 +347,65 @@ export class OdspDocumentService implements IDocumentService {
                 this.epochTracker,
                 requestSocketToken,
                 options,
+                disableJoinSessionRefresh,
                 this.hostPolicy.sessionOptions?.unauthenticatedUserDisplayName,
             );
+            return {
+                entryTime: Date.now(),
+                joinSessionResponse,
+            };
+        };
+
+        const getResponseAndRefreshAfterDeltaMs = async () => {
+            let response = await this.cache.sessionJoinCache.addOrGet(this.joinSessionKey, executeFetch);
+            // If the response does not contain refreshSessionDurationSeconds, then treat it as old flow and let the
+            // cache entry to be treated as expired after 1 hour.
+            response.joinSessionResponse.refreshSessionDurationSeconds =
+                response.joinSessionResponse.refreshSessionDurationSeconds ?? 3600;
+            return {
+                ...response,
+                refreshAfterDeltaMs: this.calculateJoinSessionRefreshDelta(
+                    response.entryTime, response.joinSessionResponse.refreshSessionDurationSeconds),
+            }
+        };
+        let response = await getResponseAndRefreshAfterDeltaMs();
+        // This means that the cached entry has expired(This should not be possible if the response is fetched
+        // from the network call). In this case we remove the cached entry and fetch the new response.
+        if (response.refreshAfterDeltaMs <= 0) {
+            this.cache.sessionJoinCache.remove(this.joinSessionKey);
+            response = await getResponseAndRefreshAfterDeltaMs();
+        }
+        if (!disableJoinSessionRefresh) {
+            const props = {
+                entryTime: response.entryTime,
+                refreshSessionDurationSeconds:
+                    response.joinSessionResponse.refreshSessionDurationSeconds,
+                refreshAfterDeltaMs: response.refreshAfterDeltaMs,
+            };
+            if (response.refreshAfterDeltaMs > 0) {
+                this.scheduleJoinSessionRefresh(response.refreshAfterDeltaMs)
+                    .catch((error) => {
+                        this.mc.logger.sendErrorEvent({
+                                eventName: "JoinSessionRefreshError",
+                                ...props,
+                            },
+                            error,
+                        )
+                    });;
+            } else {
+                // Logging just for informational purposes to help with debugging as this is a new feature.
+                this.mc.logger.sendErrorEvent({
+                    eventName: "JoinSessionRefreshNotScheduled",
+                    ...props,
+                });
+            }
+        }
+        return response.joinSessionResponse;
+    }
 
-        // Note: The sessionCache is configured with a sliding expiry of 1 hour,
-        // so if we've fetched the join session within the last hour we won't run executeFetch again now.
-        return this.cache.sessionJoinCache.addOrGet(this.joinSessionKey, executeFetch);
+    private calculateJoinSessionRefreshDelta(responseFetchTime: number, refreshSessionDurationSeconds: number) {
+        // 30 seconds is buffer time to refresh the session.
+        return responseFetchTime + ((refreshSessionDurationSeconds * 1000) - 30000) - Date.now();
     }
 
     /**

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/odsp-driver";
-export const pkgVersion = "0.58.0-55561";
+export const pkgVersion = "0.58.1001";

package/src/vroom.ts

@@ -29,6 +29,7 @@ interface IJoinSessionBody {
  * @param requestSocketToken - flag indicating whether joinSession is expected to return access token
  * which is used when establishing websocket connection with collab session backend service.
  * @param options - Options to fetch the token.
+ * @param disableJoinSessionRefresh - Whether the caller wants to disable refreshing join session periodically.
  * @param guestDisplayName - display name used to identify guest user joining a session.
  * This is optional and used only when collab session is being joined via invite.
  */
@@ -41,6 +42,7 @@ export async function fetchJoinSession(
     epochTracker: EpochTracker,
     requestSocketToken: boolean,
     options: TokenFetchOptionsEx,
+    disableJoinSessionRefresh: boolean | undefined,
     guestDisplayName?: string,
 ): Promise<ISocketStorageDiscovery> {
     const token = await getStorageToken(options, "JoinSession");
@@ -61,6 +63,9 @@ export async function fetchJoinSession(
             postBody += `Authorization: Bearer ${token}\r\n`;
             postBody += `X-HTTP-Method-Override: POST\r\n`;
             postBody += `Content-Type: application/json\r\n`;
+            if (!disableJoinSessionRefresh) {
+                postBody += `prefer: FluidRemoveCheckAccess\r\n`;
+            }
             postBody += `_post: 1\r\n`;
             // Name should be there when socket token is requested and vice-versa.
             if (requestSocketToken && guestDisplayName !== undefined) {
@@ -98,6 +103,7 @@ export async function fetchJoinSession(
                 // pushV2 websocket urls will contain pushf
                 pushv2: socketUrl.includes("pushf"),
                 webSocketHostName,
+                refreshSessionDurationSeconds: response.content.refreshSessionDurationSeconds,
             });
 
             if (response.content.runtimeTenantId && !response.content.tenantId) {