@fluidframework/container-runtime 2.4.0-299374 → 2.4.0-299707

package/lib/containerRuntime.js

@@ -32,16 +32,23 @@ import { ScheduleManager } from "./scheduleManager.js";
 import { DocumentsSchemaController, OrderedClientCollection, OrderedClientElection, RetriableSummaryError, RunWhileConnectedCoordinator, Summarizer, SummarizerClientElection, SummaryCollection, SummaryManager, aliasBlobName, chunksBlobName, createRootSummarizerNodeWithGC, electedSummarizerBlobName, extractSummaryMetadataMessage, idCompressorBlobName, metadataBlobName, rootHasIsolatedChannels, summarizerClientType, wrapSummaryInChannelsTree, } from "./summary/index.js";
 import { Throttler, formExponentialFn } from "./throttler.js";
 /**
- * Utility to implement compat behaviors given an unknown message type
+ * Creates an error object to be thrown / passed to Container's close fn in case of an unknown message type.
  * The parameters are typed to support compile-time enforcement of handling all known types/behaviors
  *
- * @param _unknownContainerRuntimeMessageType - Typed as something unexpected, to ensure all known types have been
+ * @param unknownContainerRuntimeMessageType - Typed as something unexpected, to ensure all known types have been
  * handled before calling this function (e.g. in a switch statement).
- * @param compatBehavior - Typed redundantly with CompatModeBehavior to ensure handling is added when updating that type
+ *
+ * @param codePath - The code path where the unexpected message type was encountered.
+ *
+ * @param sequencedMessage - The sequenced message that contained the unexpected message type.
+ *
  */
-function compatBehaviorAllowsMessageType(_unknownContainerRuntimeMessageType, compatBehavior) {
-    // undefined defaults to same behavior as "FailToProcess"
-    return compatBehavior === "Ignore";
+function getUnknownMessageTypeError(unknownContainerRuntimeMessageType, codePath, sequencedMessage) {
+    return DataProcessingError.create("Runtime message of unknown type", codePath, sequencedMessage, {
+        messageDetails: {
+            type: unknownContainerRuntimeMessageType,
+        },
+    });
 }
 /**
  * @legacy
@@ -1389,22 +1396,9 @@ export class ContainerRuntime extends TypedEventEmitter {
                 // GC op is only sent in summarizer which should never have stashed ops.
                 throw new LoggingError("GC op not expected to be stashed in summarizer");
             default: {
-                // This should be extremely rare for stashed ops.
-                // It would require a newer runtime stashing ops and then an older one applying them,
-                // e.g. if an app rolled back its container version
-                const compatBehavior = opContents.compatDetails?.behavior;
-                if (!compatBehaviorAllowsMessageType(opContents.type, compatBehavior)) {
-                    const error = DataProcessingError.create("Stashed runtime message of unexpected type", "applyStashedOp", undefined /* sequencedMessage */, {
-                        messageDetails: JSON.stringify({
-                            type: opContents.type,
-                            compatBehavior,
-                        }),
-                    });
-                    this.closeFn(error);
-                    throw error;
-                }
-                // Note: Even if its compat behavior allows it, we don't know how to apply this stashed op.
-                // All we can do is ignore it (similar to on process).
+                const error = getUnknownMessageTypeError(opContents.type, "applyStashedOp" /* codePath */);
+                this.closeFn(error);
+                throw error;
             }
         }
     }
@@ -1724,23 +1718,9 @@ export class ContainerRuntime extends TypedEventEmitter {
                 this.documentsSchemaController.processDocumentSchemaOp(message.contents, local, message.sequenceNumber);
                 break;
             default: {
-                const compatBehavior = message.compatDetails?.behavior;
-                if (!compatBehaviorAllowsMessageType(message.type, compatBehavior)) {
-                    const error = DataProcessingError.create(
-                    // Former assert 0x3ce
-                    "Runtime message of unknown type", "OpProcessing", message, {
-                        local,
-                        messageDetails: JSON.stringify({
-                            type: message.type,
-                            contentType: typeof message.contents,
-                            compatBehavior,
-                            batch: message.metadata?.batch,
-                            compression: message.compression,
-                        }),
-                    });
-                    this.closeFn(error);
-                    throw error;
-                }
+                const error = getUnknownMessageTypeError(message.type, "validateAndProcessRuntimeMessage" /* codePath */, message);
+                this.closeFn(error);
+                throw error;
             }
         }
         this.emit("op", message, true /* runtimeMessage */);
@@ -2848,26 +2828,9 @@ export class ContainerRuntime extends TypedEventEmitter {
                 // send any ops, as some other client already changed schema.
                 break;
             default: {
-                // This case should be very rare - it would imply an op was stashed from a
-                // future version of runtime code and now is being applied on an older version.
-                const compatBehavior = message.compatDetails?.behavior;
-                if (compatBehaviorAllowsMessageType(message.type, compatBehavior)) {
-                    // We do not ultimately resubmit it, to be consistent with this version of the code.
-                    this.logger.sendTelemetryEvent({
-                        eventName: "resubmitUnrecognizedMessageTypeAllowed",
-                        messageDetails: { type: message.type, compatBehavior },
-                    });
-                }
-                else {
-                    const error = DataProcessingError.create("Resubmitting runtime message of unexpected type", "reSubmitCore", undefined /* sequencedMessage */, {
-                        messageDetails: JSON.stringify({
-                            type: message.type,
-                            compatBehavior,
-                        }),
-                    });
-                    this.closeFn(error);
-                    throw error;
-                }
+                const error = getUnknownMessageTypeError(message.type, "reSubmitCore" /* codePath */);
+                this.closeFn(error);
+                throw error;
             }
         }
     }