@fluidframework/container-loader 2.0.0-internal.3.0.1 → 2.0.0-internal.3.1.0

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-loader";
-export const pkgVersion = "2.0.0-internal.3.0.1";
+export const pkgVersion = "2.0.0-internal.3.1.0";

package/src/protocol.ts

@@ -5,116 +5,122 @@
 
 import { IAudienceOwner } from "@fluidframework/container-definitions";
 import {
-    ILocalSequencedClient,
-    IProtocolHandler as IBaseProtocolHandler,
-    IQuorumSnapshot,
-    ProtocolOpHandler,
+	ILocalSequencedClient,
+	IProtocolHandler as IBaseProtocolHandler,
+	IQuorumSnapshot,
+	ProtocolOpHandler,
 } from "@fluidframework/protocol-base";
 import {
-    IDocumentAttributes,
-    IProcessMessageResult,
-    ISequencedDocumentMessage,
-    ISignalClient,
-    ISignalMessage,
-    MessageType,
+	IDocumentAttributes,
+	IProcessMessageResult,
+	ISequencedDocumentMessage,
+	ISignalClient,
+	ISignalMessage,
+	MessageType,
 } from "@fluidframework/protocol-definitions";
 import { canBeCoalescedByService } from "@fluidframework/driver-utils";
 
 // ADO: #1986: Start using enum from protocol-base.
 export enum SignalType {
-    ClientJoin = "join", // same value as MessageType.ClientJoin,
-    ClientLeave = "leave", // same value as MessageType.ClientLeave,
-    Clear = "clear", // used only by client for synthetic signals
+	ClientJoin = "join", // same value as MessageType.ClientJoin,
+	ClientLeave = "leave", // same value as MessageType.ClientLeave,
+	Clear = "clear", // used only by client for synthetic signals
 }
 
 /**
  * Function to be used for creating a protocol handler.
  */
 export type ProtocolHandlerBuilder = (
-    attributes: IDocumentAttributes,
-    snapshot: IQuorumSnapshot,
-    sendProposal: (key: string, value: any) => number,
+	attributes: IDocumentAttributes,
+	snapshot: IQuorumSnapshot,
+	sendProposal: (key: string, value: any) => number,
 ) => IProtocolHandler;
 
 export interface IProtocolHandler extends IBaseProtocolHandler {
-    readonly audience: IAudienceOwner;
-    processSignal(message: ISignalMessage);
+	readonly audience: IAudienceOwner;
+	processSignal(message: ISignalMessage);
 }
 
 export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandler {
-    constructor(
-        attributes: IDocumentAttributes,
-        quorumSnapshot: IQuorumSnapshot,
-        sendProposal: (key: string, value: any) => number,
-        readonly audience: IAudienceOwner,
-    ) {
-        super(
-            attributes.minimumSequenceNumber,
-            attributes.sequenceNumber,
-            attributes.term,
-            quorumSnapshot.members,
-            quorumSnapshot.proposals,
-            quorumSnapshot.values,
-            sendProposal,
-        );
+	constructor(
+		attributes: IDocumentAttributes,
+		quorumSnapshot: IQuorumSnapshot,
+		sendProposal: (key: string, value: any) => number,
+		readonly audience: IAudienceOwner,
+	) {
+		super(
+			attributes.minimumSequenceNumber,
+			attributes.sequenceNumber,
+			attributes.term,
+			quorumSnapshot.members,
+			quorumSnapshot.proposals,
+			quorumSnapshot.values,
+			sendProposal,
+		);
 
-        // Join / leave signals are ignored for "write" clients in favor of join / leave ops
-        this.quorum.on("addMember", (clientId, details) => audience.addMember(clientId, details.client));
-        this.quorum.on("removeMember", (clientId) => audience.removeMember(clientId));
-        for (const [clientId, details] of this.quorum.getMembers()) {
-            this.audience.addMember(clientId, details.client);
-        }
-    }
+		// Join / leave signals are ignored for "write" clients in favor of join / leave ops
+		this.quorum.on("addMember", (clientId, details) =>
+			audience.addMember(clientId, details.client),
+		);
+		this.quorum.on("removeMember", (clientId) => audience.removeMember(clientId));
+		for (const [clientId, details] of this.quorum.getMembers()) {
+			this.audience.addMember(clientId, details.client);
+		}
+	}
 
-    public processMessage(message: ISequencedDocumentMessage, local: boolean): IProcessMessageResult {
-        const client: ILocalSequencedClient | undefined = this.quorum.getMember(message.clientId);
+	public processMessage(
+		message: ISequencedDocumentMessage,
+		local: boolean,
+	): IProcessMessageResult {
+		const client: ILocalSequencedClient | undefined = this.quorum.getMember(message.clientId);
 
-        // Check and report if we're getting messages from a clientId that we previously
-        // flagged as shouldHaveLeft, or from a client that's not in the quorum but should be
-        if (message.clientId != null) {
-            if (client === undefined && message.type !== MessageType.ClientJoin) {
-                // pre-0.58 error message: messageClientIdMissingFromQuorum
-                throw new Error("Remote message's clientId is missing from the quorum");
-            }
+		// Check and report if we're getting messages from a clientId that we previously
+		// flagged as shouldHaveLeft, or from a client that's not in the quorum but should be
+		if (message.clientId != null) {
+			if (client === undefined && message.type !== MessageType.ClientJoin) {
+				// pre-0.58 error message: messageClientIdMissingFromQuorum
+				throw new Error("Remote message's clientId is missing from the quorum");
+			}
 
-            if (client?.shouldHaveLeft === true && !canBeCoalescedByService(message)) {
-                // pre-0.58 error message: messageClientIdShouldHaveLeft
-                throw new Error("Remote message's clientId already should have left");
-            }
-        }
+			if (client?.shouldHaveLeft === true && !canBeCoalescedByService(message)) {
+				// pre-0.58 error message: messageClientIdShouldHaveLeft
+				throw new Error("Remote message's clientId already should have left");
+			}
+		}
 
-        return super.processMessage(message, local);
-    }
+		return super.processMessage(message, local);
+	}
 
-    public processSignal(message: ISignalMessage) {
-        const innerContent = message.content as { content: any; type: string; };
-        switch (innerContent.type) {
-            case SignalType.Clear: {
-                const members = this.audience.getMembers();
-                for (const [clientId, client] of members) {
-                    if (client.mode === "read") {
-                        this.audience.removeMember(clientId);
-                    }
-                }
-                break;
-            }
-            case SignalType.ClientJoin: {
-                const newClient = innerContent.content as ISignalClient;
-                // Ignore write clients - quorum will control such clients.
-                if (newClient.client.mode === "read") {
-                    this.audience.addMember(newClient.clientId, newClient.client);
-                }
-                break;
-            }
-            case SignalType.ClientLeave: {
-                const leftClientId = innerContent.content as string;
-                // Ignore write clients - quorum will control such clients.
-                if (this.audience.getMember(leftClientId)?.mode === "read") {
-                    this.audience.removeMember(leftClientId);
-                }
-                break;
-            }
-            default: break;
-        }
-    }
+	public processSignal(message: ISignalMessage) {
+		const innerContent = message.content as { content: any; type: string };
+		switch (innerContent.type) {
+			case SignalType.Clear: {
+				const members = this.audience.getMembers();
+				for (const [clientId, client] of members) {
+					if (client.mode === "read") {
+						this.audience.removeMember(clientId);
+					}
+				}
+				break;
+			}
+			case SignalType.ClientJoin: {
+				const newClient = innerContent.content as ISignalClient;
+				// Ignore write clients - quorum will control such clients.
+				if (newClient.client.mode === "read") {
+					this.audience.addMember(newClient.clientId, newClient.client);
+				}
+				break;
+			}
+			case SignalType.ClientLeave: {
+				const leftClientId = innerContent.content as string;
+				// Ignore write clients - quorum will control such clients.
+				if (this.audience.getMember(leftClientId)?.mode === "read") {
+					this.audience.removeMember(leftClientId);
+				}
+				break;
+			}
+			default:
+				break;
+		}
+	}
 }

