@fluidframework/local-driver 1.4.0-115997 → 2.0.0-dev-rc.1.0.0.224419

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;
+	}
+}

package/src/localResolver.ts

@@ -4,81 +4,79 @@
  */
 
 import { parse } from "url";
-import { assert } from "@fluidframework/common-utils";
+import { assert } from "@fluidframework/core-utils";
 import { IRequest } from "@fluidframework/core-interfaces";
-import {
-    IFluidResolvedUrl,
-    IResolvedUrl,
-    IUrlResolver,
-    DriverHeader,
-} from "@fluidframework/driver-definitions";
+import { IResolvedUrl, IUrlResolver, DriverHeader } from "@fluidframework/driver-definitions";
 import { ScopeType } from "@fluidframework/protocol-definitions";
 import { generateToken } from "./auth";
 
+/**
+ * @alpha
+ */
 export function createLocalResolverCreateNewRequest(documentId: string): IRequest {
-    const createNewRequest: IRequest = {
-        url: `http://localhost:3000/${documentId}`,
-        headers: {
-            [DriverHeader.createNew]: true,
-        },
-    };
-    return createNewRequest;
+	const createNewRequest: IRequest = {
+		url: `http://localhost:3000/${documentId}`,
+		headers: {
+			[DriverHeader.createNew]: true,
+		},
+	};
+	return createNewRequest;
 }
 
 /**
  * Resolves URLs by providing fake URLs which succeed with the other
  * related local classes.
+ * @alpha
  */
 export class LocalResolver implements IUrlResolver {
-    private readonly tenantId = "tenantId";
-    private readonly tokenKey = "tokenKey";
-
-    constructor() { }
+	private readonly tenantId = "tenantId";
+	private readonly tokenKey = "tokenKey";
 
-    /**
-     * Resolves URL requests by providing fake URLs with an actually generated
-     * token from constant test strings. The root of the URL is fake, but the
-     * remaining relative URL can still be parsed.
-     * @param request - request to handle
-     */
-    public async resolve(request: IRequest): Promise<IResolvedUrl> {
-        const parsedUrl = new URL(request.url);
-        const fullPath = `${parsedUrl.pathname.substr(1)}${parsedUrl.search}`;
-        const documentId = fullPath.split("/")[0];
-        const scopes = [ScopeType.DocRead, ScopeType.DocWrite, ScopeType.SummaryWrite];
-        const resolved: IFluidResolvedUrl = {
-            endpoints: {
-                deltaStorageUrl: `http://localhost:3000/deltas/${this.tenantId}/${documentId}`,
-                ordererUrl: "http://localhost:3000",
-                storageUrl: `http://localhost:3000/repos/${this.tenantId}`,
-            },
-            id: documentId,
-            tokens: { jwt: generateToken(this.tenantId, documentId, this.tokenKey, scopes) },
-            type: "fluid",
-            url: `fluid-test://localhost:3000/${this.tenantId}/${fullPath}`,
-        };
+	constructor() {}
 
-        return resolved;
-    }
+	/**
+	 * Resolves URL requests by providing fake URLs with an actually generated
+	 * token from constant test strings. The root of the URL is fake, but the
+	 * remaining relative URL can still be parsed.
+	 * @param request - request to handle
+	 * @alpha
+	 */
+	public async resolve(request: IRequest): Promise<IResolvedUrl> {
+		const parsedUrl = new URL(request.url);
+		const fullPath = `${parsedUrl.pathname.substr(1)}${parsedUrl.search}`;
+		const documentId = fullPath.split("/")[0];
+		const scopes = [ScopeType.DocRead, ScopeType.DocWrite, ScopeType.SummaryWrite];
+		const resolved: IResolvedUrl = {
+			endpoints: {
+				deltaStorageUrl: `http://localhost:3000/deltas/${this.tenantId}/${documentId}`,
+				ordererUrl: "http://localhost:3000",
+				storageUrl: `http://localhost:3000/repos/${this.tenantId}`,
+			},
+			id: documentId,
+			tokens: { jwt: generateToken(this.tenantId, documentId, this.tokenKey, scopes) },
+			type: "fluid",
+			url: `fluid-test://localhost:3000/${this.tenantId}/${fullPath}`,
+		};
 
-    public async getAbsoluteUrl(resolvedUrl: IResolvedUrl, relativeUrl: string): Promise<string> {
-        let url = relativeUrl;
-        if (url.startsWith("/")) {
-            url = url.substr(1);
-        }
-        const fluidResolvedUrl = resolvedUrl as IFluidResolvedUrl;
+		return resolved;
+	}
 
-        const parsedUrl = parse(fluidResolvedUrl.url);
-        if (parsedUrl.pathname === null) {
-            throw new Error("Url should contain tenant and docId!!");
-        }
-        const [, , documentId] = parsedUrl.pathname.split("/");
-        assert(!!documentId, 0x09a /* "'documentId' must be a defined, non-zero length string." */);
+	public async getAbsoluteUrl(resolvedUrl: IResolvedUrl, relativeUrl: string): Promise<string> {
+		let url = relativeUrl;
+		if (url.startsWith("/")) {
+			url = url.substr(1);
+		}
+		const parsedUrl = parse(resolvedUrl.url);
+		if (parsedUrl.pathname === null) {
+			throw new Error("Url should contain tenant and docId!!");
+		}
+		const [, , documentId] = parsedUrl.pathname.split("/");
+		assert(!!documentId, 0x09a /* "'documentId' must be a defined, non-zero length string." */);
 
-        return `http://localhost:3000/${documentId}/${url}`;
-    }
+		return `http://localhost:3000/${documentId}/${url}`;
+	}
 
-    public createCreateNewRequest(documentId: string): IRequest {
-        return createLocalResolverCreateNewRequest(documentId);
-    }
+	public createCreateNewRequest(documentId: string): IRequest {
+		return createLocalResolverCreateNewRequest(documentId);
+	}
 }