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

package/src/containerRuntime.ts

@@ -204,7 +204,7 @@ export interface ContainerRuntimeMessage {
 
 export interface ISummaryBaseConfiguration {
     /**
-     *  Delay before first attempt to spawn summarizing container.
+     * Delay before first attempt to spawn summarizing container.
      */
     initialSummarizerDelayMs: number;
 
@@ -540,9 +540,12 @@ export function isRuntimeMessage(message: ISequencedDocumentMessage): boolean {
 
 /**
  * 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: ISequencedDocumentMessage) {
     if (message.type === MessageType.Operation) {
@@ -850,7 +853,14 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
     private readonly scheduleManager: ScheduleManager;
     private readonly blobManager: BlobManager;
     private readonly pendingStateManager: PendingStateManager;
-    private readonly 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).
+    private readonly pendingAttachBatch = new BatchManager(64 * 1024);
+    private readonly pendingBatch = new BatchManager();
+
     private readonly garbageCollector: IGarbageCollector;
 
     // Local copy of incomplete received chunks.
@@ -861,6 +871,10 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
     /** The last message processed at the time of the last summary. */
     private messageAtLastSummary: ISummaryMetadataMessage | undefined;
 
+    private get emptyBatch() {
+        return this.pendingBatch.empty && this.pendingAttachBatch.empty;
+    }
+
     private get summarizer(): Summarizer {
         assert(this._summarizer !== undefined, 0x257 /* "This is not summarizing container" */);
         return this._summarizer;
@@ -896,11 +910,9 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         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;
     }
     private readonly maxOpsSinceLastSummary: number;
     private getMaxOpsSinceLastSummary(): number {
@@ -909,11 +921,9 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         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;
     }
 
     private readonly initialSummarizerDelayMs: number;
@@ -923,11 +933,9 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         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;
     }
 
     private readonly createContainerMetadata: ICreateContainerMetadata;
@@ -998,6 +1006,8 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             getNodePackagePath: async (nodePath: string) => this.getGCNodePackagePath(nodePath),
             getLastSummaryTimestampMs: () => this.messageAtLastSummary?.timestamp,
             readAndParseBlob: async <T>(id: string) => readAndParse<T>(this.storage, id),
+            getContainerDiagnosticId: () => this.context.id,
+            activeConnection: () => this.deltaManager.active,
         });
 
         const loadedFromSequenceNumber = this.deltaManager.initialSequenceNumber;
@@ -1072,6 +1082,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         this.scheduleManager = new ScheduleManager(
             context.deltaManager,
             this,
+            () => this.clientId,
             ChildLogger.create(this.logger, "ScheduleManager"),
         );
 
@@ -1320,15 +1331,12 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
 
             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);
                 const subRequest = requestParser.createSubRequest(1);
@@ -1575,7 +1583,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             this._perfSignalData.trackingSignalSequenceNumber = undefined;
         } else {
             assert(this.attachState === AttachState.Attached,
-                "Connection is possible only if container exists in storage");
+                0x3cd /* Connection is possible only if container exists in storage */);
         }
 
         // Fail while disconnected
@@ -1603,6 +1611,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         }
 
         this.dataStores.setConnectionState(connected, clientId);
+        this.garbageCollector.setConnectionState(connected, clientId);
 
         raiseConnectedEvent(this.mc.logger, this, connected, clientId);
     }
@@ -1670,7 +1679,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
                 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.
@@ -1791,10 +1800,10 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         assert(this._orderSequentiallyCalls === 0,
             0x24c /* "Cannot call `flush()` from `orderSequentially`'s callback" */);
 
-        const batch = this.batchManager.popBatch();
-        this.flushBatch(batch);
+        this.flushBatch(this.pendingAttachBatch.popBatch());
+        this.flushBatch(this.pendingBatch.popBatch());
 