package/src/protocolTreeDocumentStorageService.ts

@@ -4,42 +4,39 @@
  */
 
 import { IDisposable } from "@fluidframework/common-definitions";
-import {
-    IDocumentStorageService,
-    ISummaryContext,
-} from "@fluidframework/driver-definitions";
+import { IDocumentStorageService, ISummaryContext } from "@fluidframework/driver-definitions";
 import { combineAppAndProtocolSummary } from "@fluidframework/driver-utils";
-import {
-    ISummaryTree,
-} from "@fluidframework/protocol-definitions";
+import { ISummaryTree } from "@fluidframework/protocol-definitions";
 
 export class ProtocolTreeStorageService implements IDocumentStorageService, IDisposable {
-    constructor(
-        private readonly internalStorageService: IDocumentStorageService & IDisposable,
-        private readonly generateProtocolTree: () => ISummaryTree,
-    ) {
-    }
-    public get policies() {
-        return this.internalStorageService.policies;
-    }
-    public get repositoryUrl() {
-        return this.internalStorageService.repositoryUrl;
-    }
-    public get disposed() {
-        return this.internalStorageService.disposed;
-    }
+	constructor(
+		private readonly internalStorageService: IDocumentStorageService & IDisposable,
+		private readonly generateProtocolTree: () => ISummaryTree,
+	) {}
+	public get policies() {
+		return this.internalStorageService.policies;
+	}
+	public get repositoryUrl() {
+		return this.internalStorageService.repositoryUrl;
+	}
+	public get disposed() {
+		return this.internalStorageService.disposed;
+	}
 
-    getSnapshotTree = this.internalStorageService.getSnapshotTree.bind(this.internalStorageService);
-    getVersions = this.internalStorageService.getVersions.bind(this.internalStorageService);
-    createBlob = this.internalStorageService.createBlob.bind(this.internalStorageService);
-    readBlob = this.internalStorageService.readBlob.bind(this.internalStorageService);
-    downloadSummary = this.internalStorageService.downloadSummary.bind(this.internalStorageService);
-    dispose = this.internalStorageService.dispose.bind(this.internalStorageService);
+	getSnapshotTree = this.internalStorageService.getSnapshotTree.bind(this.internalStorageService);
+	getVersions = this.internalStorageService.getVersions.bind(this.internalStorageService);
+	createBlob = this.internalStorageService.createBlob.bind(this.internalStorageService);
+	readBlob = this.internalStorageService.readBlob.bind(this.internalStorageService);
+	downloadSummary = this.internalStorageService.downloadSummary.bind(this.internalStorageService);
+	dispose = this.internalStorageService.dispose.bind(this.internalStorageService);
 
-    async uploadSummaryWithContext(summary: ISummaryTree, context: ISummaryContext): Promise<string> {
-        return this.internalStorageService.uploadSummaryWithContext(
-            combineAppAndProtocolSummary(summary, this.generateProtocolTree()),
-            context,
-        );
-    }
+	async uploadSummaryWithContext(
+		summary: ISummaryTree,
+		context: ISummaryContext,
+	): Promise<string> {
+		return this.internalStorageService.uploadSummaryWithContext(
+			combineAppAndProtocolSummary(summary, this.generateProtocolTree()),
+			context,
+		);
+	}
 }

