@fluidframework/odsp-driver 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/src/localOdspDriver/localOdspDocumentService.ts

@@ -3,52 +3,54 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLogger } from "@fluidframework/common-definitions";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import {
-    IDocumentDeltaStorageService,
-    IDocumentService,
-    IDocumentStorageService,
-    IResolvedUrl,
+	IDocumentDeltaStorageService,
+	IDocumentService,
+	IDocumentStorageService,
+	IResolvedUrl,
 } from "@fluidframework/driver-definitions";
-import { UsageError, EmptyDocumentDeltaStorageService } from "@fluidframework/driver-utils";
+import { UsageError } from "@fluidframework/driver-utils";
 import { IOdspResolvedUrl } from "@fluidframework/odsp-driver-definitions";
 import { IClient } from "@fluidframework/protocol-definitions";
+import { LocalOdspDeltaStorageService } from "./localOdspDeltaStorageService";
 import { LocalOdspDocumentStorageService } from "./localOdspDocumentStorageManager";
 
 /**
  * IDocumentService implementation that provides explicit snapshot to the document storage service.
  */
 export class LocalOdspDocumentService implements IDocumentService {
-    public policies = { storageOnly: true };
-
-    constructor(
-        private readonly odspResolvedUrl: IOdspResolvedUrl,
-        private readonly logger: ITelemetryLogger,
-        private readonly localSnapshot: Uint8Array | string,
-    ) { }
-
-    public get resolvedUrl(): IResolvedUrl {
-        return this.odspResolvedUrl;
-    }
-
-    public async connectToStorage(): Promise<IDocumentStorageService> {
-        return new LocalOdspDocumentStorageService(
-            this.logger,
-            this.localSnapshot,
-        );
-    }
-
-    public async connectToDeltaStorage(): Promise<IDocumentDeltaStorageService> {
-        return new EmptyDocumentDeltaStorageService();
-    }
-
-    public connectToDeltaStream(_client: IClient): never {
-        const toThrow = new UsageError("\"connectToDeltaStream\" is not supported by LocalOdspDocumentService");
-        this.logger.sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
-        throw toThrow;
-    }
-
-    public dispose(_error?: any): void {
-        // Do nothing
-    }
+	public policies = { storageOnly: true };
+	private storageManager?: LocalOdspDocumentStorageService;
+
+	constructor(
+		private readonly odspResolvedUrl: IOdspResolvedUrl,
+		private readonly logger: ITelemetryLoggerExt,
+		private readonly localSnapshot: Uint8Array | string,
+	) {}
+
+	public get resolvedUrl(): IResolvedUrl {
+		return this.odspResolvedUrl;
+	}
+
+	public async connectToStorage(): Promise<IDocumentStorageService> {
+		this.storageManager = new LocalOdspDocumentStorageService(this.logger, this.localSnapshot);
+		return this.storageManager;
+	}
+
+	public async connectToDeltaStorage(): Promise<IDocumentDeltaStorageService> {
+		return new LocalOdspDeltaStorageService(this.logger, this.storageManager?.ops ?? []);
+	}
+
+	public connectToDeltaStream(_client: IClient): never {
+		const toThrow = new UsageError(
+			'"connectToDeltaStream" is not supported by LocalOdspDocumentService',
+		);
+		this.logger.sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
+		throw toThrow;
+	}
+
+	public dispose(_error?: any): void {
+		// Do nothing
+	}
 }

package/src/localOdspDriver/localOdspDocumentServiceFactory.ts

@@ -5,9 +5,8 @@
 
 import { IDocumentService, IResolvedUrl } from "@fluidframework/driver-definitions";
 import { UsageError } from "@fluidframework/driver-utils";
-import { TelemetryLogger } from "@fluidframework/telemetry-utils";
 import { ISummaryTree } from "@fluidframework/protocol-definitions";
-import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
+import { ITelemetryBaseLogger, ITelemetryLogger } from "@fluidframework/core-interfaces";
 import { createOdspLogger, getOdspResolvedUrl } from "../odspUtils";
 import { ICacheAndTracker } from "../epochTracker";
 import { OdspDocumentServiceFactoryCore } from "../odspDocumentServiceFactoryCore";
