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

package/src/mapWithExpiration.ts

@@ -0,0 +1,124 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/core-utils";
+
+/**
+ * An extension of Map that expires (deletes) entries after a period of inactivity.
+ * The policy is based on the last time a key was written to.
+ */
+export class MapWithExpiration<TKey = any, TValue = any> extends Map<TKey, TValue> {
+	/** Timestamps (as epoch ms numbers) of when each key was last refreshed */
+	private readonly lastRefreshedTimes = new Map<TKey, number>();
+
+	constructor(private readonly expiryMs: number) {
+		super();
+	}
+
+	private refresh(key: TKey): void {
+		this.lastRefreshedTimes.set(key, new Date().valueOf());
+	}
+
+	/**
+	 * Returns true if the key is present and expired, false if it's not expired, and undefined if it's not found
+	 * If cleanUp is passed as true, then delete any expired entry before returning.
+	 */
+	private checkExpiry(key: TKey, cleanUp: boolean = false): boolean | undefined {
+		const refreshTime = this.lastRefreshedTimes.get(key);
+		assert(
+			(refreshTime !== undefined) === super.has(key),
+			0x50c /* freshness map out of sync */,
+		);
+
+		if (refreshTime === undefined) {
+			return undefined;
+		}
+		const expired = new Date().valueOf() - refreshTime >= this.expiryMs;
+		if (expired && cleanUp) {
+			this.delete(key);
+		}
+		return expired;
+	}
+
+	private clearExpiredEntries() {
+		// forEach clears out any expired entries
+		this.forEach(() => {});
+	}
+
+	get size(): number {
+		this.clearExpiredEntries();
+		return super.size;
+	}
+
+	has(key: TKey): boolean {
+		this.checkExpiry(key, true /* cleanUp */);
+		return super.has(key);
+	}
+
+	get(key: TKey): TValue | undefined {
+		this.checkExpiry(key, true /* cleanUp */);
+		return super.get(key);
+	}
+
+	set(key: TKey, value: TValue): this {
+		// Sliding window expiration policy (on write)
+		this.refresh(key);
+		return super.set(key, value);
+	}
+
+	delete(key: TKey): boolean {
+		this.lastRefreshedTimes.delete(key);
+		return super.delete(key);
+	}
+
+	clear(): void {
+		this.lastRefreshedTimes.clear();
+		super.clear();
+	}
+
+	forEach(
+		callbackfn: (value: TValue, key: TKey, map: Map<TKey, TValue>) => void,
+		thisArg?: any,
+	): void {
+		const expiredKeys: TKey[] = [];
+		super.forEach(
+			(v, k, m) => {
+				if (this.checkExpiry(k) === true) {
+					expiredKeys.push(k);
+				} else {
+					callbackfn.bind(thisArg)(v, k, m);
+				}
+			},
+			// Note we don't pass thisArg here, since we bind it directly to callbackFn and don't need it otherwise
+		);
+
+		// Clean up keys we know are expired now that we're done iterating
+		expiredKeys.forEach((key: TKey) => {
+			this.delete(key);
+		});
+	}
+
+	entries(): IterableIterator<[TKey, TValue]> {
+		this.clearExpiredEntries();
+		return super.entries();
+	}
+	keys(): IterableIterator<TKey> {
+		this.clearExpiredEntries();
+		return super.keys();
+	}
+	values(): IterableIterator<TValue> {
+		this.clearExpiredEntries();
+		return super.values();
+	}
+	[Symbol.iterator](): IterableIterator<[TKey, TValue]> {
+		this.clearExpiredEntries();
+		return super[Symbol.iterator]();
+	}
+
+	valueOf() {
+		this.clearExpiredEntries();
+		return super.valueOf();
+	}
+}

package/src/nullBlobStorageService.ts