-        assert(this.batchManager.empty, "reentrancy");
+        assert(this.emptyBatch, 0x3cf /* reentrancy */);
     }
 
     protected flushBatch(batch: BatchMessage[]): void {
@@ -1843,7 +1852,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
 
             // 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.
@@ -1888,7 +1897,10 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
     private trackOrderSequentiallyCalls(callback: () => void): void {
         let checkpoint: { rollback: (action: (message: BatchMessage) => void) => void; } | undefined;
         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 {
@@ -2270,7 +2282,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
 
     /**
      * 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.
      */
     public async collectGarbage(
         options: {
@@ -2281,7 +2293,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             /** True to generate full GC data */
             fullGC?: boolean;
         },
-    ): Promise<IGCStats> {
+    ): Promise<IGCStats | undefined> {
         return this.garbageCollector.collectGarbage(options);
     }
 
@@ -2316,7 +2328,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             },
         );
 
-        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: string | undefined;
         if (refreshLatestAck) {
@@ -2407,7 +2419,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             const forcedFullTree = this.garbageCollector.summaryStateNeedsReset;
             try {
                 summarizeResult = await this.summarize({
-                    fullTree: fullTree || forcedFullTree,
+                    fullTree: fullTree ?? forcedFullTree,
                     trackState: true,
                     summaryLogger: summaryNumberLogger,
                     runGC: this.garbageCollector.shouldRunGC,
@@ -2575,16 +2587,16 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
     }
 
     private hasPendingMessages() {
-        return this.pendingStateManager.hasPendingMessages() || !this.batchManager.empty;
+        return this.pendingStateManager.hasPendingMessages() || !this.emptyBatch;
     }
 
     private updateDocumentDirtyState(dirty: boolean) {
         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");
+                0x3d3 /* if doc is dirty, there has to be pending ops */);
         }
 
         if (this.dirtyContainer === dirty) {
@@ -2661,29 +2673,57 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             //    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 &&
-                    this.mc.config.getBoolean("Fluid.ContainerRuntime.disableAttachOpReorder") !== true) {
-                this.flushBatch([message]);
+            if (type === ContainerMessageType.Attach &&
+                this.mc.config.getBoolean("Fluid.ContainerRuntime.disableAttachOpReorder") !== true) {
+                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 as GenericError);
             throw error;
@@ -2699,17 +2739,15 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         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(
+        return this.context.submitSummaryFn !== undefined
+            ? this.context.submitSummaryFn(contents)
+            : this.context.submitFn(
                 MessageType.Summarize,
                 contents,
-                false); // batch
-        }
+                false);
     }
 
     /**
@@ -2785,25 +2823,25 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         // It should only be done by the summarizerNode, if required.
         const snapshotTreeFetcher = async () => {
             const fetchResult = await this.fetchSnapshotFromStorage(
-             ackHandle,
-             summaryLogger,
-             {
-                 eventName: "RefreshLatestSummaryGetSnapshot",
-                 ackHandle,
-                 summaryRefSeq,
-                 fetchLatest: false,
-             });
-             return fetchResult.snapshotTree;
-         };
-         const result = await this.summarizerNode.refreshLatestSummary(
-             proposalHandle,
-             summaryRefSeq,
-             snapshotTreeFetcher,
-             readAndParseBlob,
-             summaryLogger,
-         );
-
-         // Notify the garbage collector so it can update its latest summary state.
+                ackHandle,
+                summaryLogger,
+                {
+                    eventName: "RefreshLatestSummaryGetSnapshot",
+                    ackHandle,
+                    summaryRefSeq,
+                    fetchLatest: false,
+                });
+            return fetchResult.snapshotTree;
+        };
+        const result = await this.summarizerNode.refreshLatestSummary(
+            proposalHandle,
+            summaryRefSeq,
+            snapshotTreeFetcher,
+            readAndParseBlob,
+            summaryLogger,
+        );
+
+        // Notify the garbage collector so it can update its latest summary state.
         await this.garbageCollector.latestSummaryStateRefreshed(result, readAndParseBlob);
     }
 
@@ -2987,7 +3025,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
 
         // 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");
+            0x3d5 /* this function is called for attached containers only */);
         if (!this.hasPendingMessages()) {
             this.updateDocumentDirtyState(false);
         }

package/src/dataStoreContext.ts

@@ -37,6 +37,7 @@ import {
     IContainerRuntime,
 } from "@fluidframework/container-runtime-definitions";
 import {
+    BindState,
     channelsTreeName,
     CreateChildSummarizerNodeFn,
     CreateChildSummarizerNodeParam,
@@ -224,9 +225,8 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
     protected registry: IFluidDataStoreRegistry | undefined;
 
     protected detachedRuntimeCreation = false;
-    // back-compat (for tests) - can be removed in 2.0.0-alpha.2.0.0, or earlier if compat tests drop n/n-2 coverage
-    // @ts-expect-error - This shouldn't be referenced in the current version, but needs to be here for back-compat
-    private readonly bindToContext: () => void;
+    /** @deprecated - To be replaced by calling makeLocallyVisible directly  */
+    public readonly bindToContext: () => void;
     protected channel: IFluidDataStoreChannel | undefined;
     private loaded = false;
     protected pending: ISequencedDocumentMessage[] | undefined = [];
@@ -253,6 +253,7 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
     constructor(
         props: IFluidDataStoreContextProps,
         private readonly existing: boolean,
+        private bindState: BindState,  // Used to assert for state tracking purposes
         public readonly isLocalDataStore: boolean,
         private readonly makeLocallyVisibleFn: () => void,
     ) {
@@ -273,8 +274,11 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
             this.containerRuntime.attachState : AttachState.Detached;
 
         this.bindToContext = () => {
+            assert(this.bindState === BindState.NotBound, 0x13b /* "datastore context is already in bound state" */);
+            this.bindState = BindState.Binding;
             assert(this.channel !== undefined, 0x13c /* "undefined channel on datastore context" */);
             this.makeLocallyVisible();
+            this.bindState = BindState.Bound;
         };
 
         const thisSummarizeInternal =
@@ -515,12 +519,18 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
 
     /**
      * After GC has run, called to notify the data store of routes used in it. These are used for the following:
+     *
      * 1. To identify if this data store is being referenced in the document or not.
+     *
      * 2. To determine if it needs to re-summarize in case used routes changed since last summary.
+     *
      * 3. These are added to the summary generated by the data store.
-     * 4. To notify child contexts of their used routes. This is done immediately if the data store is loaded. Else,
-     *    it is done when realizing the data store.
+     *
+     * 4. To notify child contexts of their used routes. This is done immediately if the data store is loaded.
+     * Else, it is done when realizing the data store.
+     *
      * 5. To update the timestamp when this data store or any children are marked as unreferenced.
+     *
      * @param usedRoutes - The routes that are used in this data store.
      * @param gcTimestamp - The time when GC was run that generated these used routes. If any node becomes unreferenced
      * as part of this GC run, this should be used to update the time when it happens.
@@ -776,6 +786,7 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
         super(
             props,
             true /* existing */,
+            BindState.Bound,
             false /* isLocalDataStore */,
             () => {
                 throw new Error("Already attached");
@@ -814,11 +825,9 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
             // For snapshotFormatVersion = "0.1" (1) or above, pkg is jsonified, otherwise it is just a string.
             const formatVersion = getAttributesFormatVersion(attributes);
             if (formatVersion < 1) {
-                if (attributes.pkg.startsWith("[\"") && attributes.pkg.endsWith("\"]")) {
-                    pkgFromSnapshot = JSON.parse(attributes.pkg) as string[];
-                } else {
-                    pkgFromSnapshot = [attributes.pkg];
-                }
+                pkgFromSnapshot = attributes.pkg.startsWith("[\"") && attributes.pkg.endsWith("\"]")
+                    ? JSON.parse(attributes.pkg) as string[]
+                    : [attributes.pkg];
             } else {
                 pkgFromSnapshot = JSON.parse(attributes.pkg) as string[];
             }
@@ -880,6 +889,7 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
         super(
             props,
             props.snapshotTree !== undefined ? true : false /* existing */,
+            props.snapshotTree ? BindState.Bound : BindState.NotBound,
             true /* isLocalDataStore */,
             props.makeLocallyVisibleFn,
         );

package/src/dataStores.ts

@@ -469,12 +469,7 @@ export class DataStores implements IDisposable {
     }
 
     public setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void {
-        let eventName: "attaching" | "attached";
-        if (attachState === AttachState.Attaching) {
-            eventName = "attaching";
-        } else {
-            eventName = "attached";
-        }
+        const eventName = attachState === AttachState.Attaching ? "attaching" : "attached";
         for (const [, context] of this.contexts) {
             // Fire only for bounded stores.
             if (!this.contexts.isNotBound(context.id)) {
@@ -566,11 +561,15 @@ export class DataStores implements IDisposable {
 
     /**
      * Generates data used for garbage collection. It does the following:
+     *
      * 1. Calls into each child data store context to get its GC data.
+     *
      * 2. Prefixes the child context's id to the GC nodes in the child's GC data. This makes sure that the node can be
-     *    identified as belonging to the child.
+     * identified as belonging to the child.
+     *
      * 3. Adds a GC node for this channel to the nodes received from the children. All these nodes together represent
-     *    the GC data of this channel.
+     * the GC data of this channel.
+     *
      * @param fullGC - true to bypass optimizations and force full generation of GC data.
      */
     public async getGCData(fullGC: boolean = false): Promise<IGarbageCollectionData> {

package/src/deltaScheduler.ts

@@ -18,12 +18,14 @@ import {
  * DeltaScheduler is responsible for the scheduling of inbound delta queue in cases where there
  * is more than one op a particular run of the queue. It does not schedule if there is just one
  * op or just one batch in the run. It does the following two things:
+ *
  * 1. If the ops have been processed for more than a specific amount of time, it pauses the queue
- *    and calls setTimeout to schedule a resume of the queue. This ensures that we don't block
- *    the JS thread for a long time processing ops synchronously (for example, when catching up
- *    ops right after boot or catching up ops / delayed realizing data stores by summarizer).
+ * and calls setTimeout to schedule a resume of the queue. This ensures that we don't block
+ * the JS thread for a long time processing ops synchronously (for example, when catching up
+ * ops right after boot or catching up ops / delayed realizing data stores by summarizer).
+ *
  * 2. If we scheduled a particular run of the queue, it logs telemetry for the number of ops
- *    processed, the time and number of turns it took to process the ops.
+ * processed, the time and number of turns it took to process the ops.
  */
 export class DeltaScheduler {
     private readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;