@@ -19,49 +18,53 @@ import { LocalOdspDocumentService } from "./localOdspDocumentService";
  * content directly.
  */
 export class LocalOdspDocumentServiceFactory extends OdspDocumentServiceFactoryCore {
-    private logger: TelemetryLogger | undefined;
+	private logger: ITelemetryLogger | undefined;
 
-    constructor(
-        private readonly localSnapshot: Uint8Array | string,
-    ) {
-        super(
-            (_options) => this.throwUnsupportedUsageError("Getting storage token"),
-            (_options) => this.throwUnsupportedUsageError("Getting websocket token"),
-            () => this.throwUnsupportedUsageError("Getting SocketIO Client"),
-        );
-    }
+	constructor(private readonly localSnapshot: Uint8Array | string) {
+		super(
+			(_options) => this.throwUnsupportedUsageError("Getting storage token"),
+			(_options) => this.throwUnsupportedUsageError("Getting websocket token"),
+		);
+	}
 
-    private throwUnsupportedUsageError(unsupportedFuncName: string): never {
-        const toThrow = new UsageError(
-            `${unsupportedFuncName} is not supported by LocalOdspDocumentServiceFactory`);
-        this.logger?.sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
-        throw toThrow;
-    }
+	private throwUnsupportedUsageError(unsupportedFuncName: string): never {
+		const toThrow = new UsageError(
+			`${unsupportedFuncName} is not supported by LocalOdspDocumentServiceFactory`,
+		);
+		this.logger?.sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
+		throw toThrow;
+	}
 
-    public createContainer(
-        _createNewSummary: ISummaryTree | undefined,
-        _createNewResolvedUrl: IResolvedUrl,
-        logger?: ITelemetryBaseLogger,
-        _clientIsSummarizer?: boolean,
-    ): never {
-        const toThrow = new UsageError("\"createContainer\" is not supported by LocalOdspDocumentServiceFactory");
-        createOdspLogger(logger).sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
-        throw toThrow;
-    }
+	public createContainer(
+		_createNewSummary: ISummaryTree | undefined,
+		_createNewResolvedUrl: IResolvedUrl,
+		logger?: ITelemetryBaseLogger,
+		_clientIsSummarizer?: boolean,
+	): never {
+		const toThrow = new UsageError(
+			'"createContainer" is not supported by LocalOdspDocumentServiceFactory',
+		);
+		createOdspLogger(logger).sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
+		throw toThrow;
+	}
 
-    protected async createDocumentServiceCore(
-        resolvedUrl: IResolvedUrl,
-        odspLogger: TelemetryLogger,
-        _cacheAndTrackerArg?: ICacheAndTracker,
-        _clientIsSummarizer?: boolean,
-    ): Promise<IDocumentService> {
-        if (_cacheAndTrackerArg !== undefined) {
-            throw new UsageError("Invalid usage. \"_cacheAndTrackerArg\" should not be provided");
-        }
-        if (_clientIsSummarizer) {
-            throw new UsageError("Invalid usage. \"_clientIsSummarizer\" should not be provided");
-        }
-        this.logger = odspLogger;
-        return new LocalOdspDocumentService(getOdspResolvedUrl(resolvedUrl), odspLogger, this.localSnapshot);
-    }
+	protected async createDocumentServiceCore(
+		resolvedUrl: IResolvedUrl,
+		odspLogger: ITelemetryLogger,
+		_cacheAndTrackerArg?: ICacheAndTracker,
+		_clientIsSummarizer?: boolean,
+	): Promise<IDocumentService> {
+		if (_cacheAndTrackerArg !== undefined) {
+			throw new UsageError('Invalid usage. "_cacheAndTrackerArg" should not be provided');
+		}
+		if (_clientIsSummarizer) {
+			throw new UsageError('Invalid usage. "_clientIsSummarizer" should not be provided');
+		}
+		this.logger = odspLogger;
+		return new LocalOdspDocumentService(
+			getOdspResolvedUrl(resolvedUrl),
+			odspLogger,
+			this.localSnapshot,
+		);
+	}
 }

package/src/localOdspDriver/localOdspDocumentStorageManager.ts

@@ -3,8 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/common-utils";
-import { ITelemetryLogger } from "@fluidframework/common-definitions";
+import { assert } from "@fluidframework/core-utils";
+import { ITelemetryLoggerExt, loggerToMonitoringContext } from "@fluidframework/telemetry-utils";
 import { ISummaryContext } from "@fluidframework/driver-definitions";
 import { UsageError } from "@fluidframework/driver-utils";
 import * as api from "@fluidframework/protocol-definitions";
@@ -13,71 +13,76 @@ import { ISnapshotContents } from "../odspPublicUtils";
 import { IOdspSnapshot } from "../contracts";
 import { convertOdspSnapshotToSnapshotTreeAndBlobs } from "../odspSnapshotParser";
 import { parseCompactSnapshotResponse } from "../compactSnapshotParser";
