@fluidframework/container-runtime 2.0.0-rc.4.0.6 → 2.0.0-rc.5.0.1

package/src/summary/summaryCollection.ts

@@ -9,12 +9,12 @@ import { IDisposable, IEvent } from "@fluidframework/core-interfaces";
 import { assert, Deferred } from "@fluidframework/core-utils/internal";
 import {
 	IDocumentMessage,
-	ISequencedDocumentMessage,
 	ISummaryAck,
 	ISummaryContent,
 	ISummaryNack,
 	MessageType,
-} from "@fluidframework/protocol-definitions";
+	ISequencedDocumentMessage,
+} from "@fluidframework/driver-definitions/internal";
 import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils/internal";
 
 /**
@@ -298,7 +298,10 @@ export class SummaryCollection extends TypedEventEmitter<ISummaryCollectionOpEve
 		this.summaryWatchers.delete(clientId);
 	}
 
-	public setPendingAckTimerTimeoutCallback(maxAckWaitTime: number, timeoutCallback: () => void) {
+	public setPendingAckTimerTimeoutCallback(
+		maxAckWaitTime: number,
+		timeoutCallback: () => void,
+	) {
 		this.maxAckWaitTime = maxAckWaitTime;
 		this.pendingAckTimerTimeoutCallback = timeoutCallback;
 	}

package/src/summary/summaryFormat.ts

@@ -4,18 +4,21 @@
  */
 
 import { assert } from "@fluidframework/core-utils/internal";
-import { IDocumentStorageService } from "@fluidframework/driver-definitions/internal";
+import { SummaryType } from "@fluidframework/driver-definitions";
+import {
+	IDocumentStorageService,
+	ISnapshotTree,
+	ISequencedDocumentMessage,
+} from "@fluidframework/driver-definitions/internal";
 import {
 	blobHeadersBlobName as blobNameForBlobHeaders,
 	readAndParse,
 } from "@fluidframework/driver-utils/internal";
 import {
-	ISequencedDocumentMessage,
-	ISnapshotTree,
-	SummaryType,
-} from "@fluidframework/protocol-definitions";
-import { ISummaryTreeWithStats } from "@fluidframework/runtime-definitions";
-import { channelsTreeName, gcTreeKey } from "@fluidframework/runtime-definitions/internal";
+	ISummaryTreeWithStats,
+	channelsTreeName,
+	gcTreeKey,
+} from "@fluidframework/runtime-definitions/internal";
 
 import { IGCMetadata } from "../gc/index.js";
 
