@fluidframework/container-runtime 2.0.0-internal.1.2.0.93071 → 2.0.0-internal.1.2.1

package/lib/containerRuntime.js

@@ -101,9 +101,12 @@ export function isRuntimeMessage(message) {
 }
 /**
  * Unpacks runtime messages
- * @internal - no promises RE back-compat - this is internal API.
+ *
+ * @remarks This API makes no promises regarding backward-compatability. This is internal API.
  * @param message - message (as it observed in storage / service)
  * @returns unpacked runtime message
+ *
+ * @internal
  */
 export function unpackRuntimeMessage(message) {
     if (message.type === MessageType.Operation) {
@@ -179,7 +182,12 @@ export class ContainerRuntime extends TypedEventEmitter {
             signalTimestamp: 0,
             trackingSignalSequenceNumber: undefined,
         };
-        this.batchManager = new BatchManager();
+        // 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);
@@ -237,6 +245,8 @@ export class ContainerRuntime extends TypedEventEmitter {
             getNodePackagePath: async (nodePath) => this.getGCNodePackagePath(nodePath),
             getLastSummaryTimestampMs: () => { var _a; return (_a = this.messageAtLastSummary) === null || _a === void 0 ? void 0 : _a.timestamp; },
             readAndParseBlob: async (id) => readAndParse(this.storage, id),
+            getContainerDiagnosticId: () => this.context.id,
+            activeConnection: () => this.deltaManager.active,
         });
         const loadedFromSequenceNumber = this.deltaManager.initialSequenceNumber;
         this.summarizerNode = createRootSummarizerNodeWithGC(ChildLogger.create(this.logger, "SummarizerNode"), 
@@ -264,7 +274,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 this.submit(ContainerMessageType.BlobAttach, undefined, undefined, { blobId, localId });
             }
         }, (blobPath) => this.garbageCollector.nodeUpdated(blobPath, "Loaded"), this, pendingRuntimeState === null || pendingRuntimeState === void 0 ? void 0 : pendingRuntimeState.pendingAttachmentBlobs);
