@fluidframework/container-runtime 2.5.0-302463 → 2.5.0

package/dist/channelCollection.js

@@ -38,14 +38,6 @@ var RuntimeHeaders;
  * @alpha
  */
 exports.AllowTombstoneRequestHeaderKey = "allowTombstone"; // Belongs in the enum above, but avoiding the breaking change
-function computeRuntimeHeaderData(config, data) {
-    return {
-        wait: config.getBoolean("Fluid.ContainerRuntime.WaitHeaderDefault") ?? true,
-        viaHandle: false,
-        allowTombstone: false,
-        ...data,
-    };
-}
 /**
  * Creates a shallow wrapper of {@link IFluidParentContext}. The wrapper can then have its methods overwritten as needed
  */
@@ -264,87 +256,93 @@ class ChannelCollection {
     makeVisibleAndAttachGraph() {
         this.parentContext.makeLocallyVisible();
     }
-    processAttachMessage(message, local) {
-        const attachMessage = message.contents;
-        // We need to process the GC Data for both local and remote attach messages
-        const foundGCData = (0, internal_5.processAttachMessageGCData)(attachMessage.snapshot, (nodeId, toPath) => {
-            // nodeId is the relative path under the node being attached. Always starts with "/", but no trailing "/" after an id
-            const fromPath = `/${attachMessage.id}${nodeId === "/" ? "" : nodeId}`;
-            this.parentContext.addedGCOutboundRoute(fromPath, toPath, message.timestamp);
-        });
-        // Only log once per container to avoid noise/cost.
-        // Allows longitudinal tracking of various state (e.g. foundGCData), and some sampled details
-        if (this.shouldSendAttachLog) {
-            this.shouldSendAttachLog = false;
-            this.mc.logger.sendTelemetryEvent({
-                eventName: "dataStoreAttachMessage_sampled",
-                ...(0, internal_6.tagCodeArtifacts)({ id: attachMessage.id, pkg: attachMessage.type }),
-                details: {
-                    local,
-                    snapshot: !!attachMessage.snapshot,
-                    foundGCData,
-                },
-                ...(0, internal_6.extractSafePropertiesFromMessage)(message),
-            });
-        }
-        // The local object has already been attached
-        if (local) {
-            (0, internal_1.assert)(this.pendingAttach.has(attachMessage.id), 0x15e /* "Local object does not have matching attach message id" */);
-            this.contexts.get(attachMessage.id)?.setAttachState(container_definitions_1.AttachState.Attached);
-            this.pendingAttach.delete(attachMessage.id);
-            return;
-        }
-        // If a non-local operation then go and create the object, otherwise mark it as officially attached.
-        if (this.alreadyProcessed(attachMessage.id)) {
-            // TODO: dataStoreId may require a different tag from PackageData #7488
-            const error = new internal_6.DataCorruptionError(
-            // pre-0.58 error message: duplicateDataStoreCreatedWithExistingId
-            "Duplicate DataStore created with existing id", {
-                ...(0, internal_6.extractSafePropertiesFromMessage)(message),
-                ...(0, internal_6.tagCodeArtifacts)({ dataStoreId: attachMessage.id }),
+    processAttachMessages(messageCollection) {
+        const { envelope, messagesContent, local } = messageCollection;
+        for (const { contents } of messagesContent) {
+            const attachMessage = contents;
+            // We need to process the GC Data for both local and remote attach messages
+            const foundGCData = (0, internal_5.processAttachMessageGCData)(attachMessage.snapshot, (nodeId, toPath) => {
+                // nodeId is the relative path under the node being attached. Always starts with "/", but no trailing "/" after an id
+                const fromPath = `/${attachMessage.id}${nodeId === "/" ? "" : nodeId}`;
+                this.parentContext.addedGCOutboundRoute(fromPath, toPath, envelope.timestamp);
             });
-            throw error;
-        }
-        const flatAttachBlobs = new Map();
-        let snapshot;
-        if (attachMessage.snapshot) {
-            snapshot = (0, internal_3.buildSnapshotTree)(attachMessage.snapshot.entries, flatAttachBlobs);
-            if ((0, internal_3.isInstanceOfISnapshot)(this.baseSnapshot)) {
-                snapshot = { ...this.baseSnapshot, snapshotTree: snapshot };
+            // Only log once per container to avoid noise/cost.
+            // Allows longitudinal tracking of various state (e.g. foundGCData), and some sampled details
+            if (this.shouldSendAttachLog) {
+                this.shouldSendAttachLog = false;
+                this.mc.logger.sendTelemetryEvent({
+                    eventName: "dataStoreAttachMessage_sampled",
+                    ...(0, internal_6.tagCodeArtifacts)({ id: attachMessage.id, pkg: attachMessage.type }),
+                    details: {
+                        local,
+                        snapshot: !!attachMessage.snapshot,
+                        foundGCData,
+                    },
+                    ...(0, internal_6.extractSafePropertiesFromMessage)(envelope),
+                });
             }
-        }
-        // Include the type of attach message which is the pkg of the store to be
-        // used by RemoteFluidDataStoreContext in case it is not in the snapshot.
-        const pkg = [attachMessage.type];
-        const remoteFluidDataStoreContext = new dataStoreContext_js_1.RemoteFluidDataStoreContext({
-            id: attachMessage.id,
-            snapshot,
-            parentContext: this.wrapContextForInnerChannel(attachMessage.id),
-            storage: new storageServiceWithAttachBlobs_js_1.StorageServiceWithAttachBlobs(this.parentContext.storage, flatAttachBlobs),
-            scope: this.parentContext.scope,
-            loadingGroupId: attachMessage.snapshot?.groupId,
-            createSummarizerNodeFn: this.parentContext.getCreateChildSummarizerNodeFn(attachMessage.id, {
-                type: internal_4.CreateSummarizerNodeSource.FromAttach,
-                sequenceNumber: message.sequenceNumber,
-                snapshot: attachMessage.snapshot ?? {
-                    entries: [(0, dataStoreContext_js_1.createAttributesBlob)(pkg, true /* isRootDataStore */)],
-                },
-            }),
-            pkg,
-        });
-        this.contexts.addBoundOrRemoted(remoteFluidDataStoreContext);
-    }
-    processAliasMessage(message, localOpMetadata, local) {
-        const aliasMessage = message.contents;
-        if (!(0, dataStore_js_1.isDataStoreAliasMessage)(aliasMessage)) {
-            throw new internal_6.DataCorruptionError("malformedDataStoreAliasMessage", {
-                ...(0, internal_6.extractSafePropertiesFromMessage)(message),
+            // The local object has already been attached
+            if (local) {
+                (0, internal_1.assert)(this.pendingAttach.has(attachMessage.id), 0x15e /* "Local object does not have matching attach message id" */);
+                this.contexts.get(attachMessage.id)?.setAttachState(container_definitions_1.AttachState.Attached);
+                this.pendingAttach.delete(attachMessage.id);
+                continue;
+            }
+            // If a non-local operation then go and create the object, otherwise mark it as officially attached.
+            if (this.alreadyProcessed(attachMessage.id)) {
+                // TODO: dataStoreId may require a different tag from PackageData #7488
+                const error = new internal_6.DataCorruptionError(
+                // pre-0.58 error message: duplicateDataStoreCreatedWithExistingId
+                "Duplicate DataStore created with existing id", {
+                    ...(0, internal_6.extractSafePropertiesFromMessage)(envelope),
+                    ...(0, internal_6.tagCodeArtifacts)({ dataStoreId: attachMessage.id }),
+                });
+                throw error;
+            }
+            const flatAttachBlobs = new Map();
+            let snapshot;
+            if (attachMessage.snapshot) {
+                snapshot = (0, internal_3.buildSnapshotTree)(attachMessage.snapshot.entries, flatAttachBlobs);
+                if ((0, internal_3.isInstanceOfISnapshot)(this.baseSnapshot)) {
+                    snapshot = { ...this.baseSnapshot, snapshotTree: snapshot };
+                }
+            }
+            // Include the type of attach message which is the pkg of the store to be
+            // used by RemoteFluidDataStoreContext in case it is not in the snapshot.
+            const pkg = [attachMessage.type];
+            const remoteFluidDataStoreContext = new dataStoreContext_js_1.RemoteFluidDataStoreContext({
+                id: attachMessage.id,
+                snapshot,
+                parentContext: this.wrapContextForInnerChannel(attachMessage.id),
+                storage: new storageServiceWithAttachBlobs_js_1.StorageServiceWithAttachBlobs(this.parentContext.storage, flatAttachBlobs),
+                scope: this.parentContext.scope,
+                loadingGroupId: attachMessage.snapshot?.groupId,
+                createSummarizerNodeFn: this.parentContext.getCreateChildSummarizerNodeFn(attachMessage.id, {
+                    type: internal_4.CreateSummarizerNodeSource.FromAttach,
+                    sequenceNumber: envelope.sequenceNumber,
+                    snapshot: attachMessage.snapshot ?? {
+                        entries: [(0, dataStoreContext_js_1.createAttributesBlob)(pkg, true /* isRootDataStore */)],
+                    },
+                }),
+                pkg,
             });
+            this.contexts.addBoundOrRemoted(remoteFluidDataStoreContext);
         }
-        const resolve = localOpMetadata;
-        const aliasResult = this.processAliasMessageCore(aliasMessage.internalId, aliasMessage.alias, message.timestamp);
-        if (local) {
-            resolve(aliasResult);
+    }
+    processAliasMessages(messageCollection) {
+        const { envelope, messagesContent, local } = messageCollection;
+        for (const { contents, localOpMetadata } of messagesContent) {
+            const aliasMessage = contents;
+            if (!(0, dataStore_js_1.isDataStoreAliasMessage)(aliasMessage)) {
+                throw new internal_6.DataCorruptionError("malformedDataStoreAliasMessage", {
+                    ...(0, internal_6.extractSafePropertiesFromMessage)(envelope),
+                });
+            }
+            const resolve = localOpMetadata;
+            const aliasResult = this.processAliasMessageCore(aliasMessage.internalId, aliasMessage.alias, envelope.timestamp);
+            if (local) {
+                resolve(aliasResult);
+            }
         }
     }
     processAliasMessageCore(internalId, alias, messageTimestampMs) {
@@ -591,61 +589,119 @@ class ChannelCollection {
             this.pendingAttach.set(message.id, message);
         }
     }
-    process(message, local, localMessageMetadata) {
-        switch (message.type) {
+    /**
+     * Process messages for this channel collection. The messages here are contiguous messages in a batch.
+     * @param messageCollection - The collection of messages to process.
+     */
+    processMessages(messageCollection) {
+        switch (messageCollection.envelope.type) {
+            case messageTypes_js_1.ContainerMessageType.FluidDataStoreOp:
+                this.processChannelMessages(messageCollection);
+                break;
             case messageTypes_js_1.ContainerMessageType.Attach:
-                this.processAttachMessage(message, local);
-                return;
+                this.processAttachMessages(messageCollection);
+                break;
             case messageTypes_js_1.ContainerMessageType.Alias:
-                this.processAliasMessage(message, localMessageMetadata, local);
-                return;
-            case messageTypes_js_1.ContainerMessageType.FluidDataStoreOp: {
-                const envelope = message.contents;
-                const innerContents = envelope.contents;
-                const transformed = {
-                    ...message,
-                    type: innerContents.type,
-                    contents: innerContents.content,
-                };
-                this.processChannelOp(envelope.address, transformed, local, localMessageMetadata);
-                // Notify GC of any outbound references that were added by this op.
-                detectOutboundReferences(envelope.address, transformed.contents, (fromPath, toPath) => this.parentContext.addedGCOutboundRoute(fromPath, toPath, message.timestamp));
+                this.processAliasMessages(messageCollection);
                 break;
-            }
             default:
                 (0, internal_1.assert)(false, 0x8e9 /* unreached */);
         }
     }
-    processChannelOp(address, message, local, localMessageMetadata) {
-        const context = this.contexts.get(address);
-        // If the data store has been deleted, log an error and ignore this message. This helps prevent document
-        // corruption in case a deleted data store accidentally submitted an op.
-        if (this.checkAndLogIfDeleted(address, context, "Changed", "processFluidDataStoreOp")) {
-            return;
-        }
-        if (context === undefined) {
-            // Former assert 0x162
-            throw internal_6.DataProcessingError.create("No context for op", "processFluidDataStoreOp", message, {
+    /**
+     * This is still here for back-compat purposes because channel collection implements
+     * IFluidDataStoreChannel. Once it is removed from the interface, this method can be removed.
+     * Container runtime calls `processMessages` instead.
+     */
+    process(message, local, localOpMetadata) {
+        this.processMessages({
+            envelope: message,
+            messagesContent: [
+                {
+                    contents: message.contents,
+                    localOpMetadata,
+                    clientSequenceNumber: message.clientSequenceNumber,
+                },
+            ],
+            local,
+        });
+    }
+    /**
+     * Process channel messages. The messages here are contiguous channel type messages in a batch. Bunch
+     * of contiguous messages for a data store should be sent to it together.
+     * @param messageCollection - The collection of messages to process.
+     */
+    processChannelMessages(messageCollection) {
+        const { messagesContent, local } = messageCollection;
+        let currentMessageState;
+        let currentMessagesContent = [];
+        // Helper that sends the current bunch of messages to the data store. It validates that the data stores exists.
+        const sendBunchedMessages = () => {
+            // Current message state will be undefined for the first message in the list.
+            if (currentMessageState === undefined) {
+                return;
+            }
+            const currentContext = this.contexts.get(currentMessageState.address);
+            (0, internal_1.assert)(!!currentContext, 0xa66 /* Context not found */);
+            currentContext.processMessages({
+                envelope: { ...messageCollection.envelope, type: currentMessageState.type },
+                messagesContent: currentMessagesContent,
                 local,
-                messageDetails: JSON.stringify({
-                    type: message.type,
-                    contentType: typeof message.contents,
-                }),
-                ...(0, internal_6.tagCodeArtifacts)({ address }),
             });
+            currentMessagesContent = [];
+        };
+        /**
+         * Bunch contiguous messages for the same data store and send them together.
+         * This is an optimization mainly for DDSes, where it can process a bunch of ops together. DDSes
+         * 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;
+            const address = contentsEnvelope.address;
+            const context = this.contexts.get(address);
+            // If the data store has been deleted, log an error and ignore this message. This helps prevent document
+            // corruption in case a deleted data store accidentally submitted an op.
+            if (this.checkAndLogIfDeleted(address, context, "Changed", "processFluidDataStoreOp")) {
+                continue;
+            }
+            if (context === undefined) {
+                // Former assert 0x162
+                throw internal_6.DataProcessingError.create("No context for op", "processFluidDataStoreOp", messageCollection.envelope, {
+                    local,
+                    messageDetails: JSON.stringify({
+                        type: messageCollection.envelope.type,
+                        contentType: typeof contents,
+                    }),
+                    ...(0, internal_6.tagCodeArtifacts)({ address }),
+                });
+            }
+            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 ||
+                currentMessageState?.type !== contextType) {
+                sendBunchedMessages();
+            }
+            currentMessagesContent.push({
+                contents: contextContents,
+                ...restOfMessagesContent,
+            });
+            currentMessageState = { address, type: contextType };
+            // Notify that a GC node for the data store changed. This is used to detect if a deleted data store is
+            // being used.
+            this.gcNodeUpdated({
+                node: { type: "DataStore", path: `/${address}` },
+                reason: "Changed",
+                timestampMs: messageCollection.envelope.timestamp,
+                packagePath: context.isLoaded ? context.packagePath : undefined,
+            });
+            detectOutboundReferences(address, contextContents, (fromPath, toPath) => this.parentContext.addedGCOutboundRoute(fromPath, toPath, messageCollection.envelope.timestamp));
         }
-        context.process(message, local, localMessageMetadata);
-        // Notify that a GC node for the data store changed. This is used to detect if a deleted data store is
-        // being used.
-        this.gcNodeUpdated({
-            node: { type: "DataStore", path: `/${address}` },
-            reason: "Changed",
-            timestampMs: message.timestamp,
-            packagePath: context.isLoaded ? context.packagePath : undefined,
-        });
+        // Process the last bunch of messages, if any. Note that there may not be any messages in case all of them are
+        // ignored because the data store is deleted.
+        sendBunchedMessages();
     }
     async getDataStore(id, requestHeaderData, originalRequest) {
-        const headerData = computeRuntimeHeaderData(this.mc.config, requestHeaderData);
+        const headerData = { ...containerRuntime_js_1.defaultRuntimeHeaderData, ...requestHeaderData };
         if (this.checkAndLogIfDeleted(id, this.contexts.get(id), "Requested", "getDataStore", requestHeaderData, originalRequest)) {
             // The requested data store has been deleted by gc. Create a 404 response exception.
             throw (0, internal_5.responseToException)((0, internal_5.createResponseError)(404, "DataStore was deleted", originalRequest, {
@@ -668,7 +724,7 @@ class ChannelCollection {
         if (this.checkAndLogIfDeleted(id, this.contexts.get(id), "Requested", "getDataStoreIfAvailable", requestHeaderData)) {
             return undefined;
         }
-        const headerData = computeRuntimeHeaderData(this.mc.config, requestHeaderData);
+        const headerData = { ...containerRuntime_js_1.defaultRuntimeHeaderData, ...requestHeaderData };
         const context = await this.contexts.getBoundOrRemoted(id, headerData.wait);
         if (context === undefined) {
             return undefined;