@fluidframework/container-loader 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.225277

package/src/retriableDocumentStorageService.ts

@@ -3,117 +3,157 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/common-utils";
-import { GenericError } from "@fluidframework/container-utils";
+import { assert } from "@fluidframework/core-utils";
 import {
-    IDocumentStorageService,
-    IDocumentStorageServicePolicies,
-    ISummaryContext,
+	FetchSource,
+	IDocumentStorageService,
+	IDocumentStorageServicePolicies,
+	ISummaryContext,
 } from "@fluidframework/driver-definitions";
 import {
-    ICreateBlobResponse,
-    ISnapshotTree,
-    ISummaryHandle,
-    ISummaryTree,
-    IVersion,
+	ICreateBlobResponse,
+	ISnapshotTree,
+	ISummaryHandle,
+	ISummaryTree,
+	IVersion,
 } from "@fluidframework/protocol-definitions";
-import { IDisposable, ITelemetryLogger } from "@fluidframework/common-definitions";
+import { IDisposable } from "@fluidframework/core-interfaces";
+import { GenericError, ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import { runWithRetry } from "@fluidframework/driver-utils";
 
 export class RetriableDocumentStorageService implements IDocumentStorageService, IDisposable {
-    private _disposed = false;
-    constructor(
-        private readonly internalStorageService: IDocumentStorageService,
-        private readonly logger: ITelemetryLogger,
-    ) {
-    }
+	private _disposed = false;
+	private internalStorageService: IDocumentStorageService | undefined;
+	constructor(
+		private readonly internalStorageServiceP: Promise<IDocumentStorageService>,
+		private readonly logger: ITelemetryLoggerExt,
+	) {
+		this.internalStorageServiceP.then((s) => (this.internalStorageService = s)).catch(() => {});
+	}
 
-    public get policies(): IDocumentStorageServicePolicies | undefined {
-        return this.internalStorageService.policies;
-    }
-    public get disposed() { return this._disposed; }
-    public dispose() {
-        this._disposed = true;
-    }
+	public get policies(): IDocumentStorageServicePolicies | undefined {
+		if (this.internalStorageService) {
+			return this.internalStorageService.policies;
+		}
+		throw new Error("storage service not yet instantiated");
+	}
+	public get disposed() {
+		return this._disposed;
+	}
+	public dispose() {
+		this._disposed = true;
+	}
 
-    public get repositoryUrl(): string {
-        return this.internalStorageService.repositoryUrl;
-    }
+	public get repositoryUrl(): string {
+		if (this.internalStorageService) {
+			return this.internalStorageService.repositoryUrl;
+		}
+		throw new Error("storage service not yet instantiated");
+	}
 
-    public async getSnapshotTree(version?: IVersion, scenarioName?: string): Promise<ISnapshotTree | null> {
-        return this.runWithRetry(
-            async () => this.internalStorageService.getSnapshotTree(version, scenarioName),
-            "storage_getSnapshotTree",
-        );
-    }
+	public async getSnapshotTree(
+		version?: IVersion,
+		scenarioName?: string,
+	): Promise<ISnapshotTree | null> {
+		return this.runWithRetry(
+			async () =>
+				this.internalStorageServiceP.then(async (s) =>
+					s.getSnapshotTree(version, scenarioName),
+				),
+			"storage_getSnapshotTree",
+		);
+	}
 
-    public async readBlob(id: string): Promise<ArrayBufferLike> {
-        return this.runWithRetry(
-            async () => this.internalStorageService.readBlob(id),
-            "storage_readBlob",
-        );
-    }
+	public async readBlob(id: string): Promise<ArrayBufferLike> {
+		return this.runWithRetry(
+			async () => this.internalStorageServiceP.then(async (s) => s.readBlob(id)),
+			"storage_readBlob",
+		);
+	}
 
-    public async getVersions(versionId: string | null, count: number, scenarioName?: string): Promise<IVersion[]> {
-        return this.runWithRetry(
-            async () => this.internalStorageService.getVersions(versionId, count, scenarioName),
-            "storage_getVersions",
-        );
-    }
+	public async getVersions(
+		versionId: string | null,
+		count: number,
+		scenarioName?: string,
+		fetchSource?: FetchSource,
+	): Promise<IVersion[]> {
+		return this.runWithRetry(
+			async () =>
+				this.internalStorageServiceP.then(async (s) =>
+					s.getVersions(versionId, count, scenarioName, fetchSource),
+				),
+			"storage_getVersions",
+		);
+	}
 
-    public async uploadSummaryWithContext(summary: ISummaryTree, context: ISummaryContext): Promise<string> {
-        // Not using retry loop here. Couple reasons:
-        // 1. If client lost connectivity, then retry loop will result in uploading stale summary
-        //    by stale summarizer after connectivity comes back. It will cause failures for this client and for
-        //    real (new) summarizer. This problem in particular should be solved in future by supplying abort handle
-        //    on all APIs and caller (ContainerRuntime.submitSummary) aborting call on loss of connectivity
-        // 2. Similar, if we get 429 with retryAfter = 10 minutes, it's likely not the right call to retry summary
-        //    upload in 10 minutes - it's better to keep processing ops and retry later. Though caller needs to take
-        //    retryAfter into account!
-        // But retry loop is required for creation flow (Container.attach)
-        assert((context.referenceSequenceNumber === 0) === (context.ackHandle === undefined),
-            0x251 /* "creation summary has to have seq=0 && handle === undefined" */);
-        if (context.referenceSequenceNumber !== 0) {
-            return this.internalStorageService.uploadSummaryWithContext(summary, context);
-        }
+	public async uploadSummaryWithContext(
+		summary: ISummaryTree,
+		context: ISummaryContext,
+	): Promise<string> {
+		// Not using retry loop here. Couple reasons:
+		// 1. If client lost connectivity, then retry loop will result in uploading stale summary
+		//    by stale summarizer after connectivity comes back. It will cause failures for this client and for
+		//    real (new) summarizer. This problem in particular should be solved in future by supplying abort handle
+		//    on all APIs and caller (ContainerRuntime.submitSummary) aborting call on loss of connectivity
+		// 2. Similar, if we get 429 with retryAfter = 10 minutes, it's likely not the right call to retry summary
+		//    upload in 10 minutes - it's better to keep processing ops and retry later. Though caller needs to take
+		//    retryAfter into account!
+		// But retry loop is required for creation flow (Container.attach)
+		assert(
+			(context.referenceSequenceNumber === 0) === (context.ackHandle === undefined),
+			0x251 /* "creation summary has to have seq=0 && handle === undefined" */,
+		);
+		if (context.referenceSequenceNumber !== 0) {
+			return this.internalStorageServiceP.then(async (s) =>
+				s.uploadSummaryWithContext(summary, context),
+			);
+		}
 
-        // Creation flow with attachment blobs - need to do retries!
-        return this.runWithRetry(
-            async () => this.internalStorageService.uploadSummaryWithContext(summary, context),
-            "storage_uploadSummaryWithContext",
-        );
-    }
+		// Creation flow with attachment blobs - need to do retries!
+		return this.runWithRetry(
+			async () =>
+				this.internalStorageServiceP.then(async (s) =>
+					s.uploadSummaryWithContext(summary, context),
+				),
+			"storage_uploadSummaryWithContext",
+		);
+	}
 
-    public async downloadSummary(handle: ISummaryHandle): Promise<ISummaryTree> {
-        return this.runWithRetry(
-            async () => this.internalStorageService.downloadSummary(handle),
-            "storage_downloadSummary",
-        );
-    }
+	public async downloadSummary(handle: ISummaryHandle): Promise<ISummaryTree> {
+		return this.runWithRetry(
+			async () => this.internalStorageServiceP.then(async (s) => s.downloadSummary(handle)),
+			"storage_downloadSummary",
+		);
+	}
 
-    public async createBlob(file: ArrayBufferLike): Promise<ICreateBlobResponse> {
-        return this.runWithRetry(
-            async () => this.internalStorageService.createBlob(file),
-            "storage_createBlob",
-        );
-    }
+	public async createBlob(file: ArrayBufferLike): Promise<ICreateBlobResponse> {
+		return this.runWithRetry(
+			async () => this.internalStorageServiceP.then(async (s) => s.createBlob(file)),
+			"storage_createBlob",
+		);
+	}
 
-    private checkStorageDisposed() {
-        if (this._disposed) {
-            // pre-0.58 error message: storageServiceDisposedCannotRetry
-            throw new GenericError("Storage Service is disposed. Cannot retry", { canRetry: false });
-        }
-        return undefined;
-    }
+	private checkStorageDisposed(callName: string, error: unknown) {
+		if (this._disposed) {
+			this.logger.sendTelemetryEvent(
+				{
+					eventName: `${callName}_abortedStorageDisposed`,
+					fetchCallName: callName, // fetchCallName matches logs in runWithRetry.ts
+				},
+				error,
+			);
+			// pre-0.58 error message: storageServiceDisposedCannotRetry
+			throw new GenericError("Storage Service is disposed. Cannot retry", {
+				canRetry: false,
+			});
+		}
+		return;
+	}
 
-    private async runWithRetry<T>(api: () => Promise<T>, callName: string): Promise<T> {
-        return runWithRetry(
-            api,
-            callName,
-            this.logger,
-            {
-                onRetry: () => this.checkStorageDisposed(),
-            },
-        );
-    }
+	private async runWithRetry<T>(api: () => Promise<T>, callName: string): Promise<T> {
+		return runWithRetry(api, callName, this.logger, {
+			onRetry: (_delayInMs: number, error: unknown) =>
+				this.checkStorageDisposed(callName, error),
+		});
+	}
 }

package/src/utils.ts

@@ -5,45 +5,99 @@
 
 import { parse } from "url";
 import { v4 as uuid } from "uuid";
-import {
-    assert,
-    stringToBuffer,
-    Uint8ArrayToArrayBuffer,
-    unreachableCase,
-} from "@fluidframework/common-utils";
+import { stringToBuffer, Uint8ArrayToArrayBuffer } from "@fluid-internal/client-utils";
+import { assert, unreachableCase } from "@fluidframework/core-utils";
 import { ISummaryTree, ISnapshotTree, SummaryType } from "@fluidframework/protocol-definitions";
 import { LoggingError } from "@fluidframework/telemetry-utils";
+import {
+	CombinedAppAndProtocolSummary,
+	DeltaStreamConnectionForbiddenError,
+	isCombinedAppAndProtocolSummary,
+} from "@fluidframework/driver-utils";
+import { DriverErrorTypes } from "@fluidframework/driver-definitions";
 
 // This is used when we rehydrate a container from the snapshot. Here we put the blob contents
 // in separate property: blobContents.
 export interface ISnapshotTreeWithBlobContents extends ISnapshotTree {
-    blobsContents: { [path: string]: ArrayBufferLike; };
-    trees: { [path: string]: ISnapshotTreeWithBlobContents; };
+	blobsContents: { [path: string]: ArrayBufferLike };
+	trees: { [path: string]: ISnapshotTreeWithBlobContents };
 }
 
+/**
+ * Interface to represent the parsed parts of IResolvedUrl.url to help
+ * in getting info about different parts of the url.
+ * May not be compatible or relevant for any Url Resolver
+ * @internal
+ */
 export interface IParsedUrl {
-    id: string;
-    path: string;
-    query: string;
-    /**
-     * Null means do not use snapshots, undefined means load latest snapshot
-     * otherwise it's version ID passed to IDocumentStorageService.getVersions() to figure out what snapshot to use.
-     * If needed, can add undefined which is treated by Container.load() as load latest snapshot.
-     */
-    version: string | null | undefined;
+	/**
+	 * It is combination of tenantid/docId part of the url.
+	 */
+	id: string;
+	/**
+	 * It is the deep link path in the url.
+	 */
+	path: string;
+	/**
+	 * Query string part of the url.
+	 */
+	query: string;
+	/**
+	 * Null means do not use snapshots, undefined means load latest snapshot
+	 * otherwise it's version ID passed to IDocumentStorageService.getVersions() to figure out what snapshot to use.
+	 * If needed, can add undefined which is treated by Container.load() as load latest snapshot.
+	 */
+	version: string | null | undefined;
+}
+
+/**
+ * Utility api to parse the IResolvedUrl.url into specific parts like querystring, path to get
+ * deep link info etc.
+ * Warning - This function may not be compatible with any Url Resolver's resolved url. It works
+ * with urls of type: protocol://<string>/.../..?<querystring>
+ * @param url - This is the IResolvedUrl.url part of the resolved url.
+ * @returns The IParsedUrl representing the input URL, or undefined if the format was not supported
+ * @internal
+ */
+export function tryParseCompatibleResolvedUrl(url: string): IParsedUrl | undefined {
+	const parsed = parse(url, true);
+	if (typeof parsed.pathname !== "string") {
+		throw new LoggingError("Failed to parse pathname");
+	}
+	const query = parsed.search ?? "";
+	const regex = /^\/([^/]*\/[^/]*)(\/?.*)$/;
+	const match = regex.exec(parsed.pathname);
+	return match?.length === 3
+		? { id: match[1], path: match[2], query, version: parsed.query.version as string }
+		: undefined;
 }
 
-export function parseUrl(url: string): IParsedUrl | undefined {
-    const parsed = parse(url, true);
-    if (typeof parsed.pathname !== "string") {
-        throw new LoggingError("Failed to parse pathname");
-    }
-    const query = parsed.search ?? "";
-    const regex = /^\/([^/]*\/[^/]*)(\/?.*)$/;
-    const match = regex.exec(parsed.pathname);
-    return (match?.length === 3)
-        ? { id: match[1], path: match[2], query, version: parsed.query.version as string }
-        : undefined;
+/**
+ * Combine the app summary and protocol summary in 1 tree.
+ * @param appSummary - Summary of the app.
+ * @param protocolSummary - Summary of the protocol.
+ * @internal
+ */
+export function combineAppAndProtocolSummary(
+	appSummary: ISummaryTree,
+	protocolSummary: ISummaryTree,
+): CombinedAppAndProtocolSummary {
+	assert(
+		!isCombinedAppAndProtocolSummary(appSummary),
+		0x5a8 /* app summary is already a combined tree! */,
+	);
+	assert(
+		!isCombinedAppAndProtocolSummary(protocolSummary),
+		0x5a9 /* protocol summary is already a combined tree! */,
+	);
+	const createNewSummary: CombinedAppAndProtocolSummary = {
+		type: SummaryType.Tree,
+		tree: {
+			".protocol": protocolSummary,
+			".app": appSummary,
+		},
+	};
+	return createNewSummary;
 }
 
 /**
@@ -57,44 +111,49 @@ export function parseUrl(url: string): IParsedUrl | undefined {
  * @param summary - summary to convert
  */
 function convertSummaryToSnapshotWithEmbeddedBlobContents(
-    summary: ISummaryTree,
+	summary: ISummaryTree,
 ): ISnapshotTreeWithBlobContents {
-    const treeNode: ISnapshotTreeWithBlobContents = {
-        blobs: {},
-        blobsContents: {},
-        trees: {},
-        id: uuid(),
-        unreferenced: summary.unreferenced,
-    };
-    const keys = Object.keys(summary.tree);
-    for (const key of keys) {
-        const summaryObject = summary.tree[key];
+	const treeNode: ISnapshotTreeWithBlobContents = {
+		blobs: {},
+		blobsContents: {},
+		trees: {},
+		id: uuid(),
+		unreferenced: summary.unreferenced,
+	};
+	const keys = Object.keys(summary.tree);
+	for (const key of keys) {
+		const summaryObject = summary.tree[key];
 
-        switch (summaryObject.type) {
-            case SummaryType.Tree: {
-                treeNode.trees[key] = convertSummaryToSnapshotWithEmbeddedBlobContents(summaryObject);
-                break;
-            }
-            case SummaryType.Attachment:
-                treeNode.blobs[key] = summaryObject.id;
-                break;
-            case SummaryType.Blob: {
-                const blobId = uuid();
-                treeNode.blobs[key] = blobId;
-                const contentBuffer = typeof summaryObject.content === "string" ?
-                    stringToBuffer(summaryObject.content, "utf8") : Uint8ArrayToArrayBuffer(summaryObject.content);
-                treeNode.blobsContents[blobId] = contentBuffer;
-                break;
-            }
-            case SummaryType.Handle:
-                throw new LoggingError("No handles should be there in summary in detached container!!");
-                break;
-            default: {
-                unreachableCase(summaryObject, `Unknown tree type ${(summaryObject as any).type}`);
-            }
-        }
-    }
-    return treeNode;
+		switch (summaryObject.type) {
+			case SummaryType.Tree: {
+				treeNode.trees[key] =
+					convertSummaryToSnapshotWithEmbeddedBlobContents(summaryObject);
+				break;
+			}
+			case SummaryType.Attachment:
+				treeNode.blobs[key] = summaryObject.id;
+				break;
+			case SummaryType.Blob: {
+				const blobId = uuid();
+				treeNode.blobs[key] = blobId;
+				const contentBuffer =
+					typeof summaryObject.content === "string"
+						? stringToBuffer(summaryObject.content, "utf8")
+						: Uint8ArrayToArrayBuffer(summaryObject.content);
+				treeNode.blobsContents[blobId] = contentBuffer;
+				break;
+			}
+			case SummaryType.Handle:
+				throw new LoggingError(
+					"No handles should be there in summary in detached container!!",
+				);
+				break;
+			default: {
+				unreachableCase(summaryObject, `Unknown tree type ${(summaryObject as any).type}`);
+			}
+		}
+	}
+	return treeNode;
 }
 
 /**
@@ -103,35 +162,49 @@ function convertSummaryToSnapshotWithEmbeddedBlobContents(
  * @param appSummaryTree - App Summary Tree
  */
 export function convertProtocolAndAppSummaryToSnapshotTree(
-    protocolSummaryTree: ISummaryTree,
-    appSummaryTree: ISummaryTree,
+	protocolSummaryTree: ISummaryTree,
+	appSummaryTree: ISummaryTree,
 ): ISnapshotTreeWithBlobContents {
-    // Shallow copy is fine, since we are doing a deep clone below.
-    const combinedSummary: ISummaryTree = {
-        type: SummaryType.Tree,
-        tree: { ...appSummaryTree.tree },
-    };
+	// Shallow copy is fine, since we are doing a deep clone below.
+	const combinedSummary: ISummaryTree = {
+		type: SummaryType.Tree,
+		tree: { ...appSummaryTree.tree },
+	};
 
-    combinedSummary.tree[".protocol"] = protocolSummaryTree;
-    const snapshotTreeWithBlobContents =
-        convertSummaryToSnapshotWithEmbeddedBlobContents(combinedSummary);
-    return snapshotTreeWithBlobContents;
+	combinedSummary.tree[".protocol"] = protocolSummaryTree;
+	const snapshotTreeWithBlobContents =
+		convertSummaryToSnapshotWithEmbeddedBlobContents(combinedSummary);
+	return snapshotTreeWithBlobContents;
 }
 
 // This function converts the snapshot taken in detached container(by serialize api) to snapshotTree with which
 // a detached container can be rehydrated.
-export const getSnapshotTreeFromSerializedContainer = (detachedContainerSnapshot: ISummaryTree) => {
-    const protocolSummaryTree = detachedContainerSnapshot.tree[".protocol"] as ISummaryTree;
-    const appSummaryTree = detachedContainerSnapshot.tree[".app"] as ISummaryTree;
-    assert(protocolSummaryTree !== undefined && appSummaryTree !== undefined,
-        0x1e0 /* "Protocol and App summary trees should be present" */);
-    const snapshotTreeWithBlobContents = convertProtocolAndAppSummaryToSnapshotTree(
-        protocolSummaryTree,
-        appSummaryTree,
-    );
-    return snapshotTreeWithBlobContents;
+export const getSnapshotTreeFromSerializedContainer = (
+	detachedContainerSnapshot: ISummaryTree,
+): ISnapshotTreeWithBlobContents => {
+	assert(
+		isCombinedAppAndProtocolSummary(detachedContainerSnapshot),
+		0x1e0 /* "Protocol and App summary trees should be present" */,
+	);
+	const protocolSummaryTree = detachedContainerSnapshot.tree[".protocol"];
+	const appSummaryTree = detachedContainerSnapshot.tree[".app"];
+	const snapshotTreeWithBlobContents = convertProtocolAndAppSummaryToSnapshotTree(
+		protocolSummaryTree,
+		appSummaryTree,
+	);
+	return snapshotTreeWithBlobContents;
 };
 
 export function getProtocolSnapshotTree(snapshot: ISnapshotTree): ISnapshotTree {
-    return ".protocol" in snapshot.trees ? snapshot.trees[".protocol"] : snapshot;
+	return ".protocol" in snapshot.trees ? snapshot.trees[".protocol"] : snapshot;
+}
+
+export function isDeltaStreamConnectionForbiddenError(
+	error: any,
+): error is DeltaStreamConnectionForbiddenError {
+	return (
+		typeof error === "object" &&
+		error !== null &&
+		error?.errorType === DriverErrorTypes.deltaStreamConnectionForbidden
+	);
 }

package/tsc-multi.test.json

@@ -0,0 +1,4 @@
+{
+	"targets": [{ "extname": ".cjs", "module": "CommonJS", "moduleResolution": "Node10" }],
+	"projects": ["./tsconfig.json", "./src/test/tsconfig.json"]
+}

package/tsconfig.json

@@ -1,14 +1,12 @@
 {
-    "extends": "@fluidframework/build-common/ts-common-config.json",
-    "exclude": [
-        "src/test/**/*"
-    ],
-    "compilerOptions": {
-        "rootDir": "./src",
-        "outDir": "./dist",
-        "composite": true
-    },
-    "include": [
-        "src/**/*"
-    ]
+	"extends": [
+		"../../../common/build/build-common/tsconfig.base.json",
+		"../../../common/build/build-common/tsconfig.cjs.json",
+	],
+	"include": ["src/**/*"],
+	"exclude": ["src/test/**/*"],
+	"compilerOptions": {
+		"rootDir": "./src",
+		"outDir": "./dist",
+	},
 }

package/dist/audience.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"audience.js","sourceRoot":"","sources":["../src/audience.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACH,mCAAsC;AAItC;;GAEG;AACH,MAAa,QAAS,SAAQ,qBAAY;IAA1C;;QACqB,YAAO,GAAG,IAAI,GAAG,EAAmB,CAAC;IAqD1D,CAAC;IAlDU,EAAE,CAAC,KAAa,EAAE,QAAkC;QACvD,OAAO,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACrC,CAAC;IAED;;OAEG;IACI,SAAS,CAAC,QAAgB,EAAE,OAAgB;QAC/C,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QACpC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC9C,CAAC;IAED;;;OAGG;IACI,YAAY,CAAC,QAAgB;QAChC,MAAM,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACjD,IAAI,aAAa,KAAK,SAAS,EAAE;YAC7B,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YAC9B,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC;YACnD,OAAO,IAAI,CAAC;SACf;aAAM;YACH,OAAO,KAAK,CAAC;SAChB;IACL,CAAC;IAED;;OAEG;IACI,UAAU;QACb,OAAO,IAAI,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACjC,CAAC;IAED;;OAEG;IACI,SAAS,CAAC,QAAgB;QAC7B,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACtC,CAAC;IAED;;OAEG;IACI,KAAK;QACR,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;QACtC,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE;YAC9B,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;SAC/B;IACL,CAAC;CACJ;AAtDD,4BAsDC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\nimport { EventEmitter } from \"events\";\nimport { IAudience } from \"@fluidframework/container-definitions\";\nimport { IClient } from \"@fluidframework/protocol-definitions\";\n\n/**\n * Audience represents all clients connected to the op stream.\n */\nexport class Audience extends EventEmitter implements IAudience {\n    private readonly members = new Map<string, IClient>();\n\n    public on(event: \"addMember\" | \"removeMember\", listener: (clientId: string, client: IClient) => void): this;\n    public on(event: string, listener: (...args: any[]) => void): this {\n        return super.on(event, listener);\n    }\n\n    /**\n     * Adds a new client to the audience\n     */\n    public addMember(clientId: string, details: IClient) {\n        this.members.set(clientId, details);\n        this.emit(\"addMember\", clientId, details);\n    }\n\n    /**\n     * Removes a client from the audience. Only emits an event if a client is actually removed\n     * @returns if a client was removed from the audience\n     */\n    public removeMember(clientId: string): boolean {\n        const removedClient = this.members.get(clientId);\n        if (removedClient !== undefined) {\n            this.members.delete(clientId);\n            this.emit(\"removeMember\", clientId, removedClient);\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * Retrieves all the members in the audience\n     */\n    public getMembers(): Map<string, IClient> {\n        return new Map(this.members);\n    }\n\n    /**\n     * Retrieves a specific member of the audience\n     */\n    public getMember(clientId: string): IClient | undefined {\n        return this.members.get(clientId);\n    }\n\n    /**\n     * Clears the audience\n     */\n    public clear(): void {\n        const clientIds = this.members.keys();\n        for (const clientId of clientIds) {\n            this.removeMember(clientId);\n        }\n    }\n}\n"]}

package/dist/collabWindowTracker.d.ts

@@ -1,19 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
-export declare class CollabWindowTracker {
-    private readonly submit;
-    private readonly NoopCountFrequency;
-    private opsCountSinceNoop;
-    private readonly timer;
-    constructor(submit: (type: MessageType, contents: any) => void, NoopTimeFrequency?: number, NoopCountFrequency?: number);
-    /**
-     * Schedules as ack to the server to update the reference sequence number
-     */
-    scheduleSequenceNumberUpdate(message: ISequencedDocumentMessage, immediateNoOp: boolean): void;
-    private submitNoop;
-    stopSequenceNumberUpdate(): void;
-}
-//# sourceMappingURL=collabWindowTracker.d.ts.map

package/dist/collabWindowTracker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"collabWindowTracker.d.ts","sourceRoot":"","sources":["../src/collabWindowTracker.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,yBAAyB,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AAyB9F,qBAAa,mBAAmB;IAKxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAEvB,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IANvC,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;gBAGrB,MAAM,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,GAAG,KAAK,IAAI,EACnE,iBAAiB,GAAE,MAAiC,EACnC,kBAAkB,GAAE,MAAkC;IAa3E;;OAEG;IACI,4BAA4B,CAAC,OAAO,EAAE,yBAAyB,EAAE,aAAa,EAAE,OAAO,GAAG,IAAI;IA+BrG,OAAO,CAAC,UAAU;IAOX,wBAAwB,IAAI,IAAI;CAS1C"}

package/dist/collabWindowTracker.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"collabWindowTracker.js","sourceRoot":"","sources":["../src/collabWindowTracker.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,+DAA6D;AAC7D,+EAA8F;AAC9F,+DAAgE;AAEhE,MAAM,wBAAwB,GAAG,IAAI,CAAC;AACtC,MAAM,yBAAyB,GAAG,EAAE,CAAC;AAErC,6FAA6F;AAC7F,4GAA4G;AAC5G,yGAAyG;AACzG,2CAA2C;AAC3C,oHAAoH;AACpH,2FAA2F;AAC3F,kHAAkH;AAClH,+CAA+C;AAC/C,gHAAgH;AAChH,yFAAyF;AACzF,qHAAqH;AACrH,oDAAoD;AACpD,EAAE;AACF,kDAAkD;AAClD,oGAAoG;AACpG,iHAAiH;AACjH,sEAAsE;AACtE,4GAA4G;AAC5G,qGAAqG;AACrG,MAAa,mBAAmB;IAI5B,YACqB,MAAkD,EACnE,oBAA4B,wBAAwB,EACnC,qBAA6B,yBAAyB;QAFtD,WAAM,GAAN,MAAM,CAA4C;QAElD,uBAAkB,GAAlB,kBAAkB,CAAoC;QANnE,sBAAiB,GAAG,CAAC,CAAC;QAQ1B,IAAI,iBAAiB,KAAK,QAAQ,EAAE;YAChC,IAAI,CAAC,KAAK,GAAG,IAAI,oBAAK,CAAC,iBAAiB,EAAE,GAAG,EAAE;gBAC3C,2EAA2E;gBAC3E,mGAAmG;gBACnG,IAAI,IAAI,CAAC,iBAAiB,KAAK,CAAC,EAAE;oBAC9B,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;iBAC1C;YACL,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAED;;OAEG;IACI,4BAA4B,CAAC,OAAkC,EAAE,aAAsB;QAC1F,mEAAmE;QACnE,sDAAsD;QACtD,IAAI,aAAa,EAAE;YACf,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;YACtC,OAAO;SACV;QAED,gFAAgF;QAChF,+DAA+D;QAC/D,sFAAsF;QACtF,yCAAyC;QACzC,IAAI,CAAC,IAAA,+BAAgB,EAAC,OAAO,CAAC,EAAE;YAC5B,OAAO;SACV;QAED,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACzB,IAAI,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,kBAAkB,EAAE;YACnD,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;YACvC,OAAO;SACV;QAED,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE;YAC1B,IAAI,IAAI,CAAC,iBAAiB,KAAK,CAAC,EAAE;gBAC9B,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;aACxB;YAED,IAAA,qBAAM,EAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC;SACxD;IACL,CAAC;IAEO,UAAU,CAAC,SAAkB;QACjC,6CAA6C;QAC7C,IAAI,CAAC,MAAM,CAAC,kCAAW,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACrD,IAAA,qBAAM,EAAC,IAAI,CAAC,iBAAiB,KAAK,CAAC,EAC/B,KAAK,CAAC,8EAA8E,CAAC,CAAC;IAC9F,CAAC;IAEM,wBAAwB;QAC3B,IAAI,CAAC,iBAAiB,GAAG,CAAC,CAAC;QAC3B,kGAAkG;QAClG,wGAAwG;QACxG,oDAAoD;QACpD,qGAAqG;QACrG,yFAAyF;QACzF,sBAAsB;IAC1B,CAAC;CACJ;AAtED,kDAsEC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert, Timer } from \"@fluidframework/common-utils\";\nimport { ISequencedDocumentMessage, MessageType } from \"@fluidframework/protocol-definitions\";\nimport { isRuntimeMessage } from \"@fluidframework/driver-utils\";\n\nconst defaultNoopTimeFrequency = 2000;\nconst defaultNoopCountFrequency = 50;\n\n// Here are key considerations when deciding conditions for when to send non-immediate noops:\n// 1. Sending them too often results in increase in file size and bandwidth, as well as catch up performance\n// 2. Sending too infrequently ensures that collab window is large, and as result Sequence DDS would have\n//    large catchUp blobs - see Issue #6364\n// 3. Similarly, processes that rely on \"core\" snapshot (and can't parse trailing ops, including above), like search\n//    parser in SPO, will result in non-accurate results due to presence of catch up blobs.\n// 4. Ordering service used 250ms timeout to coalesce non-immediate noops. It was changed to 2000 ms to allow more\n//    aggressive noop sending from client side.\n// 5. Number of ops sent by all clients is proportional to number of \"write\" clients (every client sends noops),\n//    but number of sequenced noops is a function of time (one op per 2 seconds at most).\n//    We should consider impact to both outbound traffic (might be huge, depends on number of clients) and file size.\n// Please also see Issue #5629 for more discussions.\n//\n// With that, the current algorithm is as follows:\n// 1. Sent noop 2000 ms of receiving an op if no ops were sent by this client within this timeframe.\n//    This will ensure that MSN moves forward with reasonable speed. If that results in too many sequenced noops,\n//    server timeout of 2000ms should be reconsidered to be increased.\n// 2. If there are more than 50 ops received without sending any ops, send noop to keep collab window small.\n//    Note that system ops (including noops themselves) are excluded, so it's 1 noop per 50 real ops.\nexport class CollabWindowTracker {\n    private opsCountSinceNoop = 0;\n    private readonly timer: Timer | undefined;\n\n    constructor(\n        private readonly submit: (type: MessageType, contents: any) => void,\n        NoopTimeFrequency: number = defaultNoopTimeFrequency,\n        private readonly NoopCountFrequency: number = defaultNoopCountFrequency,\n    ) {\n        if (NoopTimeFrequency !== Infinity) {\n            this.timer = new Timer(NoopTimeFrequency, () => {\n                // Can get here due to this.stopSequenceNumberUpdate() not resetting timer.\n                // Also timer callback can fire even after timer cancellation if it was queued before cancellation.\n                if (this.opsCountSinceNoop !== 0) {\n                    this.submitNoop(false /* immediate */);\n                }\n            });\n        }\n    }\n\n    /**\n     * Schedules as ack to the server to update the reference sequence number\n     */\n    public scheduleSequenceNumberUpdate(message: ISequencedDocumentMessage, immediateNoOp: boolean): void {\n        // While processing a message, an immediate no-op can be requested.\n        // i.e. to expedite approve or commit phase of quorum.\n        if (immediateNoOp) {\n            this.submitNoop(true /* immediate */);\n            return;\n        }\n\n        // We don't acknowledge no-ops to avoid acknowledgement cycles (i.e. ack the MSN\n        // update, which updates the MSN, then ack the update, etc...).\n        // Intent here is for runtime (and DDSes) not to keep too much tracking state / memory\n        // due to runtime ops from other clients.\n        if (!isRuntimeMessage(message)) {\n            return;\n        }\n\n        this.opsCountSinceNoop++;\n        if (this.opsCountSinceNoop >= this.NoopCountFrequency) {\n            this.submitNoop(false /* immediate */);\n            return;\n        }\n\n        if (this.timer !== undefined) {\n            if (this.opsCountSinceNoop === 1) {\n                this.timer.restart();\n            }\n\n            assert(this.timer.hasTimer, 0x242 /* \"has timer\" */);\n        }\n    }\n\n    private submitNoop(immediate: boolean) {\n        // Anything other than null is immediate noop\n        this.submit(MessageType.NoOp, immediate ? \"\" : null);\n        assert(this.opsCountSinceNoop === 0,\n            0x243 /* \"stopSequenceNumberUpdate should be called as result of sending any op!\" */);\n    }\n\n    public stopSequenceNumberUpdate(): void {\n        this.opsCountSinceNoop = 0;\n        // Ideally, we cancel timer here. But that will result in too often set/reset cycle if this client\n        // keeps sending ops. In most cases it's actually better to let it expire (at most - 4 times per second)\n        // for nothing, then have a ton of set/reset cycles.\n        // Note that Timer.restart() is smart and will not change timer expiration if we keep extending timer\n        // expiration - it will restart the timer instead when it fires with adjusted expiration.\n        // this.timer.clear();\n    }\n}\n"]}