@fluidframework/container-runtime 0.54.2 → 0.56.0-49831

package/lib/containerRuntime.js

@@ -7,7 +7,7 @@ import { assert, Trace, TypedEventEmitter, unreachableCase, performance, } from
 import { ChildLogger, raiseConnectedEvent, PerformanceEvent, normalizeError, TaggedLoggerAdapter, loggerToMonitoringContext, } from "@fluidframework/telemetry-utils";
 import { DriverHeader } from "@fluidframework/driver-definitions";
 import { readAndParse, BlobAggregationStorage } from "@fluidframework/driver-utils";
-import { CreateProcessingError, DataCorruptionError, GenericError, UsageError, extractSafePropertiesFromMessage, } from "@fluidframework/container-utils";
+import { DataCorruptionError, GenericError, UsageError, extractSafePropertiesFromMessage, } from "@fluidframework/container-utils";
 import { MessageType, SummaryType, } from "@fluidframework/protocol-definitions";
 import { FlushMode, channelsTreeName, } from "@fluidframework/runtime-definitions";
 import { addBlobToSummary, addTreeToSummary, convertToSummaryTree, createRootSummarizerNodeWithGC, RequestParser, create404Response, exceptionToResponse, requestFluidObject, responseToException, seqFromTree, convertSummaryTreeToITree, } from "@fluidframework/runtime-utils";
@@ -56,21 +56,24 @@ const DefaultSummaryConfiguration = {
     // the min of the two will be chosen
     maxAckWaitTime: 120000,
 };
+;
 // Local storage key to set the default flush mode to TurnBased
 const turnBasedFlushModeKey = "Fluid.ContainerRuntime.FlushModeTurnBased";