-        this.scheduleManager = new ScheduleManager(context.deltaManager, this, ChildLogger.create(this.logger, "ScheduleManager"));
+        this.scheduleManager = new ScheduleManager(context.deltaManager, this, () => this.clientId, ChildLogger.create(this.logger, "ScheduleManager"));
         this.deltaSender = this.deltaManager;
         this.pendingStateManager = new PendingStateManager({
             applyStashedOp: this.applyStashedOp.bind(this),
@@ -500,6 +510,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         return (_a = this.summarizerClientElection) === null || _a === void 0 ? void 0 : _a.electedClientId;
     }
     get disposed() { return this._disposed; }
+    get emptyBatch() {
+        return this.pendingBatch.empty && this.pendingAttachBatch.empty;
+    }
     get summarizer() {
         assert(this._summarizer !== undefined, 0x257 /* "This is not summarizing container" */);
         return this._summarizer;
@@ -531,12 +544,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (this.runtimeOptions.summaryOptions.summarizerClientElection === true) {
             return true;
         }
-        if (this.summaryConfiguration.state !== "disabled") {
-            return this.summaryConfiguration.summarizerClientElection === true;
-        }
-        else {
-            return false;
-        }
+        return this.summaryConfiguration.state !== "disabled"
+            ? this.summaryConfiguration.summarizerClientElection === true
+            : false;
     }
     getMaxOpsSinceLastSummary() {
         // back-compat: maxOpsSinceLastSummary was moved from ISummaryRuntimeOptions
@@ -544,12 +554,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (this.runtimeOptions.summaryOptions.maxOpsSinceLastSummary !== undefined) {
             return this.runtimeOptions.summaryOptions.maxOpsSinceLastSummary;
         }
-        if (this.summaryConfiguration.state !== "disabled") {
-            return this.summaryConfiguration.maxOpsSinceLastSummary;
-        }
-        else {
-            return 0;
-        }
+        return this.summaryConfiguration.state !== "disabled"
+            ? this.summaryConfiguration.maxOpsSinceLastSummary
+            : 0;
     }
     getInitialSummarizerDelayMs() {
         // back-compat: initialSummarizerDelayMs was moved from ISummaryRuntimeOptions
@@ -557,12 +564,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (this.runtimeOptions.summaryOptions.initialSummarizerDelayMs !== undefined) {
             return this.runtimeOptions.summaryOptions.initialSummarizerDelayMs;
         }
-        if (this.summaryConfiguration.state !== "disabled") {
-            return this.summaryConfiguration.initialSummarizerDelayMs;
-        }
-        else {
-            return 0;
-        }
+        return this.summaryConfiguration.state !== "disabled"
+            ? this.summaryConfiguration.initialSummarizerDelayMs
+            : 0;
     }
     dispose(error) {
         var _a;
@@ -636,16 +640,12 @@ export class ContainerRuntime extends TypedEventEmitter {
             }
             if (id === BlobManager.basePath && requestParser.isLeaf(2)) {
                 const blob = await this.blobManager.getBlob(requestParser.pathParts[1]);
-                if (blob) {
-                    return {
+                return blob
+                    ? {
                         status: 200,
                         mimeType: "fluid/object",
                         value: blob,
-                    };
-                }
-                else {
-                    return create404Response(request);
-                }
+                    } : create404Response(request);
             }
             else if (requestParser.pathParts.length > 0) {
                 const dataStore = await this.getDataStoreFromRequest(id, request);
@@ -851,7 +851,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             this._perfSignalData.trackingSignalSequenceNumber = undefined;
         }
         else {
-            assert(this.attachState === AttachState.Attached, "Connection is possible only if container exists in storage");
+            assert(this.attachState === AttachState.Attached, 0x3cd /* Connection is possible only if container exists in storage */);
         }
         // Fail while disconnected
         if (reconnection) {
@@ -871,6 +871,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             this.replayPendingStates();
         }
         this.dataStores.setConnectionState(connected, clientId);
+        this.garbageCollector.setConnectionState(connected, clientId);
         raiseConnectedEvent(this.mc.logger, this, connected, clientId);
     }
     process(messageArg, local) {
@@ -928,7 +929,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 case ContainerMessageType.Rejoin:
                     break;
                 default:
-                    assert(!runtimeMessage, "Runtime message of unknown type");
+                    assert(!runtimeMessage, 0x3ce /* Runtime message of unknown type */);
             }
             // For back-compat, notify only about runtime messages for now.
             if (runtimeMessage) {
@@ -1027,9 +1028,9 @@ export class ContainerRuntime extends TypedEventEmitter {
     }
     flush() {
         assert(this._orderSequentiallyCalls === 0, 0x24c /* "Cannot call `flush()` from `orderSequentially`'s callback" */);
-        const batch = this.batchManager.popBatch();
-        this.flushBatch(batch);
-        assert(this.batchManager.empty, "reentrancy");
+        this.flushBatch(this.pendingAttachBatch.popBatch());
+        this.flushBatch(this.pendingBatch.popBatch());
+        assert(this.emptyBatch, 0x3cf /* reentrancy */);
     }
     flushBatch(batch) {
         const length = batch.length;
@@ -1069,7 +1070,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             }
             // Convert from clientSequenceNumber of last message in the batch to clientSequenceNumber of first message.
             clientSequenceNumber -= batch.length - 1;
-            assert(clientSequenceNumber >= 0, "clientSequenceNumber can't be negative");
+            assert(clientSequenceNumber >= 0, 0x3d0 /* clientSequenceNumber can't be negative */);
         }
         // Let the PendingStateManager know that a message was submitted.
         // In future, need to shift toward keeping batch as a whole!
@@ -1102,7 +1103,10 @@ export class ContainerRuntime extends TypedEventEmitter {
     trackOrderSequentiallyCalls(callback) {
         let checkpoint;
         if (this.mc.config.getBoolean("Fluid.ContainerRuntime.EnableRollback")) {
-            checkpoint = this.batchManager.checkpoint();
+            // Note: we are not touching this.pendingAttachBatch here, for two reasons:
+            // 1. It would not help, as we flush attach ops as they become available.
+            // 2. There is no way to undo process of data store creation.
+            checkpoint = this.pendingBatch.checkpoint();
         }
         try {
             this._orderSequentiallyCalls++;
@@ -1389,7 +1393,7 @@ export class ContainerRuntime extends TypedEventEmitter {
     }
     /**
      * Runs garbage collection and updates the reference / used state of the nodes in the container.
-     * @returns the statistics of the garbage collection run.
+     * @returns the statistics of the garbage collection run; undefined if GC did not run.
      */
     async collectGarbage(options) {
         return this.garbageCollector.collectGarbage(options);
@@ -1420,7 +1424,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         const summaryNumberLogger = ChildLogger.create(summaryLogger, undefined, {
             all: { summaryNumber },
         });
-        assert(this.batchManager.empty, "Can't trigger summary in the middle of a batch");
+        assert(this.emptyBatch, 0x3d1 /* Can't trigger summary in the middle of a batch */);
         let latestSnapshotVersionId;
         if (refreshLatestAck) {
             const latestSnapshotInfo = await this.refreshLatestSummaryAckFromServer(ChildLogger.create(summaryNumberLogger, undefined, { all: { safeSummary: true } }));
@@ -1495,7 +1499,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             const forcedFullTree = this.garbageCollector.summaryStateNeedsReset;
             try {
                 summarizeResult = await this.summarize({
-                    fullTree: fullTree || forcedFullTree,
+                    fullTree: fullTree !== null && fullTree !== void 0 ? fullTree : forcedFullTree,
                     trackState: true,
                     summaryLogger: summaryNumberLogger,
                     runGC: this.garbageCollector.shouldRunGC,
@@ -1633,15 +1637,15 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
     }
     hasPendingMessages() {
-        return this.pendingStateManager.hasPendingMessages() || !this.batchManager.empty;
+        return this.pendingStateManager.hasPendingMessages() || !this.emptyBatch;
     }
     updateDocumentDirtyState(dirty) {
         if (this.attachState !== AttachState.Attached) {
-            assert(dirty, "Non-attached container is dirty");
+            assert(dirty, 0x3d2 /* Non-attached container is dirty */);
         }
         else {
             // Other way is not true = see this.isContainerMessageDirtyable()
-            assert(!dirty || this.hasPendingMessages(), "if doc is dirty, there has to be pending ops");
+            assert(!dirty || this.hasPendingMessages(), 0x3d3 /* if doc is dirty, there has to be pending ops */);
         }
         if (this.dirtyContainer === dirty) {
             return;
@@ -1698,31 +1702,54 @@ export class ContainerRuntime extends TypedEventEmitter {
             //    failure (batch is too large). Pushing them earlier and outside of main batch should alleviate
             //    these issues.
             // Cons:
-            //    With large batches, relay service may throttle clients. Clients may disconnect while throttled.
+            //    1. With large batches, relay service may throttle clients. Clients may disconnect while throttled.
             //    This change creates new possibility of a lot of newly created data stores never being referenced
             //    because client died before it had a change to submit the rest of the ops. This will create more
             //    garbage that needs to be collected leveraging GC (Garbage Collection) feature.
+            //    2. Sending ops out of order means they are excluded from rollback functionality. This is not an issue
+            //    today as rollback can't undo creation of data store. To some extent not sending them is a bigger
+            //    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 (this._flushMode === FlushMode.TurnBased && type === ContainerMessageType.Attach &&
+            if (type === ContainerMessageType.Attach &&
                 this.mc.config.getBoolean("Fluid.ContainerRuntime.disableAttachOpReorder") !== true) {
-                this.flushBatch([message]);
+                if (!this.pendingAttachBatch.push(message)) {
+                    // BatchManager has two limits - soft limit & hard limit. Soft limit is only engaged
+                    // when queue is not empty.
+                    // Flush queue & retry. Failure on retry would mean - single message is bigger than hard limit
+                    this.flushBatch(this.pendingAttachBatch.popBatch());
+                    if (!this.pendingAttachBatch.push(message)) {
+                        throw new GenericError("BatchTooLarge", 
+                        /* error */ undefined, {
+                            opSize: message.contents.length,
+                            count: this.pendingAttachBatch.length,
+                            limit: this.pendingAttachBatch.limit,
+                        });
+                    }
+                }
             }
             else {
-                this.batchManager.push(message);
-                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;
-                        this.flush();
+                if (!this.pendingBatch.push(message)) {
+                    throw new GenericError("BatchTooLarge", 
+                    /* error */ undefined, {
+                        opSize: message.contents.length,
+                        count: this.pendingBatch.length,
+                        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;
+                    this.flush();
+                });
+            }
         }
         catch (error) {
             this.closeFn(error);
@@ -1736,14 +1763,11 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.verifyNotClosed();
         assert(this.connected, 0x133 /* "Container disconnected when trying to submit system message" */);
         // System message should not be sent in the middle of the batch.
-        assert(this.batchManager.empty, "System op in the middle of a batch");
+        assert(this.emptyBatch, 0x3d4 /* System op in the middle of a batch */);
         // back-compat: ADO #1385: Make this call unconditional in the future
-        if (this.context.submitSummaryFn !== undefined) {
-            return this.context.submitSummaryFn(contents);
-        }
-        else {
-            return this.context.submitFn(MessageType.Summarize, contents, false); // batch
-        }
+        return this.context.submitSummaryFn !== undefined
+            ? this.context.submitSummaryFn(contents)
+            : this.context.submitFn(MessageType.Summarize, contents, false);
     }
     /**
      * Throw an error if the runtime is closed.  Methods that are expected to potentially
@@ -1923,7 +1947,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         // don't have any more saved ops
         await this.pendingStateManager.applyStashedOpsAt();
         // If it's not the case, we should take it into account when calculating dirty state.
-        assert(this.context.attachState === AttachState.Attached, "this function is called for attached containers only");
+        assert(this.context.attachState === AttachState.Attached, 0x3d5 /* this function is called for attached containers only */);
         if (!this.hasPendingMessages()) {
             this.updateDocumentDirtyState(false);
         }