@@ -25,7 +28,10 @@ import { IDocumentSchema } from "./documentSchema.js";
  * @deprecated - This interface will no longer be exported in the future(AB#8004).
  * @alpha
  */
-export type OmitAttributesVersions<T> = Omit<T, "snapshotFormatVersion" | "summaryFormatVersion">;
+export type OmitAttributesVersions<T> = Omit<
+	T,
+	"snapshotFormatVersion" | "summaryFormatVersion"
+>;
 
 /**
  * @deprecated - This interface will no longer be exported in the future(AB#8004).
@@ -84,7 +90,9 @@ export type ReadFluidDataStoreAttributes =
 	| IFluidDataStoreAttributes0
 	| IFluidDataStoreAttributes1
 	| IFluidDataStoreAttributes2;
-export type WriteFluidDataStoreAttributes = IFluidDataStoreAttributes1 | IFluidDataStoreAttributes2;
+export type WriteFluidDataStoreAttributes =
+	| IFluidDataStoreAttributes1
+	| IFluidDataStoreAttributes2;
 
 export function getAttributesFormatVersion(attributes: ReadFluidDataStoreAttributes): number {
 	if (attributes.summaryFormatVersion) {
@@ -172,7 +180,7 @@ export const extractSummaryMetadataMessage = (
 				sequenceNumber: message.sequenceNumber,
 				timestamp: message.timestamp,
 				type: message.type,
-		  };
+			};
 
 export function getMetadataFormatVersion(metadata?: IContainerRuntimeMetadata): number {
 	/**

package/src/summary/summaryFormats.md

@@ -0,0 +1,160 @@
+# Summary and snapshot formats
+
+## Table of contents
+
+-   [Introduction](#introduction)
+-   [Summary Format](#summary-format)
+-   [Snapshot Format](#snapshot-format)
+-   [Summary / Snapshot Tree Visualization](#summary--snapshot-tree-visualization)
+    -   [Protocol Tree](#protocol-tree)
+    -   [App Tree](#app-tree)
+    -   [Summary Tree distinction](#summary-tree-distinction)
+
+## Introduction
+
+This document describes the format of summaries and snapshots. For learning the differences between summaries and snapshots, see the FAQ section [here](https://fluidframework.com/docs/faq/#whats-the-difference-between-a-summary-and-a-snapshot).
+
+The goal of this document is to describe the fundamental structure of a summary / snapshot tree as produced by the runtime, to explain the various node types within the tree along with their respective data, and to show the distinctions between a summary tree and a snapshot tree.
+
+## Summary Format
+
+Summary is uploaded to storage and is the container's state at a point in time. A summary is represented by an `ISummaryTree` which is defined in [this file](../../../../../common/lib/protocol-definitions/src/summary.ts) and has the following basic structure (some optional properties are removed for simplicity):
+
+```typescript
+export interface ISummaryTree {
+	type: SummaryType.Tree;
+	tree: { [path: string]: SummaryObject };
+}
+export type SummaryType =
+	| SummaryType.Attachment
+	| SummaryType.Blob
+	| SummaryType.Handle
+	| SummaryType.Tree;
+export type SummaryObject = ISummaryTree | ISummaryBlob | ISummaryHandle | ISummaryAttachment;
+```
+
+Each tree node in a summary tree is represented by the `ISummaryTree` interface above and contains the following:
+
+-   `type` - `SummaryType.Tree`
+-   `tree` - A list of children of the tree node. Each child node has the following format:
+
+    `<tree name>`: `<SummaryObject>` where `tree name` is the name given to the child node and `SummaryObject` is one of the following:
+
+    -   `ISummaryTree` - A subtree which has the same structure as this node. For example, container runtime will have subtrees for its data store which in turn will have subtrees for its DDSes.
+
+    -   `ISummaryBlob` - A blob that has some content for this node. For example, a DDS's node has a ".attributes" blob for its attributes such as type, snapshot versions, etc. It may have additional blobs for the actual user content in the DDS.
+
+        ```typescript
+        export interface ISummaryBlob {
+        	type: SummaryType.Blob;
+        	content: string | Uint8Array;
+        }
+        ```
+
+    -   `ISummaryAttachment` - This is used for attachment blobs that are uploaded to and downloaded from storage directly. The contents of these blobs are not part of the summary. Storage returns an ID after the attachment has been uploaded and this ID is included in the summary attachment. For example, a DDS can upload some of its large content directly to storage and include its ID in the summary.
+
+        ```typescript
+        export interface ISummaryAttachment {
+        	type: SummaryType.Attachment;
+        	id: string;
+        }
+        ```
+
+    -   `ISummaryHandle` - A summary handle is used for incremental summaries. If a node hasn't changed since the last successful summary, instead of sending it's entire contents, it can send a "handle" which is a path to its summary tree object in the last summary. For example, if a data store or DDS did not change since the last summary, the runtime will use a handle for the entire data store instead of re-sending the entire subtree. The same concept applies for a summary blob or a summary attachment and the "handleType" should be set according to the type of the node. An example of "handle" that a DDS sends would be something like: "/_dataStoreId_/_ddsId_".
+
+            ```typescript
+            export interface ISummaryHandle {
+            	type: SummaryType.Handle;
+            	handleType: SummaryTypeNoHandle;
+            	handle: string;
+            }
+            export type SummaryTypeNoHandle =
+            	| SummaryType.Tree
+            	| SummaryType.Blob
+            	| SummaryType.Attachment;
+            ```
+
+## Snapshot Format
+
+Snapshot is downloaded from the storage (typically on document load) and is the container's state at a point in time. A snapshot is represented by an `ISnapshotTree` which is defined in [this file](../../../../../common/lib/protocol-definitions/src/storage.ts) and has the following basic structure (some optional properties are removed for simplicity):
+
+```typescript
+export interface ISnapshotTree {
+	blobs: { [path: string]: string };
+	trees: { [path: string]: ISnapshotTree };
+}
+```
+
+Each node in a snapshot tree is represented by the above interface and contains the following:
+
+-   `blobs` - A list of blobs that have the contents for the node. For example, a DDS's node has a ".attributes" blob for its attributes such as type, snapshot versions, etc. It may have additional blobs for the actual user content in the DDS. Each blob in the list has the following format:
+
+    `<blob name>`: `<unique blob id>` where `blob name` is the name given to the blob by the node and `unique blob id` is the id that uniquely represents the blob's content in storage.
+
+    When a node needs the content of a blob, it fetches it from storage by calling `readBlob` and providing the `unique blob id`.
+
+    > Note: Summary attachments (described in summary format) are also part of this list.
+
+-   `trees` - A list of subtrees of the node. For example, container runtime will have subtrees for its data store which in turn will have subtrees for its DDSes. Each subtree in the list has the following format:
+
+    `<tree name>`: `<snapshot tree>` where `tree name` is the name given to the subtree by the node and `snapshot tree` is its content in `ISnapshotTree` format.
+
+## Summary / Snapshot Tree Visualization
+
+This section shows what a typical summary or snapshot tree in a container looks like. Some key things to note:
+
+-   The diagrams in this section show some examples of existing blobs / trees that are added at each node and doesn't show an exhaustive list.
+-   The blue boxes represent tree nodes.
+-   The green boxes represent blobs.
+-   The purple boxes represent attachments.
+-   The orange boxes represent other nodes - either existing nodes that are not shown or new nodes that may be added in the future. A node can be a tree, blob or attachment.
+
+A typical tree uploaded to or downloaded from storage looks like the following:
+![ProtocolAndAppTree](./images/protocolAndAppTree.png)
+
+`Protocol tree` - This is the tree named `.protocol` and contains protocol level information for the container. These are used by the container to initialize.
+
+`App tree` - This is the tree named `.app` and contains the container's state and data. The subtree under .app is what is generated by the container runtime.
+
+### Protocol tree
+
+The contents of the protocol tree are:
+
+-   `attributes blob` - Attributes such as the sequence number the summary was taken at.
+-   `quorum members blob` - The members in the quorum at the time summary was taken.
+-   `quorum proposals blob` - The quorum proposals at the time summary was taken.
+-   `quorum values blob` - The quorum values at the time summary was taken.
+-   Other blobs and trees may be added at this level as needed.
+
+### App tree
+
+This is what the ".app" tree looks like which is generated by the container runtime during summary upload. The same is passed to container runtime during snapshot download:
+![appTree](./images/appTree.png)
+
+-   `Container`: The root represents the container or container runtime node. Its contents are described below:
+
+    -   `.metadata blob` - The container level metadata such as creation time, create version, etc.
+    -   `.aliases blob` - The list of aliases for data stores and the corresponding internal id.
+    -   `.idCompressor blob` - The data for the ID compressor.
+    -   `.blobs tree` - The snapshot for the attachment blobs added by the blob manager. The individual attachment blobs are present as summary attachments (`ISummaryAttachment`).
+    -   `gc tree` - The snapshot for garbage collection added by the garbage collector.
+    -   `.channels tree` - The subtrees for all the data stores.
+    -   There may be other blobs and trees added at this level as needed.
+
+-   `Data store`: Data store snapshot trees are under ".channels" subtree of container runtime's tree. Its contents are described below:
+
+    -   `.component blob` - The attributes for a data store such as the package name, snapshot version, etc.
+    -   `.channels tree` - The subtrees for all its DDSs.
+    -   There may be other blobs and trees added at this level as needed.
+
+-   `DDS`: DDS snapshot trees are under ".channels" subtree of its parent data store's tree. Its contents are described below:
+    -   `.attributes blob` - The attributes for a DDS such as the type, snapshot version, etc.
+    -   `.header blob` - Added by some DDSs and may contains its data. Note that all DDSs may not add this.
+    -   A DDS may add other blobs and / or trees to represent its data. Basically, a DDS can write its data in any form
+
+### Summary tree distinction
+
+In the visualization above, a summary tree differs from a snapshot tree in the following way:
+A summary tree supports incremental summaries via summary handles. Any node in the tree that has not changed since the previous successful summary can send a summary handle (`ISummaryHandle`) instead of sending its entire contents in a full summary. The following diagram shows this with an example where certain parts of the summary tree use a summary handle. It is a zoomed in version of the same app tree as above where nodes where summary handles are marked in red:
+
+![summaryTree](./images/summaryTree.png)

package/src/summary/summaryGenerator.ts

@@ -11,9 +11,8 @@ import {
 	IPromiseTimerResult,
 	Timer,
 } from "@fluidframework/core-utils/internal";
-import { DriverErrorTypes } from "@fluidframework/driver-definitions/internal";
+import { DriverErrorTypes, MessageType } from "@fluidframework/driver-definitions/internal";
 import { getRetryDelaySecondsFromError } from "@fluidframework/driver-utils/internal";
-import { MessageType } from "@fluidframework/protocol-definitions";
 import {
 	isFluidError,
 	ITelemetryLoggerExt,
@@ -35,6 +34,7 @@ import {
 	SubmitSummaryResult,
 	SummarizeResultPart,
 	SummaryGeneratorTelemetry,
+	type IRetriableFailureError,
 } from "./summarizerTypes.js";
 import { IClientSummaryWatcher } from "./summaryCollection.js";
 
@@ -127,8 +127,10 @@ const summarizeErrors = {
 	disconnect: "Summary cancelled due to summarizer or main client disconnect",
 } as const;
 
+export type SummarizeErrorCode = keyof typeof summarizeErrors;
+
 // Helper functions to report failures and return.
-export const getFailMessage = (errorCode: keyof typeof summarizeErrors) =>
+export const getFailMessage = (errorCode: SummarizeErrorCode) =>
 	`${errorCode}: ${summarizeErrors[errorCode]}`;
 
 export class SummarizeResultBuilder {
@@ -150,7 +152,7 @@ export class SummarizeResultBuilder {
 	 */
 	public fail(
 		message: string,
-		error: any,
+		error: IRetriableFailureError,
 		submitFailureResult?: SubmitSummaryFailureData,
 		nackSummaryResult?: INackSummaryResult,
 	) {
@@ -184,8 +186,7 @@ export class SummarizeResultBuilder {
 /**
  * Errors type for errors hit during summary that may be retriable.
  */
-export class RetriableSummaryError extends LoggingError {
-	public readonly canRetry = this.retryAfterSeconds !== undefined;
+export class RetriableSummaryError extends LoggingError implements IRetriableFailureError {
 	constructor(
 		message: string,
 		public readonly retryAfterSeconds?: number,
@@ -221,9 +222,8 @@ export class SummaryGenerator {
 	/**
 	 * Generates summary and listens for broadcast and ack/nack.
 	 * Returns true for ack, false for nack, and undefined for failure or timeout.
-	 * @param reason - reason for summarizing
-	 * @param options - refreshLatestAck to fetch summary ack info from server,
-	 * fullTree to generate tree without any summary handles even if unchanged
+	 * @param summaryOptions - options controlling how the summary is generated or submitted.
+	 * @param resultsBuilder - optional, result builder to use to build pass or fail result.
 	 */
 	public summarize(
 		summaryOptions: ISubmitSummaryOptions,
@@ -273,8 +273,8 @@ export class SummaryGenerator {
 		 * be provided. For op broadcast failures, only errors / properties should be provided.
 		 */
 		const fail = (
-			errorCode: keyof typeof summarizeErrors,
-			error?: Error,
+			errorCode: SummarizeErrorCode,
+			error: IRetriableFailureError,
 			properties?: SummaryGeneratorTelemetry,
 			submitFailureResult?: SubmitSummaryFailureData,
 			nackSummaryResult?: INackSummaryResult,
@@ -294,11 +294,9 @@ export class SummaryGenerator {
 					...properties,
 					reason,
 					category,
-					retryAfterSeconds:
-						submitFailureResult?.retryAfterSeconds ??
-						nackSummaryResult?.retryAfterSeconds,
+					retryAfterSeconds: error.retryAfterSeconds,
 				},
-				error ?? reason,
+				error,
 			); // disconnect & summaryAckTimeout do not have proper error.
 
 			resultsBuilder.fail(reason, error, submitFailureResult, nackSummaryResult);
@@ -320,8 +318,7 @@ export class SummaryGenerator {
 				minimumSequenceNumber: summaryData.minimumSequenceNumber,
 				opsSinceLastAttempt: referenceSequenceNumber - lastAttemptRefSeqNum,
 				opsSinceLastSummary:
-					referenceSequenceNumber -
-					this.heuristicData.lastSuccessfulSummary.refSequenceNumber,
+					referenceSequenceNumber - this.heuristicData.lastSuccessfulSummary.refSequenceNumber,
 				stage: summaryData.stage,
 			};
 			summarizeTelemetryProps = this.addSummaryDataToTelemetryProps(
@@ -330,9 +327,11 @@ export class SummaryGenerator {
 			);
 
 			if (summaryData.stage !== "submit") {
-				return fail("submitSummaryFailure", summaryData.error, summarizeTelemetryProps, {
+				const errorCode: SummarizeErrorCode = "submitSummaryFailure";
+				const retriableError =
+					summaryData.error ?? new RetriableSummaryError(getFailMessage(errorCode));
+				return fail(errorCode, retriableError, summarizeTelemetryProps, {
 					stage: summaryData.stage,
-					retryAfterSeconds: getRetryDelaySecondsFromError(summaryData.error),
 				});
 			}
 
@@ -346,7 +345,7 @@ export class SummaryGenerator {
 			 * state change of multiple data stores. So, the total number of data stores that are summarized should not
 			 * exceed the number of ops since last summary + number of data store whose reference state changed.
 			 */
-			if (!submitSummaryOptions.fullTree && !summaryData.forcedFullTree) {
+			if (!submitSummaryOptions.fullTree) {
 				const { summarizedDataStoreCount, gcStateUpdatedDataStoreCount = 0 } =
 					summaryData.summaryStats;
 				if (
@@ -368,11 +367,14 @@ export class SummaryGenerator {
 		} catch (error) {
 			return fail(
 				"submitSummaryFailure",
-				wrapError(error, (message) => new LoggingError(message)),
+				wrapError(
+					error,
+					(message) =>
+						new RetriableSummaryError(message, getRetryDelaySecondsFromError(error)),
+				),
 				undefined /* properties */,
 				{
 					stage: "unknown",
-					retryAfterSeconds: getRetryDelaySecondsFromError(error),
 				},
 			);
 		} finally {
@@ -393,10 +395,17 @@ export class SummaryGenerator {
 				cancellationToken,
 			);
 			if (waitBroadcastResult.result === "cancelled") {
-				return fail("disconnect");
+				const errorCode: SummarizeErrorCode = "disconnect";
+				return fail(errorCode, new RetriableSummaryError(getFailMessage(errorCode)));
 			}
 			if (waitBroadcastResult.result !== "done") {
-				return fail("summaryOpWaitTimeout");
+				// The summary op may not have been received within the timeout due to a transient error. So,
+				// fail with a retriable error to re-attempt the summary if possible.
+				const errorCode: SummarizeErrorCode = "summaryOpWaitTimeout";
+				return fail(
+					errorCode,
+					new RetriableSummaryError(getFailMessage(errorCode), 0 /* retryAfterSeconds */),
+				);
 			}
 			const summarizeOp = waitBroadcastResult.value;
 
@@ -422,10 +431,17 @@ export class SummaryGenerator {
 				cancellationToken,
 			);
 			if (waitAckNackResult.result === "cancelled") {
-				return fail("disconnect");
+				const errorCode: SummarizeErrorCode = "disconnect";
+				return fail(errorCode, new RetriableSummaryError(getFailMessage(errorCode)));
 			}
 			if (waitAckNackResult.result !== "done") {
-				return fail("summaryAckWaitTimeout");
+				const errorCode: SummarizeErrorCode = "summaryAckWaitTimeout";
+				// The summary ack may not have been received within the timeout due to a transient error. So,
+				// fail with a retriable error to re-attempt the summary if possible.
+				return fail(
+					errorCode,
+					new RetriableSummaryError(getFailMessage(errorCode), 0 /* retryAfterSeconds */),
+				);
 			}
 			const ackNackOp = waitAckNackResult.value;
 			this.pendingAckTimer.clear();
@@ -469,9 +485,10 @@ export class SummaryGenerator {
 				const errorMessage = summaryNack?.message;
 				const retryAfterSeconds = summaryNack?.retryAfter;
 
+				const errorCode: SummarizeErrorCode = "summaryNack";
+
 				// pre-0.58 error message prefix: summaryNack
-				const error = new LoggingError(`Received summaryNack`, {
-					retryAfterSeconds,
+				const error = new RetriableSummaryError(getFailMessage(errorCode), retryAfterSeconds, {
 					errorMessage,
 				});
 
@@ -481,11 +498,11 @@ export class SummaryGenerator {
 				);
 				// This will only set resultsBuilder.receivedSummaryAckOrNack, as other promises are already set.
 				return fail(
-					"summaryNack",
+					errorCode,
 					error,
 					{ ...summarizeTelemetryProps, nackRetryAfter: retryAfterSeconds },
 					undefined /* submitFailureResult */,
-					{ summaryNackOp: ackNackOp, ackNackDuration, retryAfterSeconds },
+					{ summaryNackOp: ackNackOp, ackNackDuration },
 				);
 			}
 		} finally {

package/src/summary/summaryManager.ts

@@ -89,7 +89,10 @@ export interface ISummaryManagerConfig {
  * It observes changes in calculated summarizer and reacts to changes by either creating summarizer client or
  * stopping existing summarizer client.
  */
-export class SummaryManager extends TypedEventEmitter<ISummarizerEvents> implements IDisposable {
+export class SummaryManager
+	extends TypedEventEmitter<ISummarizerEvents>
+	implements IDisposable
+{
 	private readonly logger: ITelemetryLoggerExt;
 	private readonly opsToBypassInitialDelay: number;
 	private readonly initialDelayMs: number;
@@ -263,10 +266,7 @@ export class SummaryManager extends TypedEventEmitter<ISummarizerEvents> impleme
 				// when the electedClient will be replaced with the new summarizer client.
 				// The alternative would be to let connectedState.clientId !== clientElection.electedClientId when
 				// state === Starting || state === Running.
-				assert(
-					this.state === SummaryManagerState.Starting,
-					0x263 /* "Expected: starting" */,
-				);
+				assert(this.state === SummaryManagerState.Starting, 0x263 /* "Expected: starting" */);
 				this.state = SummaryManagerState.Running;
 
 				const summarizer = await this.createSummarizerFn();
@@ -326,10 +326,7 @@ export class SummaryManager extends TypedEventEmitter<ISummarizerEvents> impleme
 				// means it also lost connection), and error happened on load (we do not have summarizer).
 				// We could annotate the error raised in Container.load where the container closed during load with no error
 				// and check for that case here, but that does not seem to be necessary.
-				if (
-					this.getShouldSummarizeState().shouldSummarize ||
-					this.summarizer !== undefined
-				) {
+				if (this.getShouldSummarizeState().shouldSummarize || this.summarizer !== undefined) {
 					// Report any failure as an error unless it was due to cancellation (like "disconnected" error)
 					// If failure happened on container load, we may not yet realized that socket disconnected, so check
 					// offlineError.

package/src/throttler.ts

@@ -52,7 +52,9 @@ export class Throttler implements IThrottler {
 	 * by adding the delay time to the actual time.
 	 */
 	public get latestAttemptTime() {
-		return this.startTimes.length > 0 ? this.startTimes[this.startTimes.length - 1] : undefined;
+		return this.startTimes.length > 0
+			? this.startTimes[this.startTimes.length - 1]
+			: undefined;
 	}
 
 	constructor(

package/tsconfig.json

@@ -5,5 +5,7 @@
 	"compilerOptions": {
 		"rootDir": "./src",
 		"outDir": "./lib",
+		"noUncheckedIndexedAccess": false,
+		"exactOptionalPropertyTypes": false,
 	},
 }

package/tsdoc.json

@@ -0,0 +1,4 @@
+{
+	"$schema": "https://developer.microsoft.com/json-schemas/tsdoc/v0/tsdoc.schema.json",
+	"extends": ["../../../common/build/build-common/tsdoc-base.json"]
+}