-import { ReadBuffer } from "../ReadBufferUtils";
 
 /**
  * ODSP document storage service that works on a provided snapshot for all its processing.
  * Attempting to use unsupported actions/methods will result in errors being thrown.
  */
 export class LocalOdspDocumentStorageService extends OdspDocumentStorageServiceBase {
-    private snapshotTreeId: string | undefined;
+	private snapshotTreeId: string | undefined;
 
-    constructor(
-        private readonly logger: ITelemetryLogger,
-        private readonly localSnapshot: Uint8Array | string,
-    ) {
-        super();
-    }
+	constructor(
+		private readonly logger: ITelemetryLoggerExt,
+		private readonly localSnapshot: Uint8Array | string,
+	) {
+		super(loggerToMonitoringContext(logger).config);
+	}
 
-    private calledGetVersions = false;
+	private calledGetVersions = false;
 
-    public async getVersions(blobid: string | null, count: number, _scenarioName?: string): Promise<api.IVersion[]> {
-        assert(blobid === null, 0x342 /* Invalid usage. "blobid" should always be null */);
-        assert(count === 1, 0x343 /* Invalid usage. "count" should always be 1 */);
+	public async getVersions(
+		// eslint-disable-next-line @rushstack/no-new-null
+		blobid: string | null,
+		count: number,
+		_scenarioName?: string,
+	): Promise<api.IVersion[]> {
+		assert(blobid === null, 0x342 /* Invalid usage. "blobid" should always be null */);
+		assert(count === 1, 0x343 /* Invalid usage. "count" should always be 1 */);
 
-        // No reason to re-parse the data since it will never change
-        if (this.calledGetVersions) {
-            return this.getSnapshotVersion();
-        }
-        this.calledGetVersions = true;
+		// No reason to re-parse the data since it will never change
+		if (this.calledGetVersions) {
+			return this.getSnapshotVersion();
+		}
+		this.calledGetVersions = true;
 
-        let snapshotContents: ISnapshotContents;
+		let snapshotContents: ISnapshotContents;
 
-        if (typeof this.localSnapshot === "string") {
-            const content: IOdspSnapshot = JSON.parse(this.localSnapshot);
-            snapshotContents = convertOdspSnapshotToSnapshotTreeAndBlobs(content);
-        } else {
-            snapshotContents = parseCompactSnapshotResponse(
-                new ReadBuffer(this.localSnapshot));
-        }
+		if (typeof this.localSnapshot === "string") {
+			const content: IOdspSnapshot = JSON.parse(this.localSnapshot);
+			snapshotContents = convertOdspSnapshotToSnapshotTreeAndBlobs(content);
+		} else {
+			snapshotContents = parseCompactSnapshotResponse(this.localSnapshot, this.logger);
+		}
 
-        this.snapshotTreeId = this.initializeFromSnapshot(snapshotContents);
-        return this.getSnapshotVersion();
-    }
+		this.snapshotTreeId = this.initializeFromSnapshot(snapshotContents);
+		return this.getSnapshotVersion();
+	}
 
-    private getSnapshotVersion(): api.IVersion[] {
-        return this.snapshotTreeId ? [{ id: this.snapshotTreeId, treeId: undefined! }] : [];
-    }
+	private getSnapshotVersion(): api.IVersion[] {
+		return this.snapshotTreeId ? [{ id: this.snapshotTreeId, treeId: undefined! }] : [];
+	}
 
-    protected fetchTreeFromSnapshot(_id: string, _scenarioName?: string): never {
-        this.throwUsageError("fetchTreeFromSnapshot");
-    }
+	protected fetchTreeFromSnapshot(_id: string, _scenarioName?: string): never {
+		this.throwUsageError("fetchTreeFromSnapshot");
+	}
 
-    protected fetchBlobFromStorage(_blobId: string, _evicted: boolean): never {
-        this.throwUsageError("fetchBlobFromStorage");
-    }
+	protected fetchBlobFromStorage(_blobId: string, _evicted: boolean): never {
+		this.throwUsageError("fetchBlobFromStorage");
+	}
 
-    public uploadSummaryWithContext(_summary: api.ISummaryTree, _context: ISummaryContext): never {
-        this.throwUsageError("uploadSummaryWithContext");
-    }
+	public uploadSummaryWithContext(_summary: api.ISummaryTree, _context: ISummaryContext): never {
+		this.throwUsageError("uploadSummaryWithContext");
+	}
 
-    public createBlob(_file: ArrayBufferLike): never {
-        this.throwUsageError("createBlob");
-    }
+	public createBlob(_file: ArrayBufferLike): never {
+		this.throwUsageError("createBlob");
+	}
 
-    private throwUsageError(methodName: string): never {
-        const toThrow = new UsageError(`"${methodName}" is not supported by LocalOdspDocumentStorageService`);
-        this.logger.sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
-        throw toThrow;
-    }
+	private throwUsageError(methodName: string): never {
+		const toThrow = new UsageError(
+			`"${methodName}" is not supported by LocalOdspDocumentStorageService`,
+		);
+		this.logger.sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
+		throw toThrow;
+	}
 }

