@fluidframework/routerlicious-driver 2.0.0-dev.2.3.0.115467 → 2.0.0-dev.3.1.0.125672

package/src/documentDeltaConnection.ts

@@ -17,55 +17,61 @@ const protocolVersions = ["^0.4.0", "^0.3.0", "^0.2.0", "^0.1.0"];
  * Wrapper over the shared one for driver specific translation.
  */
 export class R11sDocumentDeltaConnection extends DocumentDeltaConnection {
-    public static async create(
-        tenantId: string,
-        id: string,
-        token: string | null,
-        io: typeof SocketIOClientStatic,
-        client: IClient,
-        url: string,
-        logger: ITelemetryLogger,
-        timeoutMs = 20000): Promise<IDocumentDeltaConnection> {
-        const socket = io(
-            url,
-            {
-                query: {
-                    documentId: id,
-                    tenantId,
-                },
-                reconnection: false,
-                // Default to websocket connection, with long-polling disabled
-                transports: ["websocket"],
-                timeout: timeoutMs,
-            });
+	public static async create(
+		tenantId: string,
+		id: string,
+		token: string | null,
+		io: typeof SocketIOClientStatic,
+		client: IClient,
+		url: string,
+		logger: ITelemetryLogger,
+		timeoutMs = 20000,
+	): Promise<IDocumentDeltaConnection> {
+		const socket = io(url, {
+			query: {
+				documentId: id,
+				tenantId,
+			},
+			reconnection: false,
+			// Default to websocket connection, with long-polling disabled
+			transports: ["websocket"],
+			timeout: timeoutMs,
+		});
 
-        const connectMessage: IConnect = {
-            client,
-            id,
-            mode: client.mode,
-            tenantId,
-            token,  // Token is going to indicate tenant level information, etc...
-            versions: protocolVersions,
-            relayUserAgent: [client.details.environment, ` driverVersion:${driverVersion}`].join(";"),
-        };
+		const connectMessage: IConnect = {
+			client,
+			id,
+			mode: client.mode,
+			tenantId,
+			token, // Token is going to indicate tenant level information, etc...
+			versions: protocolVersions,
+			relayUserAgent: [client.details.environment, ` driverVersion:${driverVersion}`].join(
+				";",
+			),
+		};
 
-        // TODO: expose to host at factory level
-        const enableLongPollingDowngrades = true;
-        const deltaConnection = new R11sDocumentDeltaConnection(socket, id, logger, enableLongPollingDowngrades);
+		// TODO: expose to host at factory level
+		const enableLongPollingDowngrades = true;
+		const deltaConnection = new R11sDocumentDeltaConnection(
+			socket,
+			id,
+			logger,
+			enableLongPollingDowngrades,
+		);
 
-        await deltaConnection.initialize(connectMessage, timeoutMs);
-        return deltaConnection;
-    }
+		await deltaConnection.initialize(connectMessage, timeoutMs);
+		return deltaConnection;
+	}
 
-    /**
-     * Error raising for socket.io issues
-     */
-    protected createErrorObject(handler: string, error?: any, canRetry = true): IAnyDriverError {
-        // Note: we suspect the incoming error object is either:
-        // - a socketError: add it to the R11sError object for driver to be able to parse it and reason over it.
-        // - anything else: let base class handle it
-        return canRetry && Number.isInteger(error?.code) && typeof error?.message === "string"
-            ? errorObjectFromSocketError(error as IR11sSocketError, handler)
-            : super.createErrorObject(handler, error, canRetry);
-    }
+	/**
+	 * Error raising for socket.io issues
+	 */
+	protected createErrorObject(handler: string, error?: any, canRetry = true): IAnyDriverError {
+		// Note: we suspect the incoming error object is either:
+		// - a socketError: add it to the R11sError object for driver to be able to parse it and reason over it.
+		// - anything else: let base class handle it
+		return canRetry && Number.isInteger(error?.code) && typeof error?.message === "string"
+			? errorObjectFromSocketError(error as IR11sSocketError, handler)
+			: super.createErrorObject(handler, error, canRetry);
+	}
 }

package/src/documentService.ts

