@fluidframework/local-driver 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.225277

package/src/localDocumentService.ts

@@ -3,100 +3,116 @@
  * Licensed under the MIT License.
  */
 
-import * as api from "@fluidframework/driver-definitions";
+import {
+	IDocumentDeltaConnection,
+	IDocumentDeltaStorageService,
+	IDocumentService,
+	IDocumentServicePolicies,
+	IDocumentStorageService,
+	IResolvedUrl,
+} from "@fluidframework/driver-definitions";
 import { IClient } from "@fluidframework/protocol-definitions";
-import * as socketStorage from "@fluidframework/routerlicious-driver";
+import { ITokenProvider } from "@fluidframework/routerlicious-driver";
 import { GitManager } from "@fluidframework/server-services-client";
 import { TestHistorian } from "@fluidframework/server-test-utils";
 import { ILocalDeltaConnectionServer } from "@fluidframework/server-local-server";
-import { TelemetryNullLogger } from "@fluidframework/common-utils";
-import { LocalDeltaStorageService, LocalDocumentDeltaConnection } from ".";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { LocalDocumentStorageService } from "./localDocumentStorageService";
+import { LocalDocumentDeltaConnection } from "./localDocumentDeltaConnection";
+import { LocalDeltaStorageService } from "./localDeltaStorageService";
 
 /**
  * Basic implementation of a document service for local use.
+ * @internal
  */
