@fluidframework/container-runtime 2.0.0-internal.1.4.4 → 2.0.0-internal.2.0.1

package/lib/containerRuntime.js

@@ -1,5 +1,5 @@
 import { AttachState, LoaderHeader, } from "@fluidframework/container-definitions";
-import { assert, Trace, TypedEventEmitter, unreachableCase, } from "@fluidframework/common-utils";
+import { assert, Trace, TypedEventEmitter, unreachableCase, IsoBuffer, } from "@fluidframework/common-utils";
 import { ChildLogger, raiseConnectedEvent, PerformanceEvent, TaggedLoggerAdapter, loggerToMonitoringContext, wrapError, } from "@fluidframework/telemetry-utils";
 import { DriverHeader, FetchSource, } from "@fluidframework/driver-definitions";
 import { readAndParse } from "@fluidframework/driver-utils";
@@ -9,6 +9,7 @@ import { FlushMode, channelsTreeName, } from "@fluidframework/runtime-definition
 import { addBlobToSummary, addSummarizeResultToSummary, addTreeToSummary, createRootSummarizerNodeWithGC, RequestParser, create404Response, exceptionToResponse, requestFluidObject, responseToException, seqFromTree, calculateStats, TelemetryContext, } from "@fluidframework/runtime-utils";
 import { GCDataBuilder, trimLeadingAndTrailingSlashes } from "@fluidframework/garbage-collector";
 import { v4 as uuid } from "uuid";
+import { compress, decompress } from "lz4js";
 import { ContainerFluidHandleContext } from "./containerHandleContext";
 import { FluidDataStoreRegistry } from "./dataStoreRegistry";
 import { Summarizer } from "./summarizer";
@@ -76,6 +77,11 @@ export var RuntimeHeaders;
 })(RuntimeHeaders || (RuntimeHeaders = {}));
 const maxConsecutiveReconnectsKey = "Fluid.ContainerRuntime.MaxConsecutiveReconnects";
 const defaultFlushMode = FlushMode.TurnBased;
+// The actual limit is 1Mb (socket.io and Kafka limits)
+// We can't estimate it fully, as we
+// - do not know what properties relay service will add
+// - we do not stringify final op, thus we do not know how much escaping will be added.
+const defaultMaxBatchSizeInBytes = 950 * 1024;
 /**
  * @deprecated - use ContainerRuntimeMessage instead
  */