@@ -35,262 +35,266 @@ const RediscoverAfterTimeSinceDiscoveryMs = 5 * 60000; // 5 minute
  */
 // eslint-disable-next-line import/namespace
 export class DocumentService implements api.IDocumentService {
-    private lastDiscoveredAt: number = Date.now();
-    private discoverP: Promise<void> | undefined;
+	private lastDiscoveredAt: number = Date.now();
+	private discoverP: Promise<void> | undefined;
 
-    private storageManager: GitManager | undefined;
-    private noCacheStorageManager: GitManager | undefined;
-    private ordererRestWrapper: RestWrapper | undefined;
+	private storageManager: GitManager | undefined;
+	private noCacheStorageManager: GitManager | undefined;
 
-    public get resolvedUrl() {
-        return this._resolvedUrl;
-    }
+	public get resolvedUrl() {
+		return this._resolvedUrl;
+	}
 
-    constructor(
-        private _resolvedUrl: api.IResolvedUrl,
-        protected ordererUrl: string,
-        private deltaStorageUrl: string,
-        private deltaStreamUrl: string,
-        private storageUrl: string,
-        private readonly logger: ITelemetryLogger,
-        protected tokenProvider: ITokenProvider,
-        protected tenantId: string,
-        protected documentId: string,
-        private readonly driverPolicies: IRouterliciousDriverPolicies,
-        private readonly blobCache: ICache<ArrayBufferLike>,
-        private readonly snapshotTreeCache: ICache<ISnapshotTreeVersion>,
-        private readonly discoverFluidResolvedUrl: () => Promise<api.IFluidResolvedUrl>,
-    ) {
-    }
+	constructor(
+		private _resolvedUrl: api.IResolvedUrl,
+		protected ordererUrl: string,
+		private deltaStorageUrl: string,
+		private deltaStreamUrl: string,
+		private storageUrl: string,
+		private readonly logger: ITelemetryLogger,
+		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>,
+		private readonly discoverFluidResolvedUrl: () => Promise<api.IFluidResolvedUrl>,
+	) {}
 
-    private documentStorageService: DocumentStorageService | undefined;
+	private documentStorageService: DocumentStorageService | undefined;
 
-    public dispose() { }
+	public dispose() {}
 
-    /**
-     * Connects to a storage endpoint for snapshot service.
-     *
-     * @returns returns the document storage service for routerlicious driver.
-     */
-    public async connectToStorage(): Promise<api.IDocumentStorageService> {
-        if (this.documentStorageService !== undefined) {
-            return this.documentStorageService;
-        }
+	/**
+	 * Connects to a storage endpoint for snapshot service.
+	 *
+	 * @returns returns the document storage service for routerlicious driver.
+	 */
+	public async connectToStorage(): Promise<api.IDocumentStorageService> {
+		if (this.documentStorageService !== undefined) {
+			return this.documentStorageService;
+		}
 
-        if (this.storageUrl === undefined) {
-            return new NullBlobStorageService();
-        }
+		if (this.storageUrl === undefined) {
+			return new NullBlobStorageService();
+		}
 
-        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);
-            }
+		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
-                : api.LoaderCachingPolicy.NoCaching,
-            minBlobSize: this.driverPolicies.aggregateBlobsSmallerThanBytes,
-        };
+			return disableCache ? this.noCacheStorageManager : this.storageManager;
+		};
+		// Initialize storageManager and noCacheStorageManager
+		const storageManager = await getStorageManager();
+		const noCacheStorageManager = await getStorageManager(true);
+		this.documentStorageService = new DocumentStorageService(
+			this.documentId,
+			storageManager,
+			this.logger,
+			this.documentStorageServicePolicies,
+			this.driverPolicies,
+			this.blobCache,
+			this.snapshotTreeCache,
+			noCacheStorageManager,
+			getStorageManager,
+		);
+		return this.documentStorageService;
+	}
 
-        this.documentStorageService = new DocumentStorageService(
-            this.documentId,
-            storageManager,
-            this.logger,
-            documentStorageServicePolicies,
-            this.driverPolicies,
-            this.blobCache,
-            this.snapshotTreeCache,
-            noCacheStorageManager,
-            getStorageManager);
-        return this.documentStorageService;
-    }
+	/**
+	 * Connects to a delta storage endpoint for getting ops between a range.
+	 *
+	 * @returns returns the document delta storage service for routerlicious driver.
+	 */
+	public async connectToDeltaStorage(): Promise<api.IDocumentDeltaStorageService> {
+		await this.connectToStorage();
+		assert(!!this.documentStorageService, 0x0b1 /* "Storage service not initialized" */);
 
-    /**
-     * Connects to a delta storage endpoint for getting ops between a range.
-     *
-     * @returns returns the document delta storage service for routerlicious driver.
-     */
-    public async connectToDeltaStorage(): Promise<api.IDocumentDeltaStorageService> {
-        await this.connectToStorage();
-        assert(!!this.documentStorageService, 0x0b1 /* "Storage service not initialized" */);
+		const getRestWrapper = async (): Promise<RestWrapper> => {
+			const shouldUpdateDiscoveredSessionInfo = this.shouldUpdateDiscoveredSessionInfo();
 
-        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,
-            deltaStorageService,
-            this.documentStorageService,
-            this.logger,
-        );
-    }
+			if (shouldUpdateDiscoveredSessionInfo) {
+				await this.refreshDiscovery();
+				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,
+			deltaStorageService,
+			this.documentStorageService,
+			this.logger,
+		);
+	}
 
