@fluidframework/container-runtime 2.1.0 → 2.1.2

package/lib/containerRuntime.js

@@ -675,13 +675,14 @@ export class ContainerRuntime extends TypedEventEmitter {
             isAttached: () => this.attachState !== AttachState.Detached,
         }, pendingRuntimeState?.pending, this.logger);
         let outerDeltaManager;
-        const useDeltaManagerOpsProxy = this.mc.config.getBoolean("Fluid.ContainerRuntime.DeltaManagerOpsProxy") !== false;
+        this.useDeltaManagerOpsProxy =
+            this.mc.config.getBoolean("Fluid.ContainerRuntime.DeltaManagerOpsProxy") === true;
         // The summarizerDeltaManager Proxy is used to lie to the summarizer to convince it is in the right state as a summarizer client.
         const summarizerDeltaManagerProxy = new DeltaManagerSummarizerProxy(this.innerDeltaManager);
         outerDeltaManager = summarizerDeltaManagerProxy;
         // The DeltaManagerPendingOpsProxy is used to control the minimum sequence number
         // It allows us to lie to the layers below so that they can maintain enough local state for rebasing ops.
-        if (useDeltaManagerOpsProxy) {
+        if (this.useDeltaManagerOpsProxy) {
             const pendingOpsDeltaManagerProxy = new DeltaManagerPendingOpsProxy(summarizerDeltaManagerProxy, this.pendingStateManager);
             outerDeltaManager = pendingOpsDeltaManagerProxy;
         }
@@ -1478,36 +1479,33 @@ export class ContainerRuntime extends TypedEventEmitter {
         const messageCopy = { ...messageArg };
         // We expect runtime messages to have JSON contents - deserialize it in place.
         ensureContentsDeserialized(messageCopy, modernRuntimeMessage, logLegacyCase);
-        if (modernRuntimeMessage) {
-            const processResult = this.remoteMessageProcessor.process(messageCopy, logLegacyCase);
-            if (processResult === undefined) {
-                // This means the incoming message is an incomplete part of a message or batch
-                // and we need to process more messages before the rest of the system can understand it.
-                return;
-            }
-            const batchStartCsn = processResult.batchStartCsn;
-            const batch = processResult.messages;
-            const messages = local
-                ? this.pendingStateManager.processPendingLocalBatch(batch, batchStartCsn)
-                : batch.map((message) => ({ message, localOpMetadata: undefined }));
-            messages.forEach(({ message, localOpMetadata }) => {
-                const msg = {
-                    message,
+        const processResult = this.remoteMessageProcessor.process(messageCopy);
+        if (processResult === undefined) {
+            // This means the incoming message is an incomplete part of a message or batch
+            // and we need to process more messages before the rest of the system can understand it.
+            return;
+        }
+        for (const message of processResult.messages) {
+            const msg = modernRuntimeMessage
+                ? {
+                    // Cast it since we expect it to be this based on modernRuntimeMessage computation above.
+                    // There is nothing really ensuring that anytime original message.type is Operation that
+                    // the result messages will be so. In the end modern bool being true only directs to
+                    // throw error if ultimately unrecognized without compat details saying otherwise.
+                    message: message,
                     local,
                     modernRuntimeMessage,
-                    savedOp,
-                    localOpMetadata,
-                };
-                this.ensureNoDataModelChanges(() => this.processCore(msg));
-            });
-        }
-        else {
-            const msg = {
-                message: messageCopy,
-                local,
-                modernRuntimeMessage,
-                savedOp,
-            };
+                    batchStartCsn: processResult.batchStartCsn,
+                }
+                : // Unrecognized message will be ignored.
+                    {
+                        message,
+                        local,
+                        modernRuntimeMessage,
+                        batchStartCsn: processResult.batchStartCsn,
+                    };
+            msg.savedOp = savedOp;
+            // ensure that we observe any re-entrancy, and if needed, rebase ops
             this.ensureNoDataModelChanges(() => this.processCore(msg));
         }
     }
@@ -1515,11 +1513,12 @@ export class ContainerRuntime extends TypedEventEmitter {
      * Direct the message to the correct subsystem for processing, and implement other side effects
      */
     processCore(messageWithContext) {
-        const { message, local, localOpMetadata } = messageWithContext;
+        const { message, local } = messageWithContext;
         // Intercept to reduce minimum sequence number to the delta manager's minimum sequence number.
         // Sequence numbers are not guaranteed to follow any sort of order. Re-entrancy is one of those situations
-        if (this.deltaManager.minimumSequenceNumber <
-            messageWithContext.message.minimumSequenceNumber) {
+        if (this.useDeltaManagerOpsProxy &&
+            this.deltaManager.minimumSequenceNumber <
+                messageWithContext.message.minimumSequenceNumber) {
             messageWithContext.message.minimumSequenceNumber =
                 this.deltaManager.minimumSequenceNumber;
         }
@@ -1529,8 +1528,15 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.scheduleManager.beforeOpProcessing(message);
         this._processedClientSequenceNumber = message.clientSequenceNumber;
         try {
-            // RemoteMessageProcessor would have already reconstituted Chunked Ops into the original op type
+            // See commit that added this assert for more details.
+            // These calls should be made for all but chunked ops:
+            // 1) this.pendingStateManager.processPendingLocalMessage() below
+            // 2) this.resetReconnectCount() below
             assert(message.type !== ContainerMessageType.ChunkedOp, 0x93b /* we should never get here with chunked ops */);
+            let localOpMetadata;
+            if (local && messageWithContext.modernRuntimeMessage) {
+                localOpMetadata = this.pendingStateManager.processPendingLocalMessage(messageWithContext.message, messageWithContext.batchStartCsn);
+            }
             // If there are no more pending messages after processing a local message,
             // the document is no longer dirty.
             if (!this.hasPendingMessages()) {