@@ -93,21 +99,27 @@ export var RuntimeMessage;
  * @deprecated - please use version in driver-utils
  */
 export function isRuntimeMessage(message) {
-    if (Object.values(RuntimeMessage).includes(message.type)) {
-        return true;
-    }
-    return false;
+    return Object.values(RuntimeMessage).includes(message.type);
 }
 /**
  * Unpacks runtime messages
  *
- * @remarks This API makes no promises regarding backward-compatability. This is internal API.
+ * @remarks This API makes no promises regarding backward-compatibility. This is internal API.
  * @param message - message (as it observed in storage / service)
  * @returns unpacked runtime message
  *
  * @internal
  */
 export function unpackRuntimeMessage(message) {
+    var _a;
+    if ((_a = message.metadata) === null || _a === void 0 ? void 0 : _a.compressed) {
+        const contents = IsoBuffer.from(message.contents.contents, "base64");
+        const decompressedMessage = decompress(contents);
+        const intoString = new TextDecoder().decode(decompressedMessage);
+        const asObj = JSON.parse(intoString);
+        message.contents.contents = asObj;
+        message.metadata.compressed = false;
+    }
     if (message.type === MessageType.Operation) {
         // legacy op format?
         if (message.contents.address !== undefined && message.contents.type === undefined) {
@@ -156,7 +168,7 @@ export function getDeviceSpec() {
  */
 export class ContainerRuntime extends TypedEventEmitter {
     constructor(context, registry, metadata, electedSummarizerData, chunks, dataStoreAliasMap, runtimeOptions, containerScope, logger, existing, blobManagerSnapshot, _storage, requestHandler, summaryConfiguration) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e, _f;
         if (summaryConfiguration === void 0) { summaryConfiguration = Object.assign(Object.assign({}, DefaultSummaryConfiguration), (_a = runtimeOptions.summaryOptions) === null || _a === void 0 ? void 0 : _a.summaryConfigOverrides); }
         super();
         this.context = context;
@@ -169,9 +181,10 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.summaryConfiguration = summaryConfiguration;
         this.defaultMaxConsecutiveReconnects = 7;
         this._orderSequentiallyCalls = 0;
-        this.flushTrigger = false;
+        this.flushMicroTaskExists = false;
         this.savedOps = [];
         this.consecutiveReconnects = 0;
+        this.compressedOpCount = 0;
         this._disposed = false;
         this.emitDirtyDocumentEvent = true;
         this.defaultTelemetrySignalSampleCount = 100;
@@ -181,12 +194,6 @@ export class ContainerRuntime extends TypedEventEmitter {
             signalTimestamp: 0,
             trackingSignalSequenceNumber: undefined,
         };
-        // Provide lower soft limit - we want to have some number of ops to get efficiency in compression & bandwidth usage,
-        // but at the same time we want to send these ops sooner, to reduce overall latency of processing a batch.
-        // So there is some ballance here, that depends on compression algorithm and its efficiency working with smaller
-        // payloads. That number represents final (compressed) bits (once compression is implemented).
-        this.pendingAttachBatch = new BatchManager(64 * 1024);
-        this.pendingBatch = new BatchManager();
         this.summarizeOnDemand = (...args) => {
             if (this.clientDetails.type === summarizerClientType) {
                 return this.summarizer.summarizeOnDemand(...args);
@@ -231,8 +238,22 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.maxConsecutiveReconnects =
             (_b = this.mc.config.getNumber(maxConsecutiveReconnectsKey)) !== null && _b !== void 0 ? _b : this.defaultMaxConsecutiveReconnects;
         this._flushMode = runtimeOptions.flushMode;
+        // Provide lower soft limit - we want to have some number of ops to get efficiency in compression
+        // & bandwidth usage, but at the same time we want to send these ops sooner, to reduce overall
+        // latency of processing a batch.
+        // So there is some ballance here, that depends on compression algorithm and its efficiency working with smaller
+        // payloads. That number represents final (compressed) bits (once compression is implemented).
+        this.pendingAttachBatch = new BatchManager(runtimeOptions.maxBatchSizeInBytes, 64 * 1024);
+        this.pendingBatch = new BatchManager(runtimeOptions.maxBatchSizeInBytes);
         const pendingRuntimeState = context.pendingLocalState;
         const baseSnapshot = (_c = pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.baseSnapshot) !== null && _c !== void 0 ? _c : context.baseSnapshot;
+        const maxSnapshotCacheDurationMs = (_e = (_d = this._storage) === null || _d === void 0 ? void 0 : _d.policies) === null || _e === void 0 ? void 0 : _e.maximumCacheDurationMs;
+        if (maxSnapshotCacheDurationMs !== undefined && maxSnapshotCacheDurationMs > 5 * 24 * 60 * 60 * 1000) {
+            // This is a runtime enforcement of what's already explicit in the policy's type itself,
+            // which dictates the value is either undefined or exactly 5 days in ms.
+            // As long as the actual value is less than 5 days, the assumptions GC makes here are valid.
+            throw new UsageError("Driver's maximumCacheDurationMs policy cannot exceed 5 days");
+        }
         this.garbageCollector = GarbageCollector.create({
             runtime: this,
             gcOptions: this.runtimeOptions.gcOptions,
@@ -265,9 +286,9 @@ export class ContainerRuntime extends TypedEventEmitter {
             gcDisabled: !this.garbageCollector.shouldRunGC,
         });
         if (baseSnapshot) {
-            this.summarizerNode.loadBaseSummaryWithoutDifferential(baseSnapshot);
+            this.summarizerNode.updateBaseSummaryState(baseSnapshot);
         }
-        this.dataStores = new DataStores(getSummaryForDatastores(baseSnapshot, metadata), this, (attachMsg) => this.submit(ContainerMessageType.Attach, attachMsg), (id, createParam) => (summarizeInternal, getGCDataFn, getBaseGCDetailsFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, undefined, getGCDataFn, getBaseGCDetailsFn), (id) => this.summarizerNode.deleteChild(id), this.mc.logger, async () => this.garbageCollector.getBaseGCDetails(), (path, timestampMs, packagePath) => this.garbageCollector.nodeUpdated(path, "Changed", timestampMs, packagePath), new Map(dataStoreAliasMap), this.garbageCollector.writeDataAtRoot);
+        this.dataStores = new DataStores(getSummaryForDatastores(baseSnapshot, metadata), this, (attachMsg) => this.submit(ContainerMessageType.Attach, attachMsg), (id, createParam) => (summarizeInternal, getGCDataFn, getBaseGCDetailsFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, undefined, getGCDataFn, getBaseGCDetailsFn), (id) => this.summarizerNode.deleteChild(id), this.mc.logger, async () => this.garbageCollector.getBaseGCDetails(), (path, timestampMs, packagePath) => this.garbageCollector.nodeUpdated(path, "Changed", timestampMs, packagePath), new Map(dataStoreAliasMap));
         this.blobManager = new BlobManager(this.handleContext, blobManagerSnapshot, () => this.storage, (blobId, localId) => {
             if (!this.disposed) {
                 this.submit(ContainerMessageType.BlobAttach, undefined, undefined, { blobId, localId });
@@ -281,10 +302,10 @@ export class ContainerRuntime extends TypedEventEmitter {
             close: this.closeFn,
             connected: () => this.connected,
             flush: this.flush.bind(this),
-            flushMode: () => this.flushMode,
             reSubmit: this.reSubmit.bind(this),
-            setFlushMode: (mode) => this.setFlushMode(mode),
-        }, this._flushMode, pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.pending);
+            rollback: this.rollback.bind(this),
+            orderSequentially: this.orderSequentially.bind(this),
+        }, pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.pending);
         this.context.quorum.on("removeMember", (clientId) => {
             this.clearPartialChunks(clientId);
         });
@@ -308,7 +329,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 // if summaries are enabled and we are not the summarizer client.
                 const defaultAction = () => {
                     if (this.summaryCollection.opsSinceLastAck > this.maxOpsSinceLastSummary) {
-                        this.logger.sendErrorEvent({ eventName: "SummaryStatus:Behind" });
+                        this.logger.sendTelemetryEvent({ eventName: "SummaryStatus:Behind" });
                         // unregister default to no log on every op after falling behind
                         // and register summary ack handler to re-register this handler
                         // after successful summary
@@ -364,7 +385,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             };
             // summaryNumber was renamed from summaryCount. For older docs that haven't been opened for a long time,
             // the count is reset to 0.
-            loadSummaryNumber = (_d = metadata === null || metadata === void 0 ? void 0 : metadata.summaryNumber) !== null && _d !== void 0 ? _d : 0;
+            loadSummaryNumber = (_f = metadata === null || metadata === void 0 ? void 0 : metadata.summaryNumber) !== null && _f !== void 0 ? _f : 0;
         }
         else {
             this.createContainerMetadata = {
@@ -399,7 +420,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 runtimeVersion: pkgVersion,
             },
         });
-        const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, enableOfflineLoad = false, } = runtimeOptions;
+        const { summaryOptions = {}, gcOptions = {}, loadSequenceNumberVerification = "close", flushMode = defaultFlushMode, enableOfflineLoad = false, compressionOptions = {}, maxBatchSizeInBytes = defaultMaxBatchSizeInBytes, } = runtimeOptions;
         const pendingRuntimeState = context.pendingLocalState;
         const baseSnapshot = (_b = pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.baseSnapshot) !== null && _b !== void 0 ? _b : context.baseSnapshot;
         const storage = !pendingRuntimeState ?
@@ -454,6 +475,8 @@ export class ContainerRuntime extends TypedEventEmitter {
             loadSequenceNumberVerification,
             flushMode,
             enableOfflineLoad,
+            compressionOptions,
+            maxBatchSizeInBytes,
         }, containerScope, logger, loadExisting, blobManagerSnapshot, storage, requestHandler);
         if (pendingRuntimeState) {
             await runtime.processSavedOps(pendingRuntimeState);
@@ -727,11 +750,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (Object.keys(blobManagerSummary.summary.tree).length > 0) {
             addTreeToSummary(summaryTree, blobsTreeName, blobManagerSummary);
         }
-        if (this.garbageCollector.writeDataAtRoot) {
-            const gcSummary = this.garbageCollector.summarize(fullTree, trackState, telemetryContext);
-            if (gcSummary !== undefined) {
-                addSummarizeResultToSummary(summaryTree, gcTreeKey, gcSummary);
-            }
+        const gcSummary = this.garbageCollector.summarize(fullTree, trackState, telemetryContext);
+        if (gcSummary !== undefined) {
+            addSummarizeResultToSummary(summaryTree, gcTreeKey, gcSummary);
         }
     }
     // Track how many times the container tries to reconnect with pending messages.
@@ -1008,23 +1029,10 @@ export class ContainerRuntime extends TypedEventEmitter {
         assert(await context.isRoot(), 0x12b /* "did not get root data store" */);
         return context.realize();
     }
-    setFlushMode(mode) {
-        if (mode === this._flushMode) {
-            return;
-        }
-        this.mc.logger.sendTelemetryEvent({
-            eventName: "FlushMode Updated",
-            old: this._flushMode,
-            new: mode,
-        });
-        // Flush any pending batches if switching to immediate
-        if (mode === FlushMode.Immediate) {
-            this.flush();
-        }
-        this._flushMode = mode;
-        // Let the PendingStateManager know that FlushMode has been updated.
-        this.pendingStateManager.onFlushModeUpdated(mode);
-    }
+    /**
+     * Flush the pending ops manually.
+     * This method is expected to be called at the end of a batch.
+     */
     flush() {
         assert(this._orderSequentiallyCalls === 0, 0x24c /* "Cannot call `flush()` from `orderSequentially`'s callback" */);
         this.flushBatch(this.pendingAttachBatch.popBatch());
@@ -1053,7 +1061,33 @@ export class ContainerRuntime extends TypedEventEmitter {
             if (this.context.submitBatchFn !== undefined) {
                 const batchToSend = [];
                 for (const message of batch) {
-                    batchToSend.push({ contents: message.contents, metadata: message.metadata });
+                    let contents = message.contents;
+                    let metadata = message.metadata;
+                    if (this.runtimeOptions.compressionOptions.minimumSize &&
+                        this.runtimeOptions.compressionOptions.minimumSize < message.contents.length) {
+                        this.compressedOpCount++;
+                        const copiedMessage = Object.assign({}, message.deserializedContent);
+                        const compressionStart = Date.now();
+                        const contentsAsBuffer = new TextEncoder().encode(JSON.stringify(copiedMessage.contents));
+                        const compressedContents = compress(contentsAsBuffer);
+                        const compressedContent = IsoBuffer.from(compressedContents).toString("base64");
+                        const duration = Date.now() - compressionStart;
+                        if (this.compressedOpCount % 100) {
+                            this.mc.logger.sendPerformanceEvent({
+                                eventName: "compressedOp",
+                                duration,
+                                sizeBeforeCompression: message.contents.length,
+                                sizeAfterCompression: compressedContent.length,
+                            });
+                        }
+                        copiedMessage.contents = compressedContent;
+                        const stringifiedContents = JSON.stringify(copiedMessage);
+                        if (stringifiedContents.length < message.contents.length) {
+                            contents = JSON.stringify(copiedMessage);
+                            metadata = Object.assign(Object.assign({}, message.metadata), { compressed: true });
+                        }
+                    }
+                    batchToSend.push({ contents, metadata });
                 }
                 // returns clientSequenceNumber of last message in a batch
                 clientSequenceNumber = this.context.submitBatchFn(batchToSend);
@@ -1080,26 +1114,6 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.pendingStateManager.onFlush();
     }
     orderSequentially(callback) {
-        // If flush mode is already TurnBased we are either
-        // nested in another orderSequentially, or
-        // the app is flushing manually, in which
-        // case this invocation doesn't own
-        // flushing.
-        if (this.flushMode === FlushMode.TurnBased) {
-            this.trackOrderSequentiallyCalls(callback);
-            return;
-        }
-        const savedFlushMode = this.flushMode;
-        this.setFlushMode(FlushMode.TurnBased);
-        try {
-            this.trackOrderSequentiallyCalls(callback);
-            this.flush();
-        }
-        finally {
-            this.setFlushMode(savedFlushMode);
-        }
-    }
-    trackOrderSequentiallyCalls(callback) {
         let checkpoint;
         if (this.mc.config.getBoolean("Fluid.ContainerRuntime.EnableRollback")) {
             // Note: we are not touching this.pendingAttachBatch here, for two reasons:
@@ -1134,6 +1148,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         finally {
             this._orderSequentiallyCalls--;
         }
+        if (this.flushMode === FlushMode.Immediate && this._orderSequentiallyCalls === 0) {
+            this.flush();
+        }
     }
     async createDataStore(pkg) {
         const internalId = uuid();
@@ -1160,6 +1177,12 @@ export class ContainerRuntime extends TypedEventEmitter {
     canSendOps() {
         return this.connected && !this.deltaManager.readOnlyInfo.readonly;
     }
+    /**
+     * Are we in the middle of batching ops together?
+     */
+    currentlyBatching() {
+        return this.flushMode === FlushMode.TurnBased || this._orderSequentiallyCalls !== 0;
+    }
     getQuorum() {
         return this.context.quorum;
     }
@@ -1310,10 +1333,8 @@ export class ContainerRuntime extends TypedEventEmitter {
      * Implementation of IGarbageCollectionRuntime::updateUsedRoutes.
      * After GC has run, called to notify this container's nodes of routes that are used in it.
      * @param usedRoutes - The routes that are used in all nodes in this Container.
-     * @param gcTimestamp - The time when GC was run that generated these used routes. If any node node becomes
-     * unreferenced as part of this GC run, this should be used to update the time when it happens.
      */
-    updateUsedRoutes(usedRoutes, gcTimestamp) {
+    updateUsedRoutes(usedRoutes) {
         // Update our summarizer node's used routes. Updating used routes in summarizer node before
         // summarizing is required and asserted by the the summarizer node. We are the root and are
         // always referenced, so the used routes is only self-route (empty string).
@@ -1324,7 +1345,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 dataStoreUsedRoutes.push(route);
             }
         }
-        return this.dataStores.updateUsedRoutes(dataStoreUsedRoutes, gcTimestamp);
+        return this.dataStores.updateUsedRoutes(dataStoreUsedRoutes);
     }
     /**
      * When running GC in test mode, this is called to delete objects whose routes are unused. This enables testing
@@ -1710,8 +1731,8 @@ export class ContainerRuntime extends TypedEventEmitter {
             //    issue than sending.
             // Please note that this does not change file format, so it can be disabled in the future if this
             // optimization no longer makes sense (for example, batch compression may make it less appealing).
-            if (type === ContainerMessageType.Attach &&
-                this.mc.config.getBoolean("Fluid.ContainerRuntime.disableAttachOpReorder") !== true) {
+            if (this.currentlyBatching() && type === ContainerMessageType.Attach &&
+                this.mc.config.getBoolean("Fluid.ContainerRuntime.enableAttachOpReorder") === true) {
                 if (!this.pendingAttachBatch.push(message)) {
                     // BatchManager has two limits - soft limit & hard limit. Soft limit is only engaged
                     // when queue is not empty.
@@ -1736,18 +1757,18 @@ export class ContainerRuntime extends TypedEventEmitter {
                         limit: this.pendingBatch.limit,
                     });
                 }
-            }
-            if (this._flushMode !== FlushMode.TurnBased) {
-                this.flush();
-            }
-            else if (!this.flushTrigger) {
-                this.flushTrigger = true;
-                // Queue a microtask to detect the end of the turn and force a flush.
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                Promise.resolve().then(() => {
-                    this.flushTrigger = false;
+                if (!this.currentlyBatching()) {
                     this.flush();
-                });
+                }
+                else if (!this.flushMicroTaskExists) {
+                    this.flushMicroTaskExists = true;
+                    // Queue a microtask to detect the end of the turn and force a flush.
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                    Promise.resolve().then(() => {
+                        this.flushMicroTaskExists = false;
+                        this.flush();
+                    });
+                }
             }
         }
         catch (error) {
@@ -1818,7 +1839,8 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
     }
     /** Implementation of ISummarizerInternalsProvider.refreshLatestSummaryAck */
-    async refreshLatestSummaryAck(proposalHandle, ackHandle, summaryRefSeq, summaryLogger) {
+    async refreshLatestSummaryAck(options) {
+        const { proposalHandle, ackHandle, summaryRefSeq, summaryLogger } = options;
         const readAndParseBlob = async (id) => readAndParse(this.storage, id);
         // The call to fetch the snapshot is very expensive and not always needed.
         // It should only be done by the summarizerNode, if required.
@@ -1891,6 +1913,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         // getPendingLocalState() is only exposed through Container.closeAndGetPendingLocalState(), so it's safe
         // to close current batch.
         this.flush();
+        if (this._orderSequentiallyCalls !== 0) {
+            throw new UsageError("can't get state during orderSequentially");
+        }
         const previousPendingState = this.context.pendingLocalState;
         if (previousPendingState) {
             return {