-export class LocalDocumentService implements api.IDocumentService {
-    /**
-     * @param localDeltaConnectionServer - delta connection server for ops
-     * @param tokenProvider - token provider
-     * @param tenantId - ID of tenant
-     * @param documentId - ID of document
-     */
-    constructor(
-        public readonly resolvedUrl: api.IResolvedUrl,
-        private readonly localDeltaConnectionServer: ILocalDeltaConnectionServer,
-        private readonly tokenProvider: socketStorage.ITokenProvider,
-        private readonly tenantId: string,
-        private readonly documentId: string,
-        private readonly documentDeltaConnectionsMap: Map<string, LocalDocumentDeltaConnection>,
-        public readonly policies: api.IDocumentServicePolicies = {},
-        private readonly innerDocumentService?: api.IDocumentService,
-    ) { }
+export class LocalDocumentService implements IDocumentService {
+	/**
+	 * @param localDeltaConnectionServer - delta connection server for ops
+	 * @param tokenProvider - token provider
+	 * @param tenantId - ID of tenant
+	 * @param documentId - ID of document
+	 */
+	constructor(
+		public readonly resolvedUrl: IResolvedUrl,
+		private readonly localDeltaConnectionServer: ILocalDeltaConnectionServer,
+		private readonly tokenProvider: ITokenProvider,
+		private readonly tenantId: string,
+		private readonly documentId: string,
+		private readonly documentDeltaConnectionsMap: Map<string, LocalDocumentDeltaConnection>,
+		public readonly policies: IDocumentServicePolicies = {},
+		private readonly innerDocumentService?: IDocumentService,
+		private readonly logger?: ITelemetryBaseLogger,
+	) {}
 
-    public dispose() { }
+	public dispose() {}
 
-    /**
-     * Creates and returns a document storage service for local use.
-     */
-    public async connectToStorage(): Promise<api.IDocumentStorageService> {
-        return new socketStorage.DocumentStorageService(
-            this.documentId,
-            new GitManager(new TestHistorian(this.localDeltaConnectionServer.testDbFactory.testDatabase)),
-            new TelemetryNullLogger(),
-            { minBlobSize: 2048 }, // Test blob aggregation.
-            undefined,
-            undefined,
-            undefined,
-            new GitManager(new TestHistorian(this.localDeltaConnectionServer.testDbFactory.testDatabase)));
-    }
+	/**
+	 * Creates and returns a document storage service for local use.
+	 */
+	public async connectToStorage(): Promise<IDocumentStorageService> {
+		return new LocalDocumentStorageService(
+			this.documentId,
+			new GitManager(
+				new TestHistorian(this.localDeltaConnectionServer.testDbFactory.testDatabase),
+			),
+			{
+				maximumCacheDurationMs: 432_000_000, // 5 days in ms. Not actually enforced but shouldn't matter for any local driver scenario
+			},
+			this.localDeltaConnectionServer,
+			this.resolvedUrl,
+		);
+	}
 
-    /**
-     * Creates and returns a delta storage service for local use.
-     */
-    public async connectToDeltaStorage(): Promise<api.IDocumentDeltaStorageService> {
-        if (this.innerDocumentService) {
-            return this.innerDocumentService.connectToDeltaStorage();
-        }
-        return new LocalDeltaStorageService(
-            this.tenantId,
-            this.documentId,
-            this.localDeltaConnectionServer.databaseManager);
-    }
+	/**
+	 * Creates and returns a delta storage service for local use.
+	 */
+	public async connectToDeltaStorage(): Promise<IDocumentDeltaStorageService> {
+		if (this.innerDocumentService) {
+			return this.innerDocumentService.connectToDeltaStorage();
+		}
+		return new LocalDeltaStorageService(
+			this.tenantId,
+			this.documentId,
+			this.localDeltaConnectionServer.databaseManager,
+		);
+	}
 
-    /**
-     * Creates and returns a delta stream for local use.
-     * @param client - client data
-     */
-    public async connectToDeltaStream(client: IClient): Promise<api.IDocumentDeltaConnection> {
-        if (this.policies.storageOnly === true) {
-            throw new Error("can't connect to delta stream in storage-only mode");
-        }
-        if (this.innerDocumentService) {
-            return this.innerDocumentService.connectToDeltaStream(client);
-        }
-        const ordererToken = await this.tokenProvider.fetchOrdererToken(
-            this.tenantId,
-            this.documentId,
-        );
-        const documentDeltaConnection = await LocalDocumentDeltaConnection.create(
-            this.tenantId,
-            this.documentId,
-            ordererToken.jwt,
-            client,
-            this.localDeltaConnectionServer.webSocketServer,
-        );
-        const clientId = documentDeltaConnection.clientId;
+	/**
+	 * Creates and returns a delta stream for local use.
+	 * @param client - client data
+	 */
+	public async connectToDeltaStream(client: IClient): Promise<IDocumentDeltaConnection> {
+		if (this.policies.storageOnly === true) {
+			throw new Error("can't connect to delta stream in storage-only mode");
+		}
+		if (this.innerDocumentService) {
+			return this.innerDocumentService.connectToDeltaStream(client);
+		}
+		const ordererToken = await this.tokenProvider.fetchOrdererToken(
+			this.tenantId,
+			this.documentId,
+		);
+		const documentDeltaConnection = await LocalDocumentDeltaConnection.create(
+			this.tenantId,
+			this.documentId,
+			ordererToken.jwt,
+			client,
+			this.localDeltaConnectionServer.webSocketServer,
+			undefined,
+			this.logger,
+		);
+		const clientId = documentDeltaConnection.clientId;
 
-        // Add this document service for the clientId in the document service factory.
-        this.documentDeltaConnectionsMap.set(clientId, documentDeltaConnection);
+		// Add this document service for the clientId in the document service factory.
+		this.documentDeltaConnectionsMap.set(clientId, documentDeltaConnection);
 
-        // Add a listener to remove this document service when the client is disconnected.
-        documentDeltaConnection.on("disconnect", () => {
-            this.documentDeltaConnectionsMap.delete(clientId);
-        });
+		// Add a listener to remove this document service when the client is disconnected.
+		documentDeltaConnection.on("disconnect", () => {
+			this.documentDeltaConnectionsMap.delete(clientId);
+		});
 
-        return documentDeltaConnection;
-    }
+		return documentDeltaConnection;
+	}
 }
 
 /**
@@ -105,24 +121,28 @@ export class LocalDocumentService implements api.IDocumentService {
  * @param tokenProvider - token provider with a single token
  * @param tenantId - ID of tenant
  * @param documentId - ID of document
+ * @internal
  */
 export function createLocalDocumentService(
-    resolvedUrl: api.IResolvedUrl,
-    localDeltaConnectionServer: ILocalDeltaConnectionServer,
-    tokenProvider: socketStorage.ITokenProvider,
-    tenantId: string,
-    documentId: string,
-    documentDeltaConnectionsMap: Map<string, LocalDocumentDeltaConnection>,
-    policies?: api.IDocumentServicePolicies,
-    innerDocumentService?: api.IDocumentService): api.IDocumentService {
-    return new LocalDocumentService(
-        resolvedUrl,
-        localDeltaConnectionServer,
-        tokenProvider,
-        tenantId,
-        documentId,
-        documentDeltaConnectionsMap,
-        policies,
-        innerDocumentService,
-    );
+	resolvedUrl: IResolvedUrl,
+	localDeltaConnectionServer: ILocalDeltaConnectionServer,
+	tokenProvider: ITokenProvider,
+	tenantId: string,
+	documentId: string,
+	documentDeltaConnectionsMap: Map<string, LocalDocumentDeltaConnection>,
+	policies?: IDocumentServicePolicies,
+	innerDocumentService?: IDocumentService,
+	logger?: ITelemetryBaseLogger,
+): IDocumentService {
+	return new LocalDocumentService(
+		resolvedUrl,
+		localDeltaConnectionServer,
+		tokenProvider,
+		tenantId,
+		documentId,
+		documentDeltaConnectionsMap,
+		policies,
+		innerDocumentService,
+		logger,
+	);
 }

package/src/localDocumentServiceFactory.ts

@@ -5,145 +5,117 @@
 
 import { parse } from "url";
 import {
-    IDocumentService,
-    IDocumentServiceFactory,
-    IDocumentServicePolicies,
-    IResolvedUrl,
+	IDocumentService,
+	IDocumentServiceFactory,
+	IDocumentServicePolicies,
+	IResolvedUrl,
 } from "@fluidframework/driver-definitions";
-import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { DefaultTokenProvider } from "@fluidframework/routerlicious-driver";
-import { ILocalDeltaConnectionServer, LocalDeltaConnectionServer } from "@fluidframework/server-local-server";
-import {
-    ensureFluidResolvedUrl,
-    getDocAttributesFromProtocolSummary,
-    getQuorumValuesFromProtocolSummary,
-} from "@fluidframework/driver-utils";
+import { ILocalDeltaConnectionServer } from "@fluidframework/server-local-server";
 import { ISummaryTree, NackErrorType } from "@fluidframework/protocol-definitions";
-import { defaultHash } from "@fluidframework/server-services-client";
 import { LocalDocumentDeltaConnection } from "./localDocumentDeltaConnection";
 import { createLocalDocumentService } from "./localDocumentService";
+import { createDocument } from "./localCreateDocument";
 
 /**
  * Implementation of document service factory for local use.
+ * @alpha
  */
 export class LocalDocumentServiceFactory implements IDocumentServiceFactory {
-    public readonly protocolName = "fluid-test:";
-
-    // A map of clientId to LocalDocumentService.
-    private readonly documentDeltaConnectionsMap: Map<string, LocalDocumentDeltaConnection> = new Map();
-
-    /**
-     * @param localDeltaConnectionServer - delta connection server for ops
-     */
-    constructor(
-        private readonly localDeltaConnectionServer: ILocalDeltaConnectionServer,
-        private readonly policies?: IDocumentServicePolicies,
-        private readonly innerDocumentService?: IDocumentService) { }
-
-    public async createContainer(
-        createNewSummary: ISummaryTree | undefined,
-        resolvedUrl: IResolvedUrl,
-        logger?: ITelemetryBaseLogger,
-        clientIsSummarizer?: boolean,
-    ): Promise<IDocumentService> {
-        ensureFluidResolvedUrl(resolvedUrl);
-        if (createNewSummary === undefined) {
-            throw new Error("Empty file summary creation isn't supported in this driver.");
-        }
-        const pathName = new URL(resolvedUrl.url).pathname;
-        const pathArr = pathName.split("/");
-        const tenantId = pathArr[pathArr.length - 2];
-        const id = pathArr[pathArr.length - 1];
-        if (!this.localDeltaConnectionServer) {
-            throw new Error("Provide the localDeltaConnectionServer!!");
-        }
-        const documentStorage = (this.localDeltaConnectionServer as LocalDeltaConnectionServer).documentStorage;
+	// A map of clientId to LocalDocumentService.
+	private readonly documentDeltaConnectionsMap: Map<string, LocalDocumentDeltaConnection> =
+		new Map();
 
-        const protocolSummary = createNewSummary.tree[".protocol"] as ISummaryTree;
-        const appSummary = createNewSummary.tree[".app"] as ISummaryTree;
-        if (!(protocolSummary && appSummary)) {
-            throw new Error("Protocol and App Summary required in the full summary");
-        }
-        const documentAttributes = getDocAttributesFromProtocolSummary(protocolSummary);
-        const quorumValues = getQuorumValuesFromProtocolSummary(protocolSummary);
-        const sequenceNumber = documentAttributes.sequenceNumber;
-        await documentStorage.createDocument(
-            tenantId,
-            id,
-            appSummary,
-            sequenceNumber,
-            documentAttributes.term ?? 1,
-            defaultHash,
-            resolvedUrl.endpoints.ordererUrl ?? "",
-            resolvedUrl.endpoints.storageUrl ?? "",
-            quorumValues,
-            false,
-        );
-        return this.createDocumentService(resolvedUrl, logger, clientIsSummarizer);
-    }
+	/**
+	 * @param localDeltaConnectionServer - delta connection server for ops
+	 * @alpha
+	 */
+	constructor(
+		private readonly localDeltaConnectionServer: ILocalDeltaConnectionServer,
+		private readonly policies?: IDocumentServicePolicies,
+		private readonly innerDocumentService?: IDocumentService,
+	) {}
 
-    /**
-     * Creates and returns a document service for testing using the given resolved
-     * URL for the tenant ID, document ID, and token.
-     * @param resolvedUrl - resolved URL of document
-     */
-    public async createDocumentService(
-        resolvedUrl: IResolvedUrl,
-        logger?: ITelemetryBaseLogger,
-        clientIsSummarizer?: boolean,
-    ): Promise<IDocumentService> {
-        ensureFluidResolvedUrl(resolvedUrl);
+	public async createContainer(
+		createNewSummary: ISummaryTree | undefined,
+		resolvedUrl: IResolvedUrl,
+		logger?: ITelemetryBaseLogger,
+		clientIsSummarizer?: boolean,
+	): Promise<IDocumentService> {
+		if (!this.localDeltaConnectionServer) {
+			throw new Error("Provide the localDeltaConnectionServer!!");
+		}
+		if (createNewSummary !== undefined) {
+			await createDocument(this.localDeltaConnectionServer, resolvedUrl, createNewSummary);
+		}
+		return this.createDocumentService(resolvedUrl, logger, clientIsSummarizer);
+	}
 
-        const parsedUrl = parse(resolvedUrl.url);
-        const [, tenantId, documentId] = parsedUrl.path ? parsedUrl.path.split("/") : [];
-        if (!documentId || !tenantId) {
-            throw new Error(`Couldn't parse resolved url. [documentId:${documentId}][tenantId:${tenantId}]`);
-        }
+	/**
+	 * Creates and returns a document service for testing using the given resolved
+	 * URL for the tenant ID, document ID, and token.
+	 * @param resolvedUrl - resolved URL of document
+	 */
+	public async createDocumentService(
+		resolvedUrl: IResolvedUrl,
+		logger?: ITelemetryBaseLogger,
+		clientIsSummarizer?: boolean,
+	): Promise<IDocumentService> {
+		const parsedUrl = parse(resolvedUrl.url);
+		const [, tenantId, documentId] = parsedUrl.path ? parsedUrl.path.split("/") : [];
+		if (!documentId || !tenantId) {
+			throw new Error(
+				`Couldn't parse resolved url. [documentId:${documentId}][tenantId:${tenantId}]`,
+			);
+		}
 
-        const fluidResolvedUrl = resolvedUrl;
-        const jwtToken = fluidResolvedUrl.tokens.jwt;
-        if (!jwtToken) {
-            throw new Error(`Token was not provided.`);
-        }
+		const fluidResolvedUrl = resolvedUrl;
+		const jwtToken = fluidResolvedUrl.tokens.jwt;
+		if (!jwtToken) {
+			throw new Error(`Token was not provided.`);
+		}
 
-        const tokenProvider = new DefaultTokenProvider(jwtToken);
+		const tokenProvider = new DefaultTokenProvider(jwtToken);
 
-        return createLocalDocumentService(
-            resolvedUrl,
-            this.localDeltaConnectionServer,
-            tokenProvider,
-            tenantId,
-            documentId,
-            this.documentDeltaConnectionsMap,
-            this.policies,
-            this.innerDocumentService);
-    }
+		return createLocalDocumentService(
+			resolvedUrl,
+			this.localDeltaConnectionServer,
+			tokenProvider,
+			tenantId,
+			documentId,
+			this.documentDeltaConnectionsMap,
+			this.policies,
+			this.innerDocumentService,
+			logger,
+		);
+	}
 
-    /**
-     * Gets the document delta connection for the clientId and asks it to disconnect the client.
-     * @param clientId - The ID of the client to be disconnected.
-     * @param disconnectReason - The reason of the disconnection.
-     */
-    public disconnectClient(clientId: string, disconnectReason: string) {
-        if (!this.documentDeltaConnectionsMap.has(clientId)) {
-            throw new Error(`No client with the id: ${clientId}`);
-        }
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        this.documentDeltaConnectionsMap.get(clientId)!.disconnectClient(disconnectReason);
-    }
+	/**
+	 * Gets the document delta connection for the clientId and asks it to disconnect the client.
+	 * @param clientId - The ID of the client to be disconnected.
+	 * @param disconnectReason - The reason of the disconnection.
+	 */
+	public disconnectClient(clientId: string, disconnectReason: string) {
+		const documentDeltaConnection = this.documentDeltaConnectionsMap.get(clientId);
+		if (documentDeltaConnection === undefined) {
+			throw new Error(`No client with the id: ${clientId}`);
+		}
+		documentDeltaConnection.disconnectClient(disconnectReason);
+	}
 
-    /**
-     * Gets the document delta connection for the clientId and asks it to nack the client.
-     * @param clientId - The ID of the client to be Nack'd.
-     * @param code - An error code number that represents the error. It will be a valid HTTP error code.
-     * @param type - Type of the Nack.
-     * @param message - A message about the nack for debugging/logging/telemetry purposes.
-     */
-    public nackClient(clientId: string, code?: number, type?: NackErrorType, message?: any) {
-        if (!this.documentDeltaConnectionsMap.has(clientId)) {
-            throw new Error(`No client with the id: ${clientId}`);
-        }
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        this.documentDeltaConnectionsMap.get(clientId)!.nackClient(code, type, message);
-    }
+	/**
+	 * Gets the document delta connection for the clientId and asks it to nack the client.
+	 * @param clientId - The ID of the client to be Nack'd.
+	 * @param code - An error code number that represents the error. It will be a valid HTTP error code.
+	 * @param type - Type of the Nack.
+	 * @param message - A message about the nack for debugging/logging/telemetry purposes.
+	 */
+	public nackClient(clientId: string, code?: number, type?: NackErrorType, message?: any) {
+		const documentDeltaConnection = this.documentDeltaConnectionsMap.get(clientId);
+		if (documentDeltaConnection === undefined) {
+			throw new Error(`No client with the id: ${clientId}`);
+		}
+		documentDeltaConnection.nackClient(code, type, message);
+	}
 }

package/src/localDocumentStorageService.ts

@@ -0,0 +1,131 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { stringToBuffer, Uint8ArrayToString } from "@fluid-internal/client-utils";
+import {
+	IDocumentStorageService,
+	IDocumentStorageServicePolicies,
+	IResolvedUrl,
+	ISummaryContext,
+} from "@fluidframework/driver-definitions";
+import {
+	ICreateBlobResponse,
+	ISnapshotTreeEx,
+	ISummaryHandle,
+	ISummaryTree,
+	IVersion,
+} from "@fluidframework/protocol-definitions";
+import { buildGitTreeHierarchy } from "@fluidframework/protocol-base";
+import {
+	GitManager,
+	ISummaryUploadManager,
+	SummaryTreeUploadManager,
+} from "@fluidframework/server-services-client";
+import { ILocalDeltaConnectionServer } from "@fluidframework/server-local-server";
+import { createDocument } from "./localCreateDocument";
+
+const minTTLInSeconds = 24 * 60 * 60; // Same TTL as ODSP
+/**
+ * @internal
+ */
+export class LocalDocumentStorageService implements IDocumentStorageService {
+	// The values of this cache is useless. We only need the keys. So we are always putting
+	// empty strings as values.
+	protected readonly blobsShaCache = new Map<string, string>();
+	private readonly summaryTreeUploadManager: ISummaryUploadManager;
+
+	public readonly repositoryUrl: string = "";
+
+	constructor(
+		private readonly id: string,
+		private readonly manager: GitManager,
+		public readonly policies: IDocumentStorageServicePolicies,
+		private readonly localDeltaConnectionServer?: ILocalDeltaConnectionServer,
+		private readonly resolvedUrl?: IResolvedUrl,
+	) {
+		this.summaryTreeUploadManager = new SummaryTreeUploadManager(
+			manager,
+			this.blobsShaCache,
+			this.getPreviousFullSnapshot.bind(this),
+		);
+	}
+
+	public async getVersions(versionId: string | null, count: number): Promise<IVersion[]> {
+		const id = versionId ? versionId : this.id;
+		const commits = await this.manager.getCommits(id, count);
+		return commits.map((commit) => ({
+			date: commit.commit.author.date,
+			id: commit.sha,
+			treeId: commit.commit.tree.sha,
+		}));
+	}
+
+	public async getSnapshotTree(version?: IVersion): Promise<ISnapshotTreeEx | null> {
+		let requestVersion = version;
+		if (!requestVersion) {
+			const versions = await this.getVersions(this.id, 1);
+			if (versions.length === 0) {
+				return null;
+			}
+
+			requestVersion = versions[0];
+		}
+
+		const rawTree = await this.manager.getTree(requestVersion.treeId);
+		const tree = buildGitTreeHierarchy(rawTree, this.blobsShaCache, true);
+		return tree;
+	}
+
+	public async readBlob(blobId: string): Promise<ArrayBufferLike> {
+		const blob = await this.manager.getBlob(blobId);
+		this.blobsShaCache.set(blob.sha, "");
+		const bufferContent = stringToBuffer(blob.content, blob.encoding);
+		return bufferContent;
+	}
+
+	public async uploadSummaryWithContext(
+		summary: ISummaryTree,
+		context: ISummaryContext,
+	): Promise<string> {
+		if (context.referenceSequenceNumber === 0) {
+			if (this.localDeltaConnectionServer === undefined || this.resolvedUrl === undefined) {
+				throw new Error(
+					"Insufficient constructor parameters. An ILocalDeltaConnectionServer and IResolvedUrl required",
+				);
+			}
+			await createDocument(this.localDeltaConnectionServer, this.resolvedUrl, summary);
+			const version = await this.getVersions(this.id, 1);
+			return version[0].id;
+		}
+		return this.summaryTreeUploadManager.writeSummaryTree(
+			summary,
+			context.ackHandle ?? "",
+			"channel",
+		);
+	}
+
+	public async createBlob(file: ArrayBufferLike): Promise<ICreateBlobResponse> {
+		const uint8ArrayFile = new Uint8Array(file);
+		return this.manager
+			.createBlob(Uint8ArrayToString(uint8ArrayFile, "base64"), "base64")
+			.then((r) => ({ id: r.sha, url: r.url, minTTLInSeconds }));
+	}
+
+	public async downloadSummary(handle: ISummaryHandle): Promise<ISummaryTree> {
+		throw new Error("NOT IMPLEMENTED!");
+	}
+
+	private async getPreviousFullSnapshot(
+		parentHandle: string,
+	): Promise<ISnapshotTreeEx | null | undefined> {
+		return parentHandle
+			? this.getVersions(parentHandle, 1).then(async (versions) => {
+					// Clear the cache as the getSnapshotTree call will fill the cache.
+					this.blobsShaCache.clear();
+					return this.getSnapshotTree(versions[0]);
+			  })
+			: undefined;
+	}
+}