@fluidframework/datastore 2.5.0-302463 → 2.5.0

package/src/dataStoreRuntime.ts

@@ -54,6 +54,8 @@ import {
 	VisibilityState,
 	gcDataBlobKey,
 	IInboundSignalMessage,
+	type IRuntimeMessageCollection,
+	type IRuntimeMessagesContent,
 } from "@fluidframework/runtime-definitions/internal";
 import {
 	GCDataBuilder,
@@ -356,6 +358,18 @@ export class FluidDataStoreRuntime
 	public async request(request: IRequest): Promise<IResponse> {
 		try {
 			const parser = RequestParser.create(request);
+			// If there are not path parts, and the request is via a handle
+			// then we should return the entrypoint object for this runtime.
+			// This allows the entrypoint handle to be resolved without the need
+			// for the entrypoint object to know anything about requests or handles.
+			//
+			// This works because the entrypoint handle is an object handle,
+			// which always has a real reference to the object itself.
+			// Those get serialized and then deserialized into a plain handle, which really just has a path,
+			// resolution walks to the runtime, which calls this, and get the true object off the internal object handle
+			if (parser.pathParts.length === 0 && request.headers?.viaHandle === true) {
+				return { mimeType: "fluid/object", status: 200, value: await this.entryPoint.get() };
+			}
 			const id = parser.pathParts[0];
 
 			if (id === "_channels" || id === "_custom") {
@@ -650,66 +664,151 @@ export class FluidDataStoreRuntime
 		);
 	}
 
-	public process(
-		message: ISequencedDocumentMessage,
-		local: boolean,
-		localOpMetadata: unknown,
-	) {
+	/**
+	 * Process channel messages. The messages here are contiguous channel types messages in a batch for this data
+	 * store.
+	 * @param messageCollection - The collection of messages to process.
+	 */
+	private processChannelMessages(messageCollection: IRuntimeMessageCollection) {
 		this.verifyNotClosed();
 
-		try {
-			// catches as data processing error whether or not they come from async pending queues
-			switch (message.type) {
-				case DataStoreMessageType.Attach: {
-					const attachMessage = message.contents as IAttachMessage;
-					const id = attachMessage.id;
-
-					// We need to process the GC Data for both local and remote attach messages
-					processAttachMessageGCData(attachMessage.snapshot, (nodeId, toPath) => {
-						// Note: nodeId will be "/" unless and until we support sub-DDS GC Nodes
-						const fromPath = `/${this.id}/${id}${nodeId === "/" ? "" : nodeId}`;
-						this.dataStoreContext.addedGCOutboundRoute(fromPath, toPath, message.timestamp);
-					});
-
-					// If a non-local operation then go and create the object
-					// Otherwise mark it as officially attached.
-					if (local) {
-						assert(
-							this.pendingAttach.delete(id),
-							0x17c /* "Unexpected attach (local) channel OP" */,
-						);
-					} else {
-						assert(!this.contexts.has(id), 0x17d /* "Unexpected attach channel OP" */);
-
-						const summarizerNodeParams = {
-							type: CreateSummarizerNodeSource.FromAttach,
-							sequenceNumber: message.sequenceNumber,
-							snapshot: attachMessage.snapshot,
-						};
-
-						const remoteChannelContext = this.createRemoteChannelContext(
-							attachMessage,
-							summarizerNodeParams,
-						);
-						this.contexts.set(id, remoteChannelContext);
-					}
-					break;
-				}
+		/*
+		 * Bunch contiguous messages for the same channel and send them together.
+		 * This is an optimization where DDSes can process a bunch of ops together. DDSes
+		 * like merge tree or shared tree can process ops more efficiently when they are bunched together.
+		 */
+		let currentAddress: string | undefined;
+		let currentMessagesContent: IRuntimeMessagesContent[] = [];
+		const { messagesContent, local } = messageCollection;
+
+		const sendBunchedMessages = () => {
+			// Current address will be undefined for the first message in the list.
+			if (currentAddress === undefined) {
+				return;
+			}
+
+			// process the last set of channel ops
+			const channelContext = this.contexts.get(currentAddress);
+			assert(!!channelContext, 0xa6b /* Channel context not found */);
+
+			channelContext.processMessages({
+				envelope: messageCollection.envelope,
+				messagesContent: currentMessagesContent,
+				local,
+			});
+
+			currentMessagesContent = [];
+		};
+
+		for (const { contents, ...restOfMessagesContent } of messagesContent) {
+			const contentsEnvelope = contents as IEnvelope;
+
+			// If the address of the message changes while processing the batch, send the current bunch.
+			if (currentAddress !== contentsEnvelope.address) {
+				sendBunchedMessages();
+			}
+
+			currentMessagesContent.push({
+				contents: contentsEnvelope.contents,
+				...restOfMessagesContent,
+			});
+			currentAddress = contentsEnvelope.address;
+		}
+
+		// Process the last bunch of messages.
+		sendBunchedMessages();
+	}
+
+	private processAttachMessages(messageCollection: IRuntimeMessageCollection) {
+		const { envelope, messagesContent, local } = messageCollection;
+		for (const { contents } of messagesContent) {
+			const attachMessage = contents as IAttachMessage;
+			const id = attachMessage.id;
+
+			// We need to process the GC Data for both local and remote attach messages
+			processAttachMessageGCData(attachMessage.snapshot, (nodeId, toPath) => {
+				// Note: nodeId will be "/" unless and until we support sub-DDS GC Nodes
+				const fromPath = `/${this.id}/${id}${nodeId === "/" ? "" : nodeId}`;
+				this.dataStoreContext.addedGCOutboundRoute(fromPath, toPath, envelope.timestamp);
+			});
+
+			// If a non-local operation then go and create the object
+			// Otherwise mark it as officially attached.
+			if (local) {
+				assert(
+					this.pendingAttach.delete(id),
+					0x17c /* "Unexpected attach (local) channel OP" */,
+				);
+			} else {
+				assert(!this.contexts.has(id), 0x17d /* "Unexpected attach channel OP" */);
+
+				const summarizerNodeParams = {
+					type: CreateSummarizerNodeSource.FromAttach,
+					sequenceNumber: envelope.sequenceNumber,
+					snapshot: attachMessage.snapshot,
+				};
+
+				const remoteChannelContext = this.createRemoteChannelContext(
+					attachMessage,
+					summarizerNodeParams,
+				);
+				this.contexts.set(id, remoteChannelContext);
+			}
+		}
+	}
+
+	/**
+	 * Process messages for this data store. The messages here are contiguous messages in a batch.
+	 * @param messageCollection - The collection of messages to process.
+	 */
+	public processMessages(messageCollection: IRuntimeMessageCollection): void {
+		this.verifyNotClosed();
 
+		const { envelope, messagesContent } = messageCollection;
+		try {
+			switch (envelope.type) {
 				case DataStoreMessageType.ChannelOp:
-					this.processChannelOp(message, local, localOpMetadata);
+					this.processChannelMessages(messageCollection);
+					break;
+				case DataStoreMessageType.Attach:
+					this.processAttachMessages(messageCollection);
 					break;
 				default:
 			}
-
-			this.emit("op", message);
 		} catch (error) {
 			throw DataProcessingError.wrapIfUnrecognized(
 				error,
 				"fluidDataStoreRuntimeFailedToProcessMessage",
-				message,
+				envelope,
 			);
 		}
+
+		for (const { contents, clientSequenceNumber } of messagesContent) {
+			this.emit("op", { ...envelope, contents, clientSequenceNumber });
+		}
+	}
+
+	/**
+	 * back-compat ADO 21575.
+	 * This is still here for back-compat purposes because it exists on IFluidDataStoreChannel. Once it is removed from
+	 * the interface, this method can be removed.
+	 */
+	public process(
+		message: ISequencedDocumentMessage,
+		local: boolean,
+		localOpMetadata: unknown,
+	) {
+		this.processMessages({
+			envelope: message,
+			messagesContent: [
+				{
+					contents: message.contents,
+					localOpMetadata,
+					clientSequenceNumber: message.clientSequenceNumber,
+				},
+			],
+			local,
+		});
 	}
 
 	public processSignal(message: IInboundSignalMessage, local: boolean) {
@@ -1126,27 +1225,6 @@ export class FluidDataStoreRuntime
 		this.dataStoreContext.setChannelDirty(address);
 	}
 
-	private processChannelOp(
-		message: ISequencedDocumentMessage,
-		local: boolean,
-		localOpMetadata: unknown,
-	) {
-		this.verifyNotClosed();
-
-		const envelope = message.contents as IEnvelope;
-
-		const transformed: ISequencedDocumentMessage = {
-			...message,
-			contents: envelope.contents,
-		};
-
-		const channelContext = this.contexts.get(envelope.address);
-		assert(!!channelContext, 0x185 /* "Channel not found" */);
-		channelContext.processOp(transformed, local, localOpMetadata);
-
-		return channelContext;
-	}
-
 	private attachListener() {
 		this.setMaxListeners(Number.MAX_SAFE_INTEGER);
 

package/src/localChannelContext.ts

@@ -12,13 +12,14 @@ import {
 import {
 	IDocumentStorageService,
 	ISnapshotTree,
-	ISequencedDocumentMessage,
 } from "@fluidframework/driver-definitions/internal";
 import {
 	ITelemetryContext,
 	IFluidDataStoreContext,
 	IGarbageCollectionData,
 	ISummarizeResult,
+	type IPendingMessagesState,
+	type IRuntimeMessageCollection,
 } from "@fluidframework/runtime-definitions/internal";
 import {
 	ITelemetryLoggerExt,
@@ -41,7 +42,11 @@ import { ISharedObjectRegistry } from "./dataStoreRuntime.js";
  */
 export abstract class LocalChannelContextBase implements IChannelContext {
 	private globallyVisible = false;
-	protected readonly pending: ISequencedDocumentMessage[] = [];
+	/** Tracks the messages for this channel that are sent while it's not loaded */
+	protected pendingMessagesState: IPendingMessagesState = {
+		messageCollections: [],
+		pendingCount: 0,
+	};
 	constructor(
 		protected readonly id: string,
 		protected readonly runtime: IFluidDataStoreRuntime,
@@ -74,11 +79,11 @@ export abstract class LocalChannelContextBase implements IChannelContext {
 		}
 	}
 
-	public processOp(
-		message: ISequencedDocumentMessage,
-		local: boolean,
-		localOpMetadata: unknown,
-	): void {
+	/**
+	 * Process messages for this channel context. The messages here are contiguous messages for this context in a batch.
+	 * @param messageCollection - The collection of messages to process.
+	 */
+	processMessages(messageCollection: IRuntimeMessageCollection): void {
 		assert(
 			this.globallyVisible,
 			0x2d3 /* "Local channel must be globally visible when processing op" */,
@@ -88,13 +93,17 @@ export abstract class LocalChannelContextBase implements IChannelContext {
 		// delay loading. So after the container is attached and some other client joins which start generating
 		// ops for this channel. So not loaded local channel can still receive ops and we store them to process later.
 		if (this.isLoaded) {
-			this.services.value.deltaConnection.process(message, local, localOpMetadata);
+			this.services.value.deltaConnection.processMessages(messageCollection);
 		} else {
 			assert(
-				local === false,
+				!messageCollection.local,
 				0x189 /* "Should always be remote because a local dds shouldn't generate ops before loading" */,
 			);
-			this.pending.push(message);
+			const propsCopy = {
+				...messageCollection,
+				messagesContent: Array.from(messageCollection.messagesContent),
+			};
+			this.pendingMessagesState.messageCollections.push(propsCopy);
 		}
 	}
 
@@ -254,12 +263,8 @@ export class RehydratedLocalChannelContext extends LocalChannelContextBase {
 						this.id,
 					);
 					// Send all pending messages to the channel
-					for (const message of this.pending) {
-						this.services.value.deltaConnection.process(
-							message,
-							false,
-							undefined /* localOpMetadata */,
-						);
+					for (const messageCollection of this.pendingMessagesState.messageCollections) {
+						this.services.value.deltaConnection.processMessages(messageCollection);
 					}
 					return channel;
 				} catch (err) {

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/datastore";
-export const pkgVersion = "2.5.0-302463";
+export const pkgVersion = "2.5.0";

package/src/remoteChannelContext.ts

@@ -12,7 +12,6 @@ import {
 import {
 	IDocumentStorageService,
 	ISnapshotTree,
-	ISequencedDocumentMessage,
 } from "@fluidframework/driver-definitions/internal";
 import {
 	IExperimentalIncrementalSummaryContext,
@@ -23,6 +22,8 @@ import {
 	ISummarizeInternalResult,
 	ISummarizeResult,
 	ISummarizerNodeWithGC,
+	type IPendingMessagesState,
+	type IRuntimeMessageCollection,
 } from "@fluidframework/runtime-definitions/internal";
 import {
 	ITelemetryLoggerExt,
@@ -42,7 +43,11 @@ import { ISharedObjectRegistry } from "./dataStoreRuntime.js";
 
 export class RemoteChannelContext implements IChannelContext {
 	private isLoaded = false;
-	private pending: ISequencedDocumentMessage[] | undefined = [];
+	/** Tracks the messages for this channel that are sent while it's not loaded */
+	private pendingMessagesState: IPendingMessagesState | undefined = {
+		messageCollections: [],
+		pendingCount: 0,
+	};
 	private readonly channelP: Promise<IChannel>;
 	private channel: IChannel | undefined;
 	private readonly services: ChannelServiceEndpoints;
@@ -100,16 +105,21 @@ export class RemoteChannelContext implements IChannelContext {
 				this.id,
 			);
 
-			// Send all pending messages to the channel
-			assert(this.pending !== undefined, 0x23f /* "pending undefined" */);
-			for (const message of this.pending) {
-				this.services.deltaConnection.process(message, false, undefined /* localOpMetadata */);
+			assert(
+				this.pendingMessagesState !== undefined,
+				0xa6c /* pending messages state is undefined */,
+			);
+			for (const messageCollection of this.pendingMessagesState.messageCollections) {
+				this.services.deltaConnection.processMessages(messageCollection);
 			}
-			this.thresholdOpsCounter.send("ProcessPendingOps", this.pending.length);
+			this.thresholdOpsCounter.send(
+				"ProcessPendingOps",
+				this.pendingMessagesState.pendingCount,
+			);
 
 			// Commit changes.
 			this.channel = channel;
-			this.pending = undefined;
+			this.pendingMessagesState = undefined;
 			this.isLoaded = true;
 
 			// Because have some await between we created the service and here, the connection state might have changed
@@ -161,20 +171,31 @@ export class RemoteChannelContext implements IChannelContext {
 		return this.services.deltaConnection.applyStashedOp(content);
 	}
 
-	public processOp(
-		message: ISequencedDocumentMessage,
-		local: boolean,
-		localOpMetadata: unknown,
-	): void {
-		this.summarizerNode.invalidate(message.sequenceNumber);
+	/**
+	 * Process messages for this channel context. The messages here are contiguous messages for this context in a batch.
+	 * @param messageCollection - The collection of messages to process.
+	 */
+	public processMessages(messageCollection: IRuntimeMessageCollection): void {
+		const { envelope, messagesContent, local } = messageCollection;
+		this.summarizerNode.invalidate(envelope.sequenceNumber);
 
 		if (this.isLoaded) {
-			this.services.deltaConnection.process(message, local, localOpMetadata);
+			this.services.deltaConnection.processMessages(messageCollection);
 		} else {
 			assert(!local, 0x195 /* "Remote channel must not be local when processing op" */);
-			assert(this.pending !== undefined, 0x23e /* "pending is undefined" */);
-			this.pending.push(message);
-			this.thresholdOpsCounter.sendIfMultiple("StorePendingOps", this.pending.length);
+			assert(
+				this.pendingMessagesState !== undefined,
+				0xa6d /* pending messages queue is undefined */,
+			);
+			this.pendingMessagesState.messageCollections.push({
+				...messageCollection,
+				messagesContent: Array.from(messagesContent),
+			});
+			this.pendingMessagesState.pendingCount += messagesContent.length;
+			this.thresholdOpsCounter.sendIfMultiple(
+				"StorePendingOps",
+				this.pendingMessagesState.pendingCount,
+			);
 		}
 	}