@fluidframework/container-runtime 2.0.0-dev.4.4.0.162574 → 2.0.0-dev.5.2.0.169897

package/lib/containerRuntime.js

@@ -348,7 +348,6 @@ export class ContainerRuntime extends TypedEventEmitter {
             close: this.closeFn,
             connected: () => this.connected,
             reSubmit: this.reSubmit.bind(this),
-            rollback: this.rollback.bind(this),
             orderSequentially: this.orderSequentially.bind(this),
         }, pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.pending);
         const disableCompression = this.mc.config.getBoolean("Fluid.ContainerRuntime.CompressionDisabled");
@@ -474,9 +473,6 @@ export class ContainerRuntime extends TypedEventEmitter {
             return initializeEntryPoint === null || initializeEntryPoint === void 0 ? void 0 : initializeEntryPoint(this);
         });
     }
-    get IContainerRuntime() {
-        return this;
-    }
     get IFluidRouter() {
         return this;
     }
@@ -625,7 +621,7 @@ export class ContainerRuntime extends TypedEventEmitter {
     }
     get reSubmitFn() {
         // eslint-disable-next-line @typescript-eslint/unbound-method
-        return this.reSubmit;
+        return this.reSubmitCore;
     }
     get disposeFn() {
         var _a;
@@ -900,8 +896,14 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
         return this.consecutiveReconnects < this.maxConsecutiveReconnects;
     }
-    resetReconnectCount() {
-        this.consecutiveReconnects = 0;
+    resetReconnectCount(message) {
+        // Chunked ops don't count towards making progress as they are sent
+        // in their own batches before the originating batch is sent.
+        // Therefore, receiving them while attempting to send the originating batch
+        // does not mean that the container is making any progress.
+        if ((message === null || message === void 0 ? void 0 : message.type) !== ContainerMessageType.ChunkedOp) {
+            this.consecutiveReconnects = 0;
+        }
     }
     replayPendingStates() {
         // We need to be able to send ops to replay states
@@ -943,7 +945,19 @@ export class ContainerRuntime extends TypedEventEmitter {
         const { IdCompressor } = await import("./id-compressor");
         this.idCompressor = IdCompressor.deserialize(op.stashedState);
     }
-    async applyStashedOp(type, contents) {
+    /**
+     * Parse an op's type and actual content from given serialized content
+     * ! Note: this format needs to be in-line with what is set in the "ContainerRuntime.submit(...)" method
+     */
+    parseOpContent(serializedContent) {
+        assert(serializedContent !== undefined, 0x6d5 /* content must be defined */);
+        const parsed = JSON.parse(serializedContent);
+        assert(parsed.type !== undefined, 0x6d6 /* incorrect op content format */);
+        return { type: parsed.type, contents: parsed.contents };
+    }
+    async applyStashedOp(op) {
+        // Need to parse from string for back-compat
+        const { type, contents } = this.parseOpContent(op);
         switch (type) {
             case ContainerMessageType.FluidDataStoreOp:
                 return this.dataStores.applyStashedOp(contents);
@@ -1102,7 +1116,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 // If we have processed a local op, this means that the container is
                 // making progress and we can reset the counter for how many times
                 // we have consecutively replayed the pending states
-                this.resetReconnectCount();
+                this.resetReconnectCount(message);
             }
         }
         catch (e) {
@@ -1202,7 +1216,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             if (checkpoint) {
                 // This will throw and close the container if rollback fails
                 try {
-                    checkpoint.rollback((message) => this.rollback(message.deserializedContent.type, message.deserializedContent.contents, message.localOpMetadata));
+                    checkpoint.rollback((message) => this.rollback(message.contents, message.localOpMetadata));
                 }
                 catch (err) {
                     const error2 = wrapError(err, (message) => {
@@ -1807,10 +1821,10 @@ export class ContainerRuntime extends TypedEventEmitter {
                 };
                 idAllocationBatchMessage = {
                     contents: JSON.stringify(idAllocationMessage),
-                    deserializedContent: idAllocationMessage,
                     referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
                     metadata: undefined,
                     localOpMetadata: (_b = this.idCompressor) === null || _b === void 0 ? void 0 : _b.serialize(true),
+                    type: ContainerMessageType.IdAllocation,
                 };
             }
             if (idAllocationBatchMessage !== undefined) {
@@ -1834,7 +1848,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
         const message = {
             contents: serializedContent,
-            deserializedContent: JSON.parse(serializedContent),
+            type,
             metadata,
             localOpMetadata,
             referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
@@ -1966,13 +1980,18 @@ export class ContainerRuntime extends TypedEventEmitter {
             }
         }
     }
+    reSubmit(content, localOpMetadata, opMetadata) {
+        // Need to parse from string for back-compat
+        const { contents, type } = this.parseOpContent(content);
+        this.reSubmitCore(type, contents, localOpMetadata, opMetadata);
+    }
     /**
      * Finds the right store and asks it to resubmit the message. This typically happens when we
      * reconnect and there are pending messages.
      * @param content - The content of the original message.
      * @param localOpMetadata - The local metadata associated with the original message.
      */
-    reSubmit(type, content, localOpMetadata, opMetadata) {
+    reSubmitCore(type, content, localOpMetadata, opMetadata) {
         switch (type) {
             case ContainerMessageType.FluidDataStoreOp:
                 // For Operations, call resubmitDataStoreOp which will find the right store
@@ -1981,7 +2000,13 @@ export class ContainerRuntime extends TypedEventEmitter {
                 break;
             case ContainerMessageType.Attach:
             case ContainerMessageType.Alias:
+                this.submit(type, content, localOpMetadata);
+                break;
             case ContainerMessageType.IdAllocation:
+                // Remove the stashedState from the op if it's a stashed op
+                if (content.stashedState !== undefined) {
+                    delete content.stashedState;
+                }
                 this.submit(type, content, localOpMetadata);
                 break;
             case ContainerMessageType.ChunkedOp:
@@ -1996,12 +2021,14 @@ export class ContainerRuntime extends TypedEventEmitter {
                 unreachableCase(type, `Unknown ContainerMessageType: ${type}`);
         }
     }
-    rollback(type, content, localOpMetadata) {
+    rollback(content, localOpMetadata) {
+        // Need to parse from string for back-compat
+        const { type, contents } = this.parseOpContent(content);
         switch (type) {
             case ContainerMessageType.FluidDataStoreOp:
                 // For operations, call rollbackDataStoreOp which will find the right store
                 // and trigger rollback on it.
-                this.dataStores.rollbackDataStoreOp(content, localOpMetadata);
+                this.dataStores.rollbackDataStoreOp(contents, localOpMetadata);
                 break;
             default:
                 throw new Error(`Can't rollback ${type}`);