@fluidframework/container-runtime 2.70.0-361788 → 2.71.0

package/src/channelCollection.ts

@@ -11,7 +11,10 @@ import type {
 	IResponse,
 	ITelemetryBaseLogger,
 } from "@fluidframework/core-interfaces";
-import type { IFluidHandleInternal } from "@fluidframework/core-interfaces/internal";
+import type {
+	IFluidHandleInternal,
+	ISignalEnvelope,
+} from "@fluidframework/core-interfaces/internal";
 import { assert, Lazy, LazyPromise } from "@fluidframework/core-utils/internal";
 import { FluidObjectHandle } from "@fluidframework/datastore/internal";
 import type {
@@ -24,29 +27,33 @@ import {
 	getSnapshotTree,
 	isInstanceOfISnapshot,
 } from "@fluidframework/driver-utils/internal";
+import type {
+	AliasResult,
+	ContainerExtensionProvider,
+	FluidDataStoreMessage,
+	IAttachMessage,
+	IEnvelope,
+	IFluidDataStoreChannel,
+	IFluidDataStoreContext,
+	IFluidDataStoreContextDetached,
+	IFluidDataStoreFactory,
+	IFluidDataStoreRegistry,
+	IFluidParentContext,
+	IGarbageCollectionData,
+	IInboundSignalMessage,
+	InboundAttachMessage,
+	IRuntimeMessageCollection,
+	IRuntimeMessagesContent,
+	ISummarizeResult,
+	ISummaryTreeWithStats,
+	ITelemetryContext,
+	MinimumVersionForCollab,
+	NamedFluidDataStoreRegistryEntries,
+} from "@fluidframework/runtime-definitions/internal";
 import {
-	type ISummaryTreeWithStats,
-	type ITelemetryContext,
-	type IGarbageCollectionData,
-	type AliasResult,
 	CreateSummarizerNodeSource,
-	type IAttachMessage,
-	type IEnvelope,
-	type IFluidDataStoreChannel,
-	type IFluidDataStoreContext,
-	type IFluidDataStoreContextDetached,
-	type IFluidDataStoreFactory,
-	type IFluidDataStoreRegistry,
-	type IFluidParentContext,
-	type ISummarizeResult,
-	type NamedFluidDataStoreRegistryEntries,
 	channelsTreeName,
-	type IInboundSignalMessage,
 	gcDataBlobKey,
-	type IRuntimeMessagesContent,
-	type InboundAttachMessage,
-	type IRuntimeMessageCollection,
-	type MinimumVersionForCollab,
 } from "@fluidframework/runtime-definitions/internal";
 import {
 	GCDataBuilder,
@@ -89,7 +96,7 @@ import {
 } from "./dataStore.js";
 import {
 	FluidDataStoreContext,
-	type IFluidDataStoreContextInternal,
+	type IFluidDataStoreContextPrivate,
 	type ILocalDetachedFluidDataStoreContextProps,
 	LocalDetachedFluidDataStoreContext,
 	LocalFluidDataStoreContext,
@@ -99,6 +106,11 @@ import {
 import { DataStoreContexts } from "./dataStoreContexts.js";
 import { FluidDataStoreRegistry } from "./dataStoreRegistry.js";
 import { GCNodeType, type IGCNodeUpdatedProps, urlToGCNodePath } from "./gc/index.js";
+import type {
+	ContainerRuntimeAliasMessage,
+	ContainerRuntimeDataStoreOpMessage,
+	OutboundContainerRuntimeAttachMessage,
+} from "./messageTypes.js";
 import { ContainerMessageType, type LocalContainerRuntimeMessage } from "./messageTypes.js";
 import { StorageServiceWithAttachBlobs } from "./storageServiceWithAttachBlobs.js";
 import {
@@ -115,10 +127,16 @@ export const AllowTombstoneRequestHeaderKey = "allowTombstone"; // Belongs in th
 
 type PendingAliasResolve = (success: boolean) => void;
 
-interface FluidDataStoreMessage {
-	content: unknown;
-	type: string;
-}
+/**
+ * Envelope for signals not intended for the container.
+ *
+ * @privateRemarks
+ * `clientBroadcastSignalSequenceNumber` might be added to the envelope by the container runtime.
+ * But it should not be provided to start with.
+ *
+ * Equivalent to `Required<Omit<ISignalEnvelope, "clientBroadcastSignalSequenceNumber">>`.
+ */
+export type AddressedUnsequencedSignalEnvelope = IEnvelope<ISignalEnvelope["contents"]>;
 
 /**
  * This version of the interface is private to this the package. It should never be exported under any tag.
@@ -129,19 +147,64 @@ interface FluidDataStoreMessage {
  * to ease interactions within this package.
  */
 export interface IFluidParentContextPrivate
-	extends Omit<IFluidParentContext, "isReadOnly" | "minVersionForCollab"> {
+	extends IFluidParentContext,
+		ContainerExtensionProvider {
 	readonly isReadOnly: () => boolean;
+	readonly minVersionForCollab: MinimumVersionForCollab;
+}
 
+/**
+ * Kin of {@link @fluidframework/runtime-definitions#IFluidParentContext} with alternate
+ * `submitMessage` and `submitSignal` methods that are typed specifically for the
+ * root context (aka {@link ContainerRuntime} provided context).
+ *
+ * @privateRemarks
+ * These replacements might be able to get cleaned up if the future suggestions
+ * found in {@link @fluidframework/runtime-definitions#FluidDataStoreMessage}
+ * `@privateRemarks` section are implemented.
+ */
+export interface IFluidRootParentContextPrivate
+	extends Omit<IFluidParentContextPrivate, "submitMessage" | "submitSignal"> {
 	/**
-	 * {@inheritdoc IFluidParentContext.minVersionForCollab}
+	 * Submits the message to be sent to other clients.
+	 * @param containerRuntimeMessage - The message.
+	 * @param localOpMetadata - The local metadata associated with the message.
+	 * This is kept locally and not sent to the server. This will be sent back
+	 * when this message is received back from the server. This is also sent if
+	 * we are asked to resubmit the message.
 	 */
-	readonly minVersionForCollab: MinimumVersionForCollab;
+	readonly submitMessage: (
+		containerRuntimeMessage:
+			| ContainerRuntimeDataStoreOpMessage
+			| OutboundContainerRuntimeAttachMessage
+			| ContainerRuntimeAliasMessage,
+		localOpMetadata: unknown,
+	) => void;
+	/**
+	 * Submits the signal to be sent to other clients.
+	 * @param envelope - {@link IEnvelope} containing the signal address and contents.
+	 * @param targetClientId - When specified, the signal is only sent to the provided client id.
+	 */
+	readonly submitSignal: (
+		envelope: AddressedUnsequencedSignalEnvelope,
+		targetClientId?: string,
+	) => void;
 }
 
+type SubmitKeys = "submitMessage" | "submitSignal";
+
 /**
- * Creates a shallow wrapper of {@link IFluidParentContext}. The wrapper can then have its methods overwritten as needed
+ * Creates a shallow wrapper of {@link IFluidParentContextPrivate} or
+ * {@link IFluidRootParentContextPrivate} with `submitMessage` and `submitSignal`
+ * methods replaced with the provided overrides.
  */
-export function wrapContext(context: IFluidParentContextPrivate): IFluidParentContextPrivate {
+export function formParentContext<
+	T extends IFluidParentContextPrivate | IFluidRootParentContextPrivate,
+>(
+	context: Omit<IFluidParentContextPrivate & IFluidRootParentContextPrivate, SubmitKeys>,
+	overrides: Pick<T, SubmitKeys>,
+): Omit<IFluidParentContextPrivate & IFluidRootParentContextPrivate, SubmitKeys> &
+	Pick<T, SubmitKeys> {
 	return {
 		get IFluidDataStoreRegistry() {
 			return context.IFluidDataStoreRegistry;
@@ -181,12 +244,8 @@ export function wrapContext(context: IFluidParentContextPrivate): IFluidParentCo
 		getAudience: (...args) => {
 			return context.getAudience(...args);
 		},
-		submitMessage: (...args) => {
-			return context.submitMessage(...args);
-		},
-		submitSignal: (...args) => {
-			return context.submitSignal(...args);
-		},
+		submitMessage: overrides.submitMessage.bind(overrides),
+		submitSignal: overrides.submitSignal,
 		makeLocallyVisible: (...args) => {
 			return context.makeLocallyVisible(...args);
 		},
@@ -206,46 +265,41 @@ export function wrapContext(context: IFluidParentContextPrivate): IFluidParentCo
 			return context.setChannelDirty(address);
 		},
 		minVersionForCollab: context.minVersionForCollab,
+		getExtension: context.getExtension.bind(context),
 	};
 }
 
 /**
- * Creates a wrapper of a {@link IFluidParentContext} to be provided to the inner datastore channels.
+ * Creates a wrapper of a {@link IFluidRootParentContextPrivate} to be provided to the inner datastore channels.
  * The wrapper will have the submit methods overwritten with the appropriate id as the destination address.
  *
  * @param id - the id of the channel
- * @param parentContext - the {@link IFluidParentContext} to wrap
+ * @param parentContext - the {@link IFluidRootParentContextPrivate} to wrap
  * @returns A wrapped {@link IFluidParentContext}
  */
 function wrapContextForInnerChannel(
 	id: string,
-	parentContext: IFluidParentContextPrivate,
+	parentContext: IFluidRootParentContextPrivate,
 ): IFluidParentContextPrivate {
-	const context = wrapContext(parentContext);
-
-	context.submitMessage = (type: string, content: unknown, localOpMetadata: unknown) => {
-		const fluidDataStoreContent: FluidDataStoreMessage = {
-			content,
-			type,
-		};
-		const envelope: IEnvelope = {
-			address: id,
-			contents: fluidDataStoreContent,
-		};
-		parentContext.submitMessage(
-			ContainerMessageType.FluidDataStoreOp,
-			envelope,
-			localOpMetadata,
-		);
-	};
-
-	context.submitSignal = (type: string, contents: unknown, targetClientId?: string) => {
-		const envelope: IEnvelope = {
-			address: id,
-			contents,
-		};
-		parentContext.submitSignal(type, envelope, targetClientId);
-	};
+	const context = formParentContext<IFluidParentContextPrivate>(parentContext, {
+		submitMessage: (type: string, content: unknown, localOpMetadata: unknown) => {
+			const fluidDataStoreContent: FluidDataStoreMessage = {
+				content,
+				type,
+			};
+			const envelope = {
+				address: id,
+				contents: fluidDataStoreContent,
+			};
+			parentContext.submitMessage(
+				{ type: ContainerMessageType.FluidDataStoreOp, contents: envelope },
+				localOpMetadata,
+			);
+		},
+		submitSignal: (type: string, content: unknown, targetClientId?: string) => {
+			parentContext.submitSignal({ address: id, contents: { type, content } }, targetClientId);
+		},
+	});
 
 	return context;
 }
@@ -262,7 +316,9 @@ export function getLocalDataStoreType(localDataStore: LocalFluidDataStoreContext
  * but eventually could be hosted on any channel once we formalize the channel api boundary.
  * @internal
  */
-export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
+export class ChannelCollection
+	implements Omit<IFluidDataStoreChannel, "entryPoint" | "reSubmit" | "rollback">, IDisposable
+{
 	// Stores tracked by the Domain
 	private readonly pendingAttach = new Map<string, IAttachMessage>();
 	// 0.24 back-compat attachingBeforeSummary
@@ -273,8 +329,6 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 	// eslint-disable-next-line unicorn/consistent-function-scoping -- Property is defined once; no need to extract inner lambda
 	private readonly disposeOnce = new Lazy<void>(() => this.contexts.dispose());
 
-	public readonly entryPoint: IFluidHandleInternal<FluidObject>;
-
 	public readonly containerLoadStats: {
 		// number of dataStores during loadContainer
 		readonly containerLoadDataStoreCount: number;
@@ -292,20 +346,14 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 
 	constructor(
 		protected readonly baseSnapshot: ISnapshotTree | ISnapshot | undefined,
-		public readonly parentContext: IFluidParentContextPrivate,
+		public readonly parentContext: IFluidRootParentContextPrivate,
 		baseLogger: ITelemetryBaseLogger,
 		private readonly gcNodeUpdated: (props: IGCNodeUpdatedProps) => void,
 		private readonly isDataStoreDeleted: (nodePath: string) => boolean,
 		private readonly aliasMap: Map<string, string>,
-		provideEntryPoint: (runtime: ChannelCollection) => Promise<FluidObject>,
 	) {
 		this.mc = createChildMonitoringContext({ logger: baseLogger });
 		this.contexts = new DataStoreContexts(baseLogger);
-		this.entryPoint = new FluidObjectHandle<FluidObject>(
-			new LazyPromise(async () => provideEntryPoint(this)),
-			"",
-			this.parentContext.IFluidHandleContext,
-		);
 		this.aliasedDataStores = new Set(aliasMap.values());
 
 		// Extract stores stored inside the snapshot
@@ -605,7 +653,10 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 	protected submitAttachChannelOp(localContext: LocalFluidDataStoreContext): void {
 		const message = this.generateAttachMessage(localContext);
 		this.pendingAttach.set(localContext.id, message);
-		this.parentContext.submitMessage(ContainerMessageType.Attach, message, undefined);
+		this.parentContext.submitMessage(
+			{ type: ContainerMessageType.Attach, contents: message },
+			undefined,
+		);
 		this.attachOpFiredForDataStore.add(localContext.id);
 	}
 
@@ -664,7 +715,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 	public createDataStoreContext(
 		pkg: readonly string[],
 		loadingGroupId?: string,
-	): IFluidDataStoreContextInternal {
+	): IFluidDataStoreContextPrivate {
 		return this.createContext(
 			this.createDataStoreId(),
 			pkg,
@@ -712,34 +763,34 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 		return this.disposeOnce.value;
 	}
 
-	public reSubmit(
-		type: string,
-		content: unknown,
+	public readonly reSubmitContainerMessage = (
+		message:
+			| ContainerRuntimeDataStoreOpMessage
+			| OutboundContainerRuntimeAttachMessage
+			| ContainerRuntimeAliasMessage,
 		localOpMetadata: unknown,
-		squash: boolean,
-	): void {
-		switch (type) {
+		squash: boolean | undefined,
+	): void => {
+		switch (message.type) {
 			case ContainerMessageType.Attach:
 			case ContainerMessageType.Alias: {
-				this.parentContext.submitMessage(type, content, localOpMetadata);
+				this.parentContext.submitMessage(message, localOpMetadata);
 				return;
 			}
 			case ContainerMessageType.FluidDataStoreOp: {
-				return this.reSubmitChannelOp(type, content, localOpMetadata, squash);
+				return this.resubmitDataStoreOp(message.contents, localOpMetadata, squash);
 			}
 			default: {
 				assert(false, 0x907 /* unknown op type */);
 			}
 		}
-	}
+	};
 
-	protected reSubmitChannelOp(
-		type: string,
-		content: unknown,
+	protected readonly resubmitDataStoreOp = (
+		envelope: IEnvelope<FluidDataStoreMessage>,
 		localOpMetadata: unknown,
-		squash: boolean,
-	): void {
-		const envelope = content as IEnvelope;
+		squash: boolean | undefined,
+	): void => {
 		const context = this.contexts.get(envelope.address);
 		// If the data store has been deleted, log an error and throw an error. If there are local changes for a
 		// deleted data store, it can otherwise lead to inconsistent state when compared to other clients.
@@ -752,13 +803,13 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 			});
 		}
 		assert(!!context, 0x160 /* "There should be a store context for the op" */);
-		const innerContents = envelope.contents as FluidDataStoreMessage;
-		context.reSubmit(innerContents.type, innerContents.content, localOpMetadata, squash);
-	}
+		context.reSubmit(envelope.contents, localOpMetadata, squash);
+	};
 
-	public rollback(type: string, content: unknown, localOpMetadata: unknown): void {
-		assert(type === ContainerMessageType.FluidDataStoreOp, 0x8e8 /* type */);
-		const envelope = content as IEnvelope;
+	public readonly rollbackDataStoreOp = (
+		envelope: IEnvelope<FluidDataStoreMessage>,
+		localOpMetadata: unknown,
+	): void => {
 		const context = this.contexts.get(envelope.address);
 		// If the data store has been deleted, log an error and throw an error. If there are local changes for a
 		// deleted data store, it can otherwise lead to inconsistent state when compared to other clients.
@@ -771,9 +822,8 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 			});
 		}
 		assert(!!context, 0x2e8 /* "There should be a store context for the op" */);
-		const innerContents = envelope.contents as FluidDataStoreMessage;
-		context.rollback(innerContents.type, innerContents.content, localOpMetadata);
-	}
+		context.rollback(envelope.contents, localOpMetadata);
+	};
 
 	public async applyStashedOp(content: unknown): Promise<unknown> {
 		const opContents = content as LocalContainerRuntimeMessage;
@@ -907,7 +957,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 		 * like merge tree or shared tree can process ops more efficiently when they are bunched together.
 		 */
 		for (const { contents, ...restOfMessagesContent } of messagesContent) {
-			const contentsEnvelope = contents as IEnvelope;
+			const contentsEnvelope = contents as IEnvelope<FluidDataStoreMessage>;
 			const address = contentsEnvelope.address;
 			const context = this.contexts.get(address);
 
@@ -934,8 +984,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 				);
 			}
 
-			const { type: contextType, content: contextContents } =
-				contentsEnvelope.contents as FluidDataStoreMessage;
+			const { type: contextType, content: contextContents } = contentsEnvelope.contents;
 			// If the address or type of the message changes while processing the message, send the current bunch.
 			if (
 				currentMessageState?.address !== address ||
@@ -972,7 +1021,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 		id: string,
 		requestHeaderData: RuntimeHeaderData,
 		originalRequest: IRequest,
-	): Promise<IFluidDataStoreContextInternal> {
+	): Promise<IFluidDataStoreContextPrivate> {
 		const headerData = { ...defaultRuntimeHeaderData, ...requestHeaderData };
 		if (
 			this.checkAndLogIfDeleted(
@@ -1008,7 +1057,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 	public async getDataStoreIfAvailable(
 		id: string,
 		requestHeaderData: RuntimeHeaderData,
-	): Promise<IFluidDataStoreContextInternal | undefined> {
+	): Promise<IFluidDataStoreContextPrivate | undefined> {
 		// If the data store has been deleted, log an error and return undefined.
 		if (
 			this.checkAndLogIfDeleted(
@@ -1675,7 +1724,102 @@ export function detectOutboundReferences(
 	}
 }
 
+// #region Experimentation
+// The code below here is for experimentation (and one test) only.
+
+/**
+ * @privateRemarks This class is only used for experimentation/testing.
+ */
+export class ComposableChannelCollection
+	extends ChannelCollection
+	implements IFluidDataStoreChannel
+{
+	public readonly entryPoint: IFluidHandleInternal<FluidObject>;
+
+	public constructor(
+		baseSnapshot: ISnapshotTree | ISnapshot | undefined,
+		parentContext: IFluidParentContextPrivate,
+		baseLogger: ITelemetryBaseLogger,
+		gcNodeUpdated: (props: IGCNodeUpdatedProps) => void,
+		isDataStoreDeleted: (nodePath: string) => boolean,
+		aliasMap: Map<string, string>,
+		provideEntryPoint: (runtime: ComposableChannelCollection) => Promise<FluidObject>,
+	) {
+		super(
+			baseSnapshot,
+			/* [root] parentContext */
+			formParentContext<IFluidRootParentContextPrivate>(parentContext, {
+				submitMessage: (
+					containerRuntimeMessage:
+						| ContainerRuntimeDataStoreOpMessage
+						| OutboundContainerRuntimeAttachMessage
+						| ContainerRuntimeAliasMessage,
+					localOpMetadata: unknown,
+				): void => {
+					// Note that here our message format is reconfigured.
+					// While `ContainerRuntime*Message`s use `contents`
+					// as `FluidDataStoreMessage`s, the content is
+					// stored in `content`.
+					parentContext.submitMessage(
+						containerRuntimeMessage.type,
+						containerRuntimeMessage.contents,
+						localOpMetadata,
+					);
+				},
+				submitSignal: (
+					envelope: AddressedUnsequencedSignalEnvelope,
+					targetClientId?: string,
+				): void => {
+					parentContext.submitSignal(
+						envelope.contents.type,
+						{
+							address: envelope.address,
+							contents: envelope.contents.content,
+						} satisfies IEnvelope<unknown>,
+						targetClientId,
+					);
+				},
+			}),
+			baseLogger,
+			gcNodeUpdated,
+			isDataStoreDeleted,
+			aliasMap,
+		);
+		this.entryPoint = new FluidObjectHandle<FluidObject>(
+			new LazyPromise(async () => provideEntryPoint(this)),
+			"",
+			this.parentContext.IFluidHandleContext,
+		);
+	}
+
+	public reSubmit(
+		type: string,
+		content: unknown,
+		localOpMetadata: unknown,
+		squash?: boolean,
+	): void {
+		// If the cast is incorrect and type is not one of the three supported,
+		// reSubmitContainerMessage will assert.
+		// eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Need to force conversion
+		const message = {
+			type,
+			contents: content,
+		} as
+			| ContainerRuntimeDataStoreOpMessage
+			| OutboundContainerRuntimeAttachMessage
+			| ContainerRuntimeAliasMessage;
+		this.reSubmitContainerMessage(message, localOpMetadata, squash);
+	}
+
+	public rollback(type: string, content: unknown, localOpMetadata: unknown): void {
+		assert(type === ContainerMessageType.FluidDataStoreOp, 0x8e8 /* type */);
+		this.rollbackDataStoreOp(content as IEnvelope<FluidDataStoreMessage>, localOpMetadata);
+	}
+}
+
 /**
+ * @privateRemarks This factory is only used for experimentation/testing.
+ *
  * @internal
  */
 export class ChannelCollectionFactory implements IFluidDataStoreFactory {
@@ -1715,16 +1859,18 @@ export class ChannelCollectionFactory implements IFluidDataStoreFactory {
 			0xb8f /* we don't support the layer boundary here today */,
 		);
 
-		const runtime = new ChannelCollection(
+		const runtime = new ComposableChannelCollection(
 			context.baseSnapshot,
-			context, // parentContext
+			/* parentContext */ context,
 			context.baseLogger,
-			() => {}, // gcNodeUpdated
-			(_nodePath: string) => false, // isDataStoreDeleted
+			/* gcNodeUpdated */ () => {},
+			/* isDataStoreDeleted */ (_nodePath: string) => false,
 			new Map(), // aliasMap
 			this.provideEntryPoint,
 		);
 
 		return runtime;
 	}
+
+	// #endregion Experimentation
 }