-    /**
-     * Connects to a delta stream endpoint for emitting ops.
-     *
-     * @returns returns the document delta stream service for routerlicious driver.
-     */
-    public async connectToDeltaStream(client: IClient): Promise<api.IDocumentDeltaConnection> {
-        const connect = async (refreshToken?: boolean) => {
-            if (this.shouldUpdateDiscoveredSessionInfo()) {
-                await this.refreshDiscovery();
-            }
+	/**
+	 * Connects to a delta stream endpoint for emitting ops.
+	 *
+	 * @returns returns the document delta stream service for routerlicious driver.
+	 */
+	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,
-                {
-                    eventName: "ConnectToDeltaStream",
-                    docId: this.documentId,
-                },
-                async () => {
-                    return R11sDocumentDeltaConnection.create(
-                        this.tenantId,
-                        this.documentId,
-                        ordererToken.jwt,
-                        io,
-                        client,
-                        this.deltaStreamUrl,
-                        this.logger,
-                    );
-                }
-            );
-        };
+			return PerformanceEvent.timedExecAsync(
+				this.logger,
+				{
+					eventName: "ConnectToDeltaStream",
+					docId: this.documentId,
+				},
+				async () => {
+					return R11sDocumentDeltaConnection.create(
+						this.tenantId,
+						this.documentId,
+						ordererToken.jwt,
+						io,
+						client,
+						this.deltaStreamUrl,
+						this.logger,
+					);
+				},
+			);
+		};
 
-        // Attempt to establish connection.
-        // Retry with new token on authorization error; otherwise, allow container layer to handle.
-        try {
-            const connection = await connect();
-            return connection;
-        } 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 */);
-            }
-            throw error;
-        }
-    }
+		// Attempt to establish connection.
+		// Retry with new token on authorization error; otherwise, allow container layer to handle.
+		try {
+			const connection = await connect();
+			return connection;
+		} 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 */);
+			}
+			throw error;
+		}
+	}
 
-    /**
-     * Re-discover session URLs if necessary.
-     */
-    private async refreshDiscovery(): Promise<void> {
-        if (!this.discoverP) {
-            this.discoverP = PerformanceEvent.timedExecAsync(
-                this.logger,
-                {
-                    eventName: "RefreshDiscovery",
-                },
-                async () => this.refreshDiscoveryCore(),
-            );
-        }
-        return this.discoverP;
-    }
+	/**
+	 * Re-discover session URLs if necessary.
+	 */
+	private async refreshDiscovery(): Promise<void> {
+		if (!this.discoverP) {
+			this.discoverP = PerformanceEvent.timedExecAsync(
+				this.logger,
+				{
+					eventName: "RefreshDiscovery",
+				},
+				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.deltaStreamUrl = fluidResolvedUrl.endpoints.deltaStreamUrl || this.ordererUrl;
-    }
+	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.deltaStreamUrl = fluidResolvedUrl.endpoints.deltaStreamUrl || this.ordererUrl;
+	}
 
-    /**
-     * 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;
-        if (pastLastDiscoveryTimeThreshold) {
-            // Reset discover promise and refresh discovery.
-            this.lastDiscoveredAt = Date.now();
-            this.discoverP = undefined;
-            this.refreshDiscovery().catch(() => {
-                // Undo discovery time set on failure, so that next check refreshes.
-                this.lastDiscoveredAt = 0;
-            });
-        }
-        return pastLastDiscoveryTimeThreshold;
-    }
+	/**
+	 * 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;
+		if (pastLastDiscoveryTimeThreshold) {
+			// Reset discover promise and refresh discovery.
+			this.lastDiscoveredAt = Date.now();
+			this.discoverP = undefined;
+			this.refreshDiscovery().catch(() => {
+				// Undo discovery time set on failure, so that next check refreshes.
+				this.lastDiscoveredAt = 0;
+			});
+		}
+		return pastLastDiscoveryTimeThreshold;
+	}
 }