+export var RuntimeMessage;
+(function (RuntimeMessage) {
+    RuntimeMessage["FluidDataStoreOp"] = "component";
+    RuntimeMessage["Attach"] = "attach";
+    RuntimeMessage["ChunkedOp"] = "chunkedOp";
+    RuntimeMessage["BlobAttach"] = "blobAttach";
+    RuntimeMessage["Rejoin"] = "rejoin";
+    RuntimeMessage["Alias"] = "alias";
+    RuntimeMessage["Operation"] = "op";
+})(RuntimeMessage || (RuntimeMessage = {}));
 export function isRuntimeMessage(message) {
-    switch (message.type) {
-        case ContainerMessageType.FluidDataStoreOp:
-        case ContainerMessageType.ChunkedOp:
-        case ContainerMessageType.Attach:
-        case ContainerMessageType.Alias:
-        case ContainerMessageType.BlobAttach:
-        case ContainerMessageType.Rejoin:
-        case MessageType.Operation:
-            return true;
-        default:
-            return false;
+    if (Object.values(RuntimeMessage).includes(message.type)) {
+        return true;
     }
+    return false;
 }
 export function unpackRuntimeMessage(message) {
     if (message.type === MessageType.Operation) {
@@ -344,6 +347,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         this._disposed = false;
         this.dirtyContainer = false;
         this.emitDirtyDocumentEvent = true;
+        this.summarizerWarning = (warning) => this.mc.logger.sendTelemetryEvent({ eventName: "summarizerWarning" }, warning);
         /**
          * Used to apply stashed ops at their reference sequence number.
          * Normal op processing is synchronous, but applying stashed ops is async since the
@@ -365,10 +369,6 @@ export class ContainerRuntime extends TypedEventEmitter {
                 this.closeFn(normalizeError(error));
             });
         };
-        // @deprecated Needs to become private
-        this.raiseContainerWarning = (warning) => {
-            this.context.raiseContainerWarning(warning);
-        };
         this.summarizeOnDemand = (...args) => {
             if (this.clientDetails.type === summarizerClientType) {
                 return this.summarizer.summarizeOnDemand(...args);
@@ -434,7 +434,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             const timestamp = client === null || client === void 0 ? void 0 : client.timestamp;
             return (_c = (_b = (_a = this.deltaManager.lastMessage) === null || _a === void 0 ? void 0 : _a.timestamp) !== null && _b !== void 0 ? _b : timestamp) !== null && _c !== void 0 ? _c : Date.now();
         };
-        this.garbageCollector = GarbageCollector.create(this, this.runtimeOptions.gcOptions, (unusedRoutes) => this.dataStores.deleteUnusedRoutes(unusedRoutes), getCurrentTimestamp, context.baseSnapshot, async (id) => readAndParse(this.storage, id), this.mc.logger, existing, metadata);
+        this.garbageCollector = GarbageCollector.create(this, this.runtimeOptions.gcOptions, (unusedRoutes) => this.dataStores.deleteUnusedRoutes(unusedRoutes), getCurrentTimestamp, this.closeFn, context.baseSnapshot, async (id) => readAndParse(this.storage, id), this.mc.logger, existing, metadata);
         const loadedFromSequenceNumber = this.deltaManager.initialSequenceNumber;
         this.summarizerNode = createRootSummarizerNodeWithGC(ChildLogger.create(this.logger, "SummarizerNode"), 
         // Summarize function to call when summarize is called. Summarizer node always tracks summary state.
@@ -455,7 +455,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (this.context.baseSnapshot) {
             this.summarizerNode.loadBaseSummaryWithoutDifferential(this.context.baseSnapshot);
         }
-        this.dataStores = new DataStores(getSummaryForDatastores(context.baseSnapshot, metadata), this, (attachMsg) => this.submit(ContainerMessageType.Attach, attachMsg), (id, createParam) => (summarizeInternal, getGCDataFn, getInitialGCSummaryDetailsFn) => this.summarizerNode.createChild(summarizeInternal, id, createParam, undefined, getGCDataFn, getInitialGCSummaryDetailsFn), (id) => this.summarizerNode.deleteChild(id), this.mc.logger, async () => this.garbageCollector.getDataStoreBaseGCDetails(), (id) => this.garbageCollector.nodeChanged(id), new Map(dataStoreAliasMap));
+        this.dataStores = new DataStores(getSummaryForDatastores(context.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.getDataStoreBaseGCDetails(), (id) => this.garbageCollector.nodeChanged(id), new Map(dataStoreAliasMap), this.garbageCollector.writeDataAtRoot);
         this.blobManager = new BlobManager(this.handleContext, blobManagerSnapshot, () => this.storage, (blobId) => this.submit(ContainerMessageType.BlobAttach, undefined, undefined, { blobId }), this, this.logger);
         this.scheduleManager = new ScheduleManager(context.deltaManager, this, ChildLogger.create(this.logger, "ScheduleManager"));
         this.deltaSender = this.deltaManager;
@@ -508,7 +508,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 formExponentialFn({ coefficient: 20, initialDelay: 0 })), {
                     initialDelayMs: this.runtimeOptions.summaryOptions.initialSummarizerDelayMs,
                 }, this.runtimeOptions.summaryOptions.summarizerOptions);
-                this.summaryManager.on("summarizerWarning", this.raiseContainerWarning);
+                this.summaryManager.on("summarizerWarning", this.summarizerWarning);
                 this.summaryManager.start();
             }
         }
@@ -553,6 +553,7 @@ export class ContainerRuntime extends TypedEventEmitter {
     static async load(context, registryEntries, requestHandler, runtimeOptions = {}, containerScope = context.scope, existing) {
         var _a, _b, _c;
         // If taggedLogger exists, use it. Otherwise, wrap the vanilla logger:
+        // back-compat: Remove the TaggedLoggerAdapter fallback once all the host are using loader > 0.45
         const passLogger = (_a = context.taggedLogger) !== null && _a !== void 0 ? _a : new TaggedLoggerAdapter(context.logger);
         const logger = ChildLogger.create(passLogger, undefined, {
             all: {
@@ -630,12 +631,6 @@ export class ContainerRuntime extends TypedEventEmitter {
         }, containerScope, logger, loadExisting, blobManagerSnapshot, requestHandler, storage);
         return runtime;
     }
-    /**
-    * @deprecated This will be removed in a later release. Deprecated in 0.53
-    */
-    get id() {
-        return this.context.id;
-    }
     get options() {
         return this.context.options;
     }
@@ -699,13 +694,6 @@ export class ContainerRuntime extends TypedEventEmitter {
         return Object.assign(Object.assign(Object.assign({}, DefaultSummaryConfiguration), (_b = (_a = this.context) === null || _a === void 0 ? void 0 : _a.serviceConfiguration) === null || _b === void 0 ? void 0 : _b.summary), (_c = this.runtimeOptions.summaryOptions) === null || _c === void 0 ? void 0 : _c.summaryConfigOverrides);
     }
     get disposed() { return this._disposed; }
-    /**
-     * True, if GC data should be written at root of the summary tree.
-     * False, if data stores should write GC blobs in their summary tree.
-     */
-    get writeGCDataAtRoot() {
-        return this.garbageCollector.writeDataAtRoot;
-    }
     get summarizer() {
         assert(this._summarizer !== undefined, 0x257 /* "This is not summarizing container" */);
         return this._summarizer;
@@ -728,9 +716,10 @@ export class ContainerRuntime extends TypedEventEmitter {
             attachState: this.attachState,
         }, error);
         if (this.summaryManager !== undefined) {
-            this.summaryManager.off("summarizerWarning", this.raiseContainerWarning);
+            this.summaryManager.off("summarizerWarning", this.summarizerWarning);
             this.summaryManager.dispose();
         }
+        this.garbageCollector.dispose();
         (_a = this._summarizer) === null || _a === void 0 ? void 0 : _a.dispose();
         this.dataStores.dispose();
         this.pendingStateManager.dispose();
@@ -746,9 +735,6 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
         return undefined;
     }
-    get IFluidConfiguration() {
-        return this.context.configuration;
-    }
     /**
      * Notifies this object about the request made to the container.
      * @param request - Request made to the handler.
@@ -831,7 +817,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         return Object.assign(Object.assign({}, this.createContainerMetadata), { summaryCount: this.summaryCount, summaryFormatVersion: 1, disableIsolatedChannels: this.disableIsolatedChannels || undefined, gcFeature: this.garbageCollector.gcSummaryFeatureVersion, 
             // The last message processed at the time of summary. If there are no messages, nothing has changed from
             // the base summary we loaded from. So, use the message from its metadata blob.
-            message: (_a = extractSummaryMetadataMessage(this.deltaManager.lastMessage)) !== null && _a !== void 0 ? _a : this.baseSummaryMessage });
+            message: (_a = extractSummaryMetadataMessage(this.deltaManager.lastMessage)) !== null && _a !== void 0 ? _a : this.baseSummaryMessage, sessionExpiryTimeoutMs: this.garbageCollector.sessionExpiryTimeoutMs });
     }
     /**
      * Retrieves the runtime for a data store if it's referenced as per the initially summary that it is loaded with.
@@ -845,7 +831,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         const dataStoreContext = await this.dataStores.getDataStore(id, wait);
         // The data store is referenced if used routes in the initial summary has a route to self.
         // Older documents may not have used routes in the summary. They are considered referenced.
-        const usedRoutes = (await dataStoreContext.getInitialGCSummaryDetails()).usedRoutes;
+        const usedRoutes = (await dataStoreContext.getBaseGCDetails()).usedRoutes;
         if (usedRoutes === undefined || usedRoutes.includes("") || usedRoutes.includes("/")) {
             return dataStoreContext.realize();
         }
@@ -867,7 +853,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         });
         return convertSummaryTreeToITree(summaryResult.summary);
     }
-    addContainerBlobsToSummary(summaryTree) {
+    addContainerStateToSummary(summaryTree) {
         var _a;
         addBlobToSummary(summaryTree, metadataBlobName, JSON.stringify(this.formMetadata()));
         if (this.chunkMap.size > 0) {
@@ -889,7 +875,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             const blobsTree = convertToSummaryTree(snapshot, false);
             addTreeToSummary(summaryTree, blobsTreeName, blobsTree);
         }
-        if (this.writeGCDataAtRoot) {
+        if (this.garbageCollector.writeDataAtRoot) {
             const gcSummary = this.garbageCollector.summarize();
             if (gcSummary !== undefined) {
                 addTreeToSummary(summaryTree, gcTreeKey, gcSummary);
@@ -1077,21 +1063,19 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
         const savedFlushMode = this.flushMode;
         this.setFlushMode(FlushMode.TurnBased);
-        try {
-            this.trackOrderSequentiallyCalls(callback);
-            this.flush();
-            this.setFlushMode(savedFlushMode);
-        }
-        catch (error) {
-            this.closeFn(CreateProcessingError(error, "orderSequentially"));
-            throw error; // throw the original error for the consumer of the runtime
-        }
+        this.trackOrderSequentiallyCalls(callback);
+        this.flush();
+        this.setFlushMode(savedFlushMode);
     }
     trackOrderSequentiallyCalls(callback) {
         try {
             this._orderSequentiallyCalls++;
             callback();
         }
+        catch (error) {
+            this.closeFn(new GenericError("orderSequentiallyCallbackException", error));
+            throw error; // throw the original error for the consumer of the runtime
+        }
         finally {
             this._orderSequentiallyCalls--;
         }
@@ -1121,7 +1105,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         return this.dataStores._createFluidDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], id, isRoot).realize();
     }
     canSendOps() {
-        return this.connected && !this.deltaManager.readonly;
+        return this.connected && !this.deltaManager.readOnlyInfo.readonly;
     }
     getQuorum() {
         return this.context.quorum;
@@ -1194,7 +1178,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             // Wrap data store summaries in .channels subtree.
             wrapSummaryInChannelsTree(summarizeResult);
         }
-        this.addContainerBlobsToSummary(summarizeResult);
+        this.addContainerStateToSummary(summarizeResult);
         return summarizeResult.summary;
     }
     async getAbsoluteUrl(relativeUrl) {
@@ -1214,13 +1198,14 @@ export class ContainerRuntime extends TypedEventEmitter {
             wrapSummaryInChannelsTree(summarizeResult);
             pathPartsForChildren = [channelsTreeName];
         }
-        this.addContainerBlobsToSummary(summarizeResult);
+        this.addContainerStateToSummary(summarizeResult);
         return Object.assign(Object.assign({}, summarizeResult), { id: "", pathPartsForChildren });
     }
     /**
      * Returns a summary of the runtime at the current sequence number.
      */
     async summarize(options) {
+        this.verifyNotClosed();
         const { summaryLogger, fullTree = false, trackState = true, runGC = true, runSweep, fullGC } = options;
         if (runGC) {
             await this.collectGarbage({ logger: summaryLogger, runSweep, fullGC });
@@ -1229,6 +1214,15 @@ export class ContainerRuntime extends TypedEventEmitter {
         assert(summarizeResult.summary.type === SummaryType.Tree, 0x12f /* "Container Runtime's summarize should always return a tree" */);
         return summarizeResult;
     }
+    /**
+     * Implementation of IGarbageCollectionRuntime::updateStateBeforeGC.
+     * Before GC runs, called by the garbage collector to update any pending GC state. This is mainly used to notify
+     * the garbage collector of references detected since the last GC run. Most references are notified immediately
+     * but there can be some for which async operation is required (such as detecting new root data stores).
+     */
+    async updateStateBeforeGC() {
+        return this.dataStores.updateStateBeforeGC();
+    }
     /**
      * Implementation of IGarbageCollectionRuntime::getGCData.
      * Generates and returns the GC data for this container.
@@ -1339,10 +1333,9 @@ export class ContainerRuntime extends TypedEventEmitter {
             try {
                 summarizeResult = await this.summarize({
                     summaryLogger,
-                    // If the GC version changed since the last summary was submitted, we need to regenerate summary by
-                    // running full summary. This is used to handle scenarios where we upgrade the GC version because we
-                    // cannot trust the data from the previous GC version anymore.
-                    fullTree: fullTree || this.garbageCollector.hasGCVersionChanged,
+                    // If the GC state needs to be reset, we need to regenerate the summary and update the unreferenced
+                    // state of all the nodes.
+                    fullTree: fullTree || this.garbageCollector.summaryStateNeedsReset,
                     trackState: true,
                     runGC: this.garbageCollector.shouldRunGC,
                 });
@@ -1662,12 +1655,12 @@ export class ContainerRuntime extends TypedEventEmitter {
  * Wait for a specific sequence number. Promise should resolve when we reach that number,
  * or reject if closed.
  */
-const waitForSeq = async (deltaManager, targetSeq) => new Promise((accept, reject) => {
+const waitForSeq = async (deltaManager, targetSeq) => new Promise((resolve, reject) => {
     // TODO: remove cast to any when actual event is determined
     deltaManager.on("closed", reject);
     const handleOp = (message) => {
         if (message.sequenceNumber >= targetSeq) {
-            accept();
+            resolve();
             deltaManager.off("op", handleOp);
         }
     };