@fluidframework/file-driver 2.0.0-internal.3.0.5 → 2.0.0-internal.3.1.1

package/src/fileDocumentDeltaConnection.ts

@@ -4,17 +4,20 @@
  */
 
 import { IDisposable } from "@fluidframework/common-definitions";
-import { IDocumentDeltaConnection, IDocumentDeltaConnectionEvents } from "@fluidframework/driver-definitions";
 import {
-    ConnectionMode,
-    IClientConfiguration,
-    IConnected,
-    IDocumentMessage,
-    ISequencedDocumentMessage,
-    ISignalClient,
-    ISignalMessage,
-    ITokenClaims,
-    ScopeType,
+	IDocumentDeltaConnection,
+	IDocumentDeltaConnectionEvents,
+} from "@fluidframework/driver-definitions";
+import {
+	ConnectionMode,
+	IClientConfiguration,
+	IConnected,
+	IDocumentMessage,
+	ISequencedDocumentMessage,
+	ISignalClient,
+	ISignalMessage,
+	ITokenClaims,
+	ScopeType,
 } from "@fluidframework/protocol-definitions";
 import { TypedEventEmitter } from "@fluidframework/common-utils";
 import { FileDeltaStorageService } from "./fileDeltaStorageService";
@@ -29,174 +32,186 @@ const fileProtocolVersion = "^0.1.0";
 const replayDocumentId = "replayDocId";
 
 const Claims: ITokenClaims = {
-    documentId: replayDocumentId,
-    scopes: [ScopeType.DocRead],
-    tenantId: "",
-    user: {
-        id: "",
-    },
-    iat: Math.round(new Date().getTime() / 1000),
-    exp: Math.round(new Date().getTime() / 1000) + 60 * 60, // 1 hour expiration
-    ver: "1.0",
+	documentId: replayDocumentId,
+	scopes: [ScopeType.DocRead],
+	tenantId: "",
+	user: {
+		id: "",
+	},
+	iat: Math.round(new Date().getTime() / 1000),
+	exp: Math.round(new Date().getTime() / 1000) + 60 * 60, // 1 hour expiration
+	ver: "1.0",
 };
 
 /**
  * Replay service used to play ops using the delta connection.
  */
 export class Replayer {
-    private currentReplayOp = 0;
-
-    constructor(
-        private readonly deltaConnection: ReplayFileDeltaConnection,
-        private readonly documentStorageService: FileDeltaStorageService) {
-    }
-
-    public get currentReplayedOp() {
-        return this.currentReplayOp;
-    }
-
-    public set currentReplayedOp(op: number) {
-        this.currentReplayOp = op;
-    }
-
-    public get ops(): readonly Readonly<ISequencedDocumentMessage>[] {
-        return this.documentStorageService.ops;
-    }
-
-    /**
-     * Replay the ops upto a certain number.
-     * @param replayTo - The last op number to be replayed.
-     */
-    public replay(replayTo: number) {
-        let totalReplayedOps = 0;
-        let done: boolean;
-        do {
-            const fetchToBatch = this.currentReplayOp + MaxBatchDeltas;
-            const fetchTo = Math.min(fetchToBatch, replayTo);
-
-            const fetchedOps = this.documentStorageService.getFromWebSocket(this.currentReplayOp, fetchTo);
-
-            if (fetchedOps.length <= 0) {
-                break;
-            } else {
-                this.emit(fetchedOps);
-                totalReplayedOps += fetchedOps.length;
-                this.currentReplayOp += fetchedOps.length;
-                done = this.isDoneFetch(replayTo);
-            }
-        } while (!done);
-        return totalReplayedOps;
-    }
-
-    private isDoneFetch(replayTo: number) {
-        if (replayTo >= 0) {
-            return this.currentReplayOp >= replayTo;
-        }
-        return false;
-    }
-
-    private emit(ops: ISequencedDocumentMessage[]) {
-        // Note: do not clone messages here!
-        // If Replay Tool fails due to one container patching message in-place,
-        // then same thing can happen in shipping product due to
-        // socket reuse in ODSP between main and summarizer containers.
-        this.deltaConnection.emit("op", replayDocumentId, ops);
-    }
+	private currentReplayOp = 0;
+
+	constructor(
+		private readonly deltaConnection: ReplayFileDeltaConnection,
+		private readonly documentStorageService: FileDeltaStorageService,
+	) {}
+
+	public get currentReplayedOp() {
+		return this.currentReplayOp;
+	}
+
+	public set currentReplayedOp(op: number) {
+		this.currentReplayOp = op;
+	}
+
+	public get ops(): readonly Readonly<ISequencedDocumentMessage>[] {
+		return this.documentStorageService.ops;
+	}
+
+	/**
+	 * Replay the ops upto a certain number.
+	 * @param replayTo - The last op number to be replayed.
+	 */
+	public replay(replayTo: number) {
+		let totalReplayedOps = 0;
+		let done: boolean;
+		do {
+			const fetchToBatch = this.currentReplayOp + MaxBatchDeltas;
+			const fetchTo = Math.min(fetchToBatch, replayTo);
+
+			const fetchedOps = this.documentStorageService.getFromWebSocket(
+				this.currentReplayOp,
+				fetchTo,
+			);
+
+			if (fetchedOps.length <= 0) {
+				break;
+			} else {
+				this.emit(fetchedOps);
+				totalReplayedOps += fetchedOps.length;
+				this.currentReplayOp += fetchedOps.length;
+				done = this.isDoneFetch(replayTo);
+			}
+		} while (!done);
+		return totalReplayedOps;
+	}
+
+	private isDoneFetch(replayTo: number) {
+		if (replayTo >= 0) {
+			return this.currentReplayOp >= replayTo;
+		}
+		return false;
+	}
+
+	private emit(ops: ISequencedDocumentMessage[]) {
+		// Note: do not clone messages here!
+		// If Replay Tool fails due to one container patching message in-place,
+		// then same thing can happen in shipping product due to
+		// socket reuse in ODSP between main and summarizer containers.
+		this.deltaConnection.emit("op", replayDocumentId, ops);
+	}
 }
 
 export class ReplayFileDeltaConnection