@@ -11,30 +11,33 @@ import * as api from "@fluidframework/protocol-definitions";
  * Does not read/write anything.
  */
 export class NullBlobStorageService implements IDocumentStorageService {
-    public get repositoryUrl(): string {
-        throw new Error("Invalid operation");
-    }
+	public get repositoryUrl(): string {
+		throw new Error("Invalid operation");
+	}
 
-    public async getSnapshotTree(version?: api.IVersion): Promise<api.ISnapshotTree | null> {
-        return version ? Promise.reject(new Error("Invalid operation")) : null;
-    }
+	public async getSnapshotTree(version?: api.IVersion): Promise<api.ISnapshotTree | null> {
+		return version ? Promise.reject(new Error("Invalid operation")) : null;
+	}
 
-    public async getVersions(versionId: string | null, count: number): Promise<api.IVersion[]> {
-        return [];
-    }
+	public async getVersions(versionId: string | null, count: number): Promise<api.IVersion[]> {
+		return [];
+	}
 
-    public async uploadSummaryWithContext(summary: api.ISummaryTree, context: ISummaryContext): Promise<string> {
-        return Promise.reject(new Error("Invalid operation"));
-    }
+	public async uploadSummaryWithContext(
+		summary: api.ISummaryTree,
+		context: ISummaryContext,
+	): Promise<string> {
+		throw new Error("Invalid operation");
+	}
 
-    public async downloadSummary(handle: api.ISummaryHandle): Promise<api.ISummaryTree> {
-        return Promise.reject(new Error("Invalid operation"));
-    }
+	public async downloadSummary(handle: api.ISummaryHandle): Promise<api.ISummaryTree> {
+		throw new Error("Invalid operation");
+	}
 
-    public async createBlob(file: ArrayBufferLike): Promise<api.ICreateBlobResponse> {
-        return Promise.reject(new Error("Null blob storage can not create blob"));
-    }
-    public async readBlob(blobId: string): Promise<ArrayBufferLike> {
-        return Promise.reject(new Error("Null blob storage can not read blob"));
-    }
+	public async createBlob(file: ArrayBufferLike): Promise<api.ICreateBlobResponse> {
+		throw new Error("Null blob storage can not create blob");
+	}
+	public async readBlob(blobId: string): Promise<ArrayBufferLike> {
+		throw new Error("Null blob storage can not read blob");
+	}
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/routerlicious-driver";
-export const pkgVersion = "1.4.0-115997";
+export const pkgVersion = "2.0.0-dev-rc.1.0.0.224419";

package/src/policies.ts

@@ -3,43 +3,56 @@
  * Licensed under the MIT License.
  */
 
+/**
+ * @internal
+ */
 export interface IRouterliciousDriverPolicies {
-    /**
-     * Enable prefetching entire snapshot tree into memory before it is loaded by the runtime.
-     * Default: true
-     */
-    enablePrefetch: boolean;
-    /**
-     * Rate limit concurrent storage requests.
-     * Default: 100
-     */
-    maxConcurrentStorageRequests: number;
-    /**
-     * Rate limit concurrent orderer requests.
-     * Default: 100
-     */
-    maxConcurrentOrdererRequests: number;
-    /**
-     * Give hosts the option to change blob aggregation behavior to suit their needs.
-     * Larger number means fewer blob individual requests, but less blob-deduping.
-     * Smaller number means more blob individual requests, but more blob-deduping.
-     * Setting to `undefined` disables blob aggregration.
-     * Default: undefined
-     */
-    aggregateBlobsSmallerThanBytes: number | undefined;
-    /**
-     * Enable uploading entire summary tree as a IWholeSummaryPayload to storage.
-     * Default: false
-     */
-    enableWholeSummaryUpload: boolean;
-    /**
-     * Enable service endpoint discovery when creating or joining a session.
-     * Default: false
-     */
-    enableDiscovery?: boolean;
-    /**
-     * Enable using RestLess which avoids CORS preflight requests.
-     * Default: true
-     */
-    enableRestLess: boolean;
+	/**
+	 * Enable prefetching entire snapshot tree into memory before it is loaded by the runtime.
+	 * Default: true
+	 */
+	enablePrefetch: boolean;
+	/**
+	 * Rate limit concurrent storage requests.
+	 * Default: 100
+	 */
+	maxConcurrentStorageRequests: number;
+	/**
+	 * Rate limit concurrent orderer requests.
+	 * Default: 100
+	 */
+	maxConcurrentOrdererRequests: number;
+	/**
+	 * Enable uploading entire summary tree as a IWholeSummaryPayload to storage.
+	 * Default: false
+	 */
+	enableWholeSummaryUpload: boolean;
+	/**
+	 * Enable service endpoint discovery when creating or joining a session.
+	 * Default: false
+	 */
+	enableDiscovery: boolean;
+	/**
+	 * Enable using RestLess which avoids CORS preflight requests.
+	 * Default: true
+	 */
+	enableRestLess: boolean;
+	/**
+	 * Enable internal cache of summaries/snapshots.
+	 * Reduces Summarizer boot time and reduces server load in E2E tests.
+	 * Default: true
+	 */
+	enableInternalSummaryCaching: boolean;
+	/**
+	 * Enable downgrading socket connection to long-polling
+	 * when websocket connection cannot be established.
+	 * Default: true
+	 */
+	enableLongPollingDowngrade: boolean;
+	/**
+	 * Indicates that the container is ephemeral.
+	 * Artifacts relates to the container are limited to container lifetime.
+	 * Default: false
+	 */
+	isEphemeralContainer: boolean;
 }

package/src/r11sSnapshotParser.ts

@@ -0,0 +1,82 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ISnapshotTree } from "@fluidframework/protocol-definitions";
+import { stringToBuffer } from "@fluid-internal/client-utils";
+import { INormalizedWholeSnapshot, IWholeFlatSnapshot, IWholeFlatSnapshotTree } from "./contracts";
+
+/**
+ * Build a tree hierarchy from a flat tree.
+ *
+ * @param flatTree - a flat tree
+ * @param treePrefixToRemove - tree prefix to strip
+ * @returns the heirarchical tree
+ */
+function buildHierarchy(
+	flatTree: IWholeFlatSnapshotTree,
+	treePrefixToRemove: string,
+): ISnapshotTree {
+	const lookup: { [path: string]: ISnapshotTree } = {};
+	// Root tree id will be used to determine which version was downloaded.
+	const root: ISnapshotTree = { id: flatTree.id, blobs: {}, trees: {} };
+	lookup[""] = root;
+
+	for (const entry of flatTree.entries) {
+		// Strip the `treePrefixToRemove` path from tree entries such that they are stored under root.
+		const entryPath = entry.path.replace(new RegExp(`^${treePrefixToRemove}/`), "");
+		const lastIndex = entryPath.lastIndexOf("/");
+		const entryPathDir = entryPath.slice(0, Math.max(0, lastIndex));
+		const entryPathBase = entryPath.slice(lastIndex + 1);
+
+		// The flat output is breadth-first so we can assume we see tree nodes prior to their contents
+		const node = lookup[entryPathDir];
+
+		// Add in either the blob or tree
+		if (entry.type === "tree") {
+			const newTree: ISnapshotTree = {
+				blobs: {},
+				trees: {},
+				unreferenced: entry.unreferenced,
+			};
+			node.trees[decodeURIComponent(entryPathBase)] = newTree;
+			lookup[entryPath] = newTree;
+		} else if (entry.type === "blob") {
+			node.blobs[decodeURIComponent(entryPathBase)] = entry.id;
+		} else {
+			throw new Error(`Unknown entry type!!`);
+		}
+	}
+
+	return root;
+}
+
+/**
+ * Converts existing IWholeFlatSnapshot to snapshot tree, blob array, and sequence number.
+ *
+ * @param flatSnapshot - flat snapshot
+ * @param treePrefixToRemove - tree prefix to strip. By default we are stripping ".app" prefix
+ * @returns snapshot tree, blob array, and sequence number
+ */
+export function convertWholeFlatSnapshotToSnapshotTreeAndBlobs(
+	flatSnapshot: IWholeFlatSnapshot,
+	treePrefixToRemove: string = ".app",
+): INormalizedWholeSnapshot {
+	const blobs = new Map<string, ArrayBuffer>();
+	if (flatSnapshot.blobs) {
+		flatSnapshot.blobs.forEach((blob) => {
+			blobs.set(blob.id, stringToBuffer(blob.content, blob.encoding ?? "utf-8"));
+		});
+	}
+	const flatSnapshotTree = flatSnapshot.trees?.[0];
+	const sequenceNumber = flatSnapshotTree?.sequenceNumber;
+	const snapshotTree = buildHierarchy(flatSnapshotTree, treePrefixToRemove);
+
+	return {
+		blobs,
+		snapshotTree,
+		sequenceNumber,
+		id: flatSnapshot.id,
+	};
+}