package/src/odspCache.ts

@@ -2,22 +2,26 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { PromiseCache } from "@fluidframework/common-utils";
+import { PromiseCache } from "@fluidframework/core-utils";
 import {
-    IOdspResolvedUrl,
-    IFileEntry,
-    IEntry,
-    IPersistedCache,
-    ICacheEntry,
+	IOdspResolvedUrl,
+	IFileEntry,
+	IEntry,
+	IPersistedCache,
+	ICacheEntry,
+	ISocketStorageDiscovery,
+	getKeyForCacheEntry,
 } from "@fluidframework/odsp-driver-definitions";
-import { ISocketStorageDiscovery } from "./contracts";
+import { ISnapshotContents } from "./odspPublicUtils";
+
 /**
  * Similar to IPersistedCache, but exposes cache interface for single file
+ * @alpha
  */
 export interface IPersistedFileCache {
-    get(entry: IEntry): Promise<any>;
-    put(entry: IEntry, value: any): Promise<void>;
-    removeEntries(): Promise<void>;
+	get(entry: IEntry): Promise<any>;
+	put(entry: IEntry, value: any): Promise<void>;
+	removeEntries(): Promise<void>;
 }
 
 /**
@@ -25,102 +29,120 @@ export interface IPersistedFileCache {
  * used if no persisted cache is provided by the host
  */
 export class LocalPersistentCache implements IPersistedCache {
-    private readonly cache = new Map<string, any>();
-    // For every document id there will be a single expiration entry inspite of the number of cache entries.
-    private readonly docIdExpirationMap = new Map<string, ReturnType<typeof setTimeout>>();
-
-    public constructor(private readonly snapshotExpiryPolicy = 3600 * 1000) { }
-
-    async get(entry: ICacheEntry): Promise<any> {
-        const key = this.keyFromEntry(entry);
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return this.cache.get(key);
-    }
-
-    async put(entry: ICacheEntry, value: any) {
-        const key = this.keyFromEntry(entry);
-        this.cache.set(key, value);
-        this.updateExpirationEntry(entry.file.docId);
-    }
-
-    async removeEntries(file: IFileEntry): Promise<void> {
-        this.removeDocIdEntriesFromCache(file.docId);
-    }
-
-    private removeDocIdEntriesFromCache(docId: string) {
-        this.removeExpirationEntry(docId);
-        return Array.from(this.cache)
-            .filter(([cachekey]) => {
-                const docIdFromKey = cachekey.split("_");
-                if (docIdFromKey[0] === docId) {
-                    return true;
-                }
-            })
-            .map(([cachekey]) => {
-                this.cache.delete(cachekey);
-            });
-    }
-
-    private removeExpirationEntry(docId: string) {
-        const timeout = this.docIdExpirationMap.get(docId);
-        if (timeout !== undefined) {
-            clearTimeout(timeout);
-            this.docIdExpirationMap.delete(docId);
-        }
-    }
-
-    private updateExpirationEntry(docId: string) {
-        this.removeExpirationEntry(docId);
-        this.docIdExpirationMap.set(
-            docId,
-            setTimeout(
-                () => {
-                    this.removeDocIdEntriesFromCache(docId);
-                },
-                this.snapshotExpiryPolicy,
-            ),
-        );
-    }
-
-    private keyFromEntry(entry: ICacheEntry): string {
-        return `${entry.file.docId}_${entry.type}_${entry.key}`;
-    }
+	private readonly cache = new Map<string, any>();
+	// For every document id there will be a single expiration entry inspite of the number of cache entries.
+	private readonly docIdExpirationMap = new Map<string, ReturnType<typeof setTimeout>>();
+
+	public constructor(private readonly snapshotExpiryPolicy = 3600 * 1000) {}
+
+	async get(entry: ICacheEntry): Promise<any> {
+		const key = getKeyForCacheEntry(entry);
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+		return this.cache.get(key);
+	}
+
+	async put(entry: ICacheEntry, value: any) {
+		const key = getKeyForCacheEntry(entry);
+		this.cache.set(key, value);
+		this.updateExpirationEntry(entry.file.docId);
+	}
+
+	async removeEntries(file: IFileEntry): Promise<void> {
+		this.removeDocIdEntriesFromCache(file.docId);
+	}
+
+	private removeDocIdEntriesFromCache(docId: string) {
+		this.removeExpirationEntry(docId);
+		return Array.from(this.cache)
+			.filter(([cachekey]) => {
+				const docIdFromKey = cachekey.split("_");
+				if (docIdFromKey[0] === docId) {
+					return true;
+				}
+			})
+			.map(([cachekey]) => {
+				this.cache.delete(cachekey);
+			});
+	}
+
+	private removeExpirationEntry(docId: string) {
+		const timeout = this.docIdExpirationMap.get(docId);
+		if (timeout !== undefined) {
+			clearTimeout(timeout);
+			this.docIdExpirationMap.delete(docId);
+		}
+	}
+
+	private updateExpirationEntry(docId: string) {
+		this.removeExpirationEntry(docId);
+		this.docIdExpirationMap.set(
+			docId,
+			setTimeout(() => {
+				this.removeDocIdEntriesFromCache(docId);
+			}, this.snapshotExpiryPolicy),
+		);
+	}
 }
 export class PromiseCacheWithOneHourSlidingExpiry<T> extends PromiseCache<string, T> {
-    constructor(removeOnError?: (e: any) => boolean) {
-        super({ expiry: { policy: "sliding", durationMs: 3600000 }, removeOnError });
-    }
+	constructor(removeOnError?: (e: any) => boolean) {
+		super({ expiry: { policy: "sliding", durationMs: 3600000 }, removeOnError });
+	}
 }
 
 /**
  * Internal cache interface used within driver only
+ * @alpha
  */
 export interface INonPersistentCache {
-    /**
-     * Cache of joined/joining session info
-     */
-    readonly sessionJoinCache: PromiseCache<string,
-        { entryTime: number; joinSessionResponse: ISocketStorageDiscovery; }>;
-
-    /**
-     * Cache of resolved/resolving file URLs
-     */
-    readonly fileUrlCache: PromiseCache<string, IOdspResolvedUrl>;
+	/**
+	 * Cache of joined/joining session info
+	 */
+	readonly sessionJoinCache: PromiseCache<
+		string,
+		{ entryTime: number; joinSessionResponse: ISocketStorageDiscovery }
+	>;
+
+	/**
+	 * Cache of resolved/resolving file URLs
+	 */
+	readonly fileUrlCache: PromiseCache<string, IOdspResolvedUrl>;
+
+	/**
+	 * Used to store the snapshot fetch promise if the prefetch has been made using the prefetchLatestSnapshot api.
+	 * This is then used later to look for the promise during the container load.
+	 */
+	readonly snapshotPrefetchResultCache: PromiseCache<string, IPrefetchSnapshotContents>;
 }
 
 /**
  * Internal cache interface used within driver only
+ * @alpha
  */
 export interface IOdspCache extends INonPersistentCache {
-    /**
-     * Persisted cache - only serializable content is allowed
-     */
-    readonly persistedCache: IPersistedFileCache;
+	/**
+	 * Persisted cache - only serializable content is allowed
+	 */
+	readonly persistedCache: IPersistedFileCache;
 }
 
 export class NonPersistentCache implements INonPersistentCache {
-    public readonly sessionJoinCache =
-        new PromiseCache<string, { entryTime: number; joinSessionResponse: ISocketStorageDiscovery; }>();
+	public readonly sessionJoinCache = new PromiseCache<
+		string,
+		{ entryTime: number; joinSessionResponse: ISocketStorageDiscovery }
+	>();
 
-    public readonly fileUrlCache = new PromiseCache<string, IOdspResolvedUrl>();
+	public readonly fileUrlCache = new PromiseCache<string, IOdspResolvedUrl>();
+
+	public readonly snapshotPrefetchResultCache = new PromiseCache<
+		string,
+		IPrefetchSnapshotContents
+	>();
+}
+
+/**
+ * @alpha
+ */
+export interface IPrefetchSnapshotContents extends ISnapshotContents {
+	fluidEpoch: string;
+	prefetchStartTime: number;
 }