-    extends TypedEventEmitter<IDocumentDeltaConnectionEvents>
-    implements IDocumentDeltaConnection, IDisposable {
-    /**
-     * Mimic the delta connection to replay ops on it.
-     *
-     * @param documentDeltaStorageService - The delta storage service to get ops from.
-     * @returns Document delta connection.
-     */
-    public static async create(
-        documentDeltaStorageService: FileDeltaStorageService): Promise<ReplayFileDeltaConnection> {
-        const mode: ConnectionMode = "read";
-        const connection = {
-            claims: Claims,
-            clientId: "PseudoClientId",
-            existing: true,
-            initialMessages: [],
-            initialSignals: [],
-            initialClients: [],
-            maxMessageSize: ReplayMaxMessageSize,
-            mode,
-            serviceConfiguration: {
-                blockSize: 64436,
-                maxMessageSize: ReplayMaxMessageSize,
-            },
-            supportedVersions: [fileProtocolVersion],
-            user: null,
-            version: fileProtocolVersion,
-        };
-        const deltaConnection = new ReplayFileDeltaConnection(connection, documentDeltaStorageService);
-        return deltaConnection;
-    }
-
-    public readonly maxMessageSize = ReplayMaxMessageSize;
-    private readonly replayer: Replayer;
-
-    public constructor(public details: IConnected, documentDeltaStorageService: FileDeltaStorageService) {
-        super();
-        this.replayer = new Replayer(
-            this,
-            documentDeltaStorageService);
-    }
-
-    public getReplayer() {
-        return this.replayer;
-    }
-
-    public get clientId(): string {
-        return this.details.clientId;
-    }
-
-    public get mode(): ConnectionMode {
-        return this.details.mode;
-    }
-
-    public get claims(): ITokenClaims {
-        return this.details.claims;
-    }
-
-    public get existing(): boolean {
-        return this.details.existing;
-    }
-
-    public get version(): string {
-        return this.details.version;
-    }
-
-    public get initialMessages(): ISequencedDocumentMessage[] {
-        return this.details.initialMessages;
-    }
-
-    public get initialSignals(): ISignalMessage[] {
-        return this.details.initialSignals;
-    }
-
-    public get initialClients(): ISignalClient[] {
-        return this.details.initialClients;
-    }
-
-    public get serviceConfiguration(): IClientConfiguration {
-        return this.details.serviceConfiguration;
-    }
-
-    public submit(documentMessages: IDocumentMessage[]): void {
-        // ReplayFileDeltaConnection.submit() can't be called - client never sees its own join on,
-        // and thus can never move to sending ops.
-        throw new Error("ReplayFileDeltaConnection.submit() can't be called");
-    }
-
-    public async submitSignal(message: any) {
-    }
-
-    private _disposed = false;
-    public get disposed() { return this._disposed; }
-    public dispose() { this._disposed = true; }
+	extends TypedEventEmitter<IDocumentDeltaConnectionEvents>
+	implements IDocumentDeltaConnection, IDisposable
+{
+	/**
+	 * Mimic the delta connection to replay ops on it.
+	 *
+	 * @param documentDeltaStorageService - The delta storage service to get ops from.
+	 * @returns Document delta connection.
+	 */
+	public static async create(
+		documentDeltaStorageService: FileDeltaStorageService,
+	): Promise<ReplayFileDeltaConnection> {
+		const mode: ConnectionMode = "read";
+		const connection = {
+			claims: Claims,
+			clientId: "PseudoClientId",
+			existing: true,
+			initialMessages: [],
+			initialSignals: [],
+			initialClients: [],
+			maxMessageSize: ReplayMaxMessageSize,
+			mode,
+			serviceConfiguration: {
+				blockSize: 64436,
+				maxMessageSize: ReplayMaxMessageSize,
+			},
+			supportedVersions: [fileProtocolVersion],
+			user: null,
+			version: fileProtocolVersion,
+		};
+		const deltaConnection = new ReplayFileDeltaConnection(
+			connection,
+			documentDeltaStorageService,
+		);
+		return deltaConnection;
+	}
+
+	public readonly maxMessageSize = ReplayMaxMessageSize;
+	private readonly replayer: Replayer;
+
+	public constructor(
+		public details: IConnected,
+		documentDeltaStorageService: FileDeltaStorageService,
+	) {
+		super();
+		this.replayer = new Replayer(this, documentDeltaStorageService);
+	}
+
+	public getReplayer() {
+		return this.replayer;
+	}
+
+	public get clientId(): string {
+		return this.details.clientId;
+	}
+
+	public get mode(): ConnectionMode {
+		return this.details.mode;
+	}
+
+	public get claims(): ITokenClaims {
+		return this.details.claims;
+	}
+
+	public get existing(): boolean {
+		return this.details.existing;
+	}
+
+	public get version(): string {
+		return this.details.version;
+	}
+
+	public get initialMessages(): ISequencedDocumentMessage[] {
+		return this.details.initialMessages;
+	}
+
+	public get initialSignals(): ISignalMessage[] {
+		return this.details.initialSignals;
+	}
+
+	public get initialClients(): ISignalClient[] {
+		return this.details.initialClients;
+	}
+
+	public get serviceConfiguration(): IClientConfiguration {
+		return this.details.serviceConfiguration;
+	}
+
+	public submit(documentMessages: IDocumentMessage[]): void {
+		// ReplayFileDeltaConnection.submit() can't be called - client never sees its own join on,
+		// and thus can never move to sending ops.
+		throw new Error("ReplayFileDeltaConnection.submit() can't be called");
+	}
+
+	public async submitSignal(message: any) {}
+
+	private _disposed = false;
+	public get disposed() {
+		return this._disposed;
+	}
+	public dispose() {
+		this._disposed = true;
+	}
 }

package/src/fileDocumentService.ts

@@ -13,36 +13,35 @@ import { FileDeltaStorageService } from "./fileDeltaStorageService";
  */
 // eslint-disable-next-line import/namespace
 export class FileDocumentService implements api.IDocumentService {
-    constructor(
-        private readonly storage: api.IDocumentStorageService,
-        private readonly deltaStorage: FileDeltaStorageService,
-        private readonly deltaConnection: api.IDocumentDeltaConnection) {
-    }
+	constructor(
+		private readonly storage: api.IDocumentStorageService,
+		private readonly deltaStorage: FileDeltaStorageService,
+		private readonly deltaConnection: api.IDocumentDeltaConnection,
+	) {}
 
-    public dispose() {}
+	public dispose() {}
 
-    // TODO: Issue-2109 Implement detach container api or put appropriate comment.
-    public get resolvedUrl(): api.IResolvedUrl {
-        throw new Error("Not implemented");
-    }
+	// TODO: Issue-2109 Implement detach container api or put appropriate comment.
+	public get resolvedUrl(): api.IResolvedUrl {
+		throw new Error("Not implemented");
+	}
 
-    public async connectToStorage(): Promise<api.IDocumentStorageService> {
-        return this.storage;
-    }
+	public async connectToStorage(): Promise<api.IDocumentStorageService> {
+		return this.storage;
+	}
 
-    public async connectToDeltaStorage(): Promise<api.IDocumentDeltaStorageService> {
-        return this.deltaStorage;
-    }
+	public async connectToDeltaStorage(): Promise<api.IDocumentDeltaStorageService> {
+		return this.deltaStorage;
+	}
 
-    /**
-     * Connects to a delta storage endpoint of provided documentService to get ops and then replaying
-     * them so as to mimic a delta stream endpoint.
-     *
-     * @param client - Client that connects to socket.
-     * @returns returns the delta stream service.
-     */
-    public async connectToDeltaStream(
-        client: IClient): Promise<api.IDocumentDeltaConnection> {
-        return this.deltaConnection;
-    }
+	/**
+	 * Connects to a delta storage endpoint of provided documentService to get ops and then replaying
+	 * them so as to mimic a delta stream endpoint.
+	 *
+	 * @param client - Client that connects to socket.
+	 * @returns returns the delta stream service.
+	 */
+	public async connectToDeltaStream(client: IClient): Promise<api.IDocumentDeltaConnection> {
+		return this.deltaConnection;
+	}
 }

package/src/fileDocumentServiceFactory.ts

@@ -4,11 +4,11 @@
  */
 
 import {
-    IDocumentDeltaConnection,
-    IDocumentService,
-    IDocumentServiceFactory,
-    IDocumentStorageService,
-    IResolvedUrl,
+	IDocumentDeltaConnection,
+	IDocumentService,
+	IDocumentServiceFactory,
+	IDocumentStorageService,
+	IResolvedUrl,
 } from "@fluidframework/driver-definitions";
 import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
 import { ISummaryTree } from "@fluidframework/protocol-definitions";
@@ -20,34 +20,34 @@ import { FileDocumentService } from "./fileDocumentService";
  * use the local file storage as underlying storage.
  */
 export class FileDocumentServiceFactory implements IDocumentServiceFactory {
-    public readonly protocolName = "fluid-file:";
-    constructor(
-        private readonly storage: IDocumentStorageService,
-        private readonly deltaStorage: FileDeltaStorageService,
-        private readonly deltaConnection: IDocumentDeltaConnection) {
-    }
+	public readonly protocolName = "fluid-file:";
+	constructor(
+		private readonly storage: IDocumentStorageService,
+		private readonly deltaStorage: FileDeltaStorageService,
+		private readonly deltaConnection: IDocumentDeltaConnection,
+	) {}
 
-    /**
-     * Creates the file document service if the path exists.
-     *
-     * @param fileURL - Path of directory containing ops/snapshots.
-     * @returns file document service.
-     */
-    public async createDocumentService(
-        fileURL: IResolvedUrl,
-        logger?: ITelemetryBaseLogger,
-        clientIsSummarizer?: boolean,
-    ): Promise<IDocumentService> {
-        return new FileDocumentService(this.storage, this.deltaStorage, this.deltaConnection);
-    }
+	/**
+	 * Creates the file document service if the path exists.
+	 *
+	 * @param fileURL - Path of directory containing ops/snapshots.
+	 * @returns file document service.
+	 */
+	public async createDocumentService(
+		fileURL: IResolvedUrl,
+		logger?: ITelemetryBaseLogger,
+		clientIsSummarizer?: boolean,
+	): Promise<IDocumentService> {
+		return new FileDocumentService(this.storage, this.deltaStorage, this.deltaConnection);
+	}
 
-    // TODO: Issue-2109 Implement detach container api or put appropriate comment.
-    public async createContainer(
-        createNewSummary: ISummaryTree,
-        resolvedUrl: IResolvedUrl,
-        logger?: ITelemetryBaseLogger,
-        clientIsSummarizer?: boolean,
-    ): Promise<IDocumentService> {
-        throw new Error("Not implemented");
-    }
+	// TODO: Issue-2109 Implement detach container api or put appropriate comment.
+	public async createContainer(
+		createNewSummary: ISummaryTree,
+		resolvedUrl: IResolvedUrl,
+		logger?: ITelemetryBaseLogger,
+		clientIsSummarizer?: boolean,
+	): Promise<IDocumentService> {
+		throw new Error("Not implemented");
+	}
 }