package/src/quorum.ts

@@ -5,55 +5,55 @@
 import { assert, EventForwarder, doIfNotDisposed } from "@fluidframework/common-utils";
 import { IFluidCodeDetails } from "@fluidframework/core-interfaces";
 import {
-    ICommittedProposal,
-    IQuorum,
-    IQuorumEvents,
-    ISequencedClient,
+	ICommittedProposal,
+	IQuorum,
+	IQuorumEvents,
+	ISequencedClient,
 } from "@fluidframework/protocol-definitions";
 
 /**
  * Proxies Quorum events.
  */
 export class QuorumProxy extends EventForwarder<IQuorumEvents> implements IQuorum {
-    public readonly propose: (key: string, value: any) => Promise<void>;
-    public readonly has: (key: string) => boolean;
-    public readonly get: (key: string) => any;
-    public readonly getMembers: () => Map<string, ISequencedClient>;
-    public readonly getMember: (clientId: string) => ISequencedClient | undefined;
+	public readonly propose: (key: string, value: any) => Promise<void>;
+	public readonly has: (key: string) => boolean;
+	public readonly get: (key: string) => any;
+	public readonly getMembers: () => Map<string, ISequencedClient>;
+	public readonly getMember: (clientId: string) => ISequencedClient | undefined;
 
-    constructor(quorum: IQuorum) {
-        super(quorum);
+	constructor(quorum: IQuorum) {
+		super(quorum);
 
-        // This is heavily used object, increase limit at which Node prints warnings.
-        super.setMaxListeners(50);
+		// This is heavily used object, increase limit at which Node prints warnings.
+		super.setMaxListeners(50);
 
-        this.propose = doIfNotDisposed(this, quorum.propose.bind(quorum));
-        this.has = doIfNotDisposed(this, quorum.has.bind(quorum));
-        this.get = doIfNotDisposed(this, quorum.get.bind(quorum));
-        this.getMembers = doIfNotDisposed(this, quorum.getMembers.bind(quorum));
-        this.getMember = doIfNotDisposed(this, quorum.getMember.bind(quorum));
-    }
+		this.propose = doIfNotDisposed(this, quorum.propose.bind(quorum));
+		this.has = doIfNotDisposed(this, quorum.has.bind(quorum));
+		this.get = doIfNotDisposed(this, quorum.get.bind(quorum));
+		this.getMembers = doIfNotDisposed(this, quorum.getMembers.bind(quorum));
+		this.getMember = doIfNotDisposed(this, quorum.getMember.bind(quorum));
+	}
 }
 
 export function getCodeDetailsFromQuorumValues(
-    quorumValues: [string, ICommittedProposal][],
+	quorumValues: [string, ICommittedProposal][],
 ): IFluidCodeDetails {
-    const qValuesMap = new Map(quorumValues);
-    const proposal = qValuesMap.get("code");
-    assert(proposal !== undefined, 0x2dc /* "Cannot find code proposal" */);
-    return proposal?.value as IFluidCodeDetails;
+	const qValuesMap = new Map(quorumValues);
+	const proposal = qValuesMap.get("code");
+	assert(proposal !== undefined, 0x2dc /* "Cannot find code proposal" */);
+	return proposal?.value as IFluidCodeDetails;
 }
 
 export function initQuorumValuesFromCodeDetails(
-    source: IFluidCodeDetails,
+	source: IFluidCodeDetails,
 ): [string, ICommittedProposal][] {
-    // Seed the base quorum to be an empty list with a code quorum set
-    const committedCodeProposal: ICommittedProposal = {
-        key: "code",
-        value: source,
-        approvalSequenceNumber: 0,
-        commitSequenceNumber: 0,
-        sequenceNumber: 0,
-    };
-    return [["code", committedCodeProposal]];
+	// Seed the base quorum to be an empty list with a code quorum set
+	const committedCodeProposal: ICommittedProposal = {
+		key: "code",
+		value: source,
+		approvalSequenceNumber: 0,
+		commitSequenceNumber: 0,
+		sequenceNumber: 0,
+	};
+	return [["code", committedCodeProposal]];
 }

package/src/retriableDocumentStorageService.ts

@@ -6,124 +6,140 @@
 import { assert } from "@fluidframework/common-utils";
 import { GenericError } from "@fluidframework/container-utils";
 import {
-    FetchSource,
-    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 { 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;
+	constructor(
+		private readonly internalStorageService: IDocumentStorageService,
+		private readonly logger: ITelemetryLogger,
+	) {}
 
-    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 {
+		return this.internalStorageService.policies;
+	}
+	public get disposed() {
+		return this._disposed;
+	}
+	public dispose() {
+		this._disposed = true;
+	}
 
-    public get repositoryUrl(): string {
-        return this.internalStorageService.repositoryUrl;
-    }
+	public get repositoryUrl(): string {
+		return this.internalStorageService.repositoryUrl;
+	}
 
-    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.internalStorageService.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.internalStorageService.readBlob(id),
+			"storage_readBlob",
+		);
+	}
 
-    public async getVersions(
-        versionId: string | null,
-        count: number,
-        scenarioName?: string,
-        fetchSource?: FetchSource,
-    ): Promise<IVersion[]> {
-        return this.runWithRetry(
-            async () => this.internalStorageService.getVersions(versionId, count, scenarioName, fetchSource),
-            "storage_getVersions",
-        );
-    }
+	public async getVersions(
+		versionId: string | null,
+		count: number,
+		scenarioName?: string,
+		fetchSource?: FetchSource,
+	): Promise<IVersion[]> {
+		return this.runWithRetry(
+			async () =>
+				this.internalStorageService.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.internalStorageService.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.internalStorageService.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.internalStorageService.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.internalStorageService.createBlob(file),
+			"storage_createBlob",
+		);
+	}
 
-    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 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: (_delayInMs: number, error: unknown) => this.checkStorageDisposed(callName, error),
-            },
-        );
-    }
+	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),
+		});
+	}
 }