@fluidframework/container-runtime 2.0.0-internal.2.3.1 → 2.0.0-internal.3.0.0

package/dist/garbageCollection.js

@@ -145,7 +145,10 @@ class GarbageCollector {
         // Keeps a list of references (edges in the GC graph) between GC runs. Each entry has a node id and a list of
         // outbound routes from that node.
         this.newReferencesSinceLastRun = new Map();
+        // A list of nodes that have been tombstoned.
         this.tombstones = [];
+        // A list of nodes that have been deleted during sweep phase.
+        this.deletedNodes = new Set();
         // Map of node ids to their unreferenced state tracker.
         this.unreferencedNodesState = new Map();
         // Keeps track of unreferenced events that are logged for a node. This is used to limit the log generation to one
@@ -214,8 +217,7 @@ class GarbageCollector {
             // flag in GC options to false.
             this.gcEnabled = this.gcOptions.gcAllowed !== false;
             // The sweep phase has to be explicitly enabled by setting the sweepAllowed flag in GC options to true.
-            // ...unless we're using the TestOverride
-            this.sweepEnabled = this.gcOptions.sweepAllowed === true || testOverrideSweepTimeoutMs !== undefined;
+            this.sweepEnabled = this.gcOptions.sweepAllowed === true;
             // Set the Session Expiry only if the flag is enabled and GC is enabled.
             if (this.mc.config.getBoolean(garbageCollectionConstants_1.runSessionExpiryKey) && this.gcEnabled) {
                 this.sessionExpiryTimeoutMs = (_c = this.gcOptions.sessionExpiryTimeoutMs) !== null && _c !== void 0 ? _c : garbageCollectionConstants_1.defaultSessionExpiryDurationMs;
@@ -271,8 +273,9 @@ class GarbageCollector {
         }
         // Whether we are running in test mode. In this mode, unreferenced nodes are immediately deleted.
         this.testMode = (_h = this.mc.config.getBoolean(garbageCollectionConstants_1.gcTestModeKey)) !== null && _h !== void 0 ? _h : this.gcOptions.runGCInTestMode === true;
-        // Whether we are running in tombstone mode. This is true by default unless disabled via feature flags.
-        this.tombstoneMode = this.mc.config.getBoolean(garbageCollectionConstants_1.disableTombstoneKey) !== true;
+        // Whether we are running in tombstone mode. This is enabled by default if sweep won't run. It can be disabled
+        // via feature flags.
+        this.tombstoneMode = !this.shouldRunSweep && this.mc.config.getBoolean(garbageCollectionConstants_1.disableTombstoneKey) !== true;
         // If GC ran in the container that generated the base snapshot, it will have a GC tree.
         this.wasGCRunInLatestSummary = (baseSnapshot === null || baseSnapshot === void 0 ? void 0 : baseSnapshot.trees[runtime_definitions_1.gcTreeKey]) !== undefined;
         // Get the GC data from the base snapshot. Use LazyPromise because we only want to do this once since it
@@ -322,7 +325,9 @@ class GarbageCollector {
                 }
                 // If there is only one node (root node just added above), either GC is disabled or we are loading from
                 // the first summary generated by detached container. In both cases, GC was not run - return undefined.
-                return Object.keys(gcState.gcNodes).length === 1 ? undefined : { gcState, tombstones: undefined };
+                return Object.keys(gcState.gcNodes).length === 1
+                    ? undefined
+                    : { gcState, tombstones: undefined, deletedNodes: undefined };
             }
             catch (error) {
                 const dpe = container_utils_1.DataProcessingError.wrapIfUnrecognized(error, "FailedToInitializeGC");
@@ -435,24 +440,31 @@ class GarbageCollector {
         return Object.assign({ gcEnabled: this.gcEnabled, sweepEnabled: this.sweepEnabled, runGC: this.shouldRunGC, runSweep: this.shouldRunSweep, testMode: this.testMode, tombstoneMode: this.tombstoneMode, sessionExpiry: this.sessionExpiryTimeoutMs, sweepTimeout: this.sweepTimeoutMs, inactiveTimeout: this.inactiveTimeoutMs, trackGCState: this.trackGCState }, this.gcOptions);
     }
     /**
-     * Called during container initialization. Initialize the tombstone state so that object are marked as tombstones
-     * before they are loaded or used. This is important to get accurate information of whether tombstoned object are
-     * in use or not.
+     * Called during container initialization. Initialize from the tombstone state in the base snapshot. This is done
+     * during initialization so that deleted or tombstoned objects are marked as such before they are loaded or used.
      */
     async initializeBaseState() {
         const baseSnapshotData = await this.baseSnapshotDataP;
         /**
-         * The base snapshot data or tombstone state will not be present if the container is loaded from:
+         * The base snapshot data will not be present if the container is loaded from:
          * 1. The first summary created by the detached container.
          * 2. A summary that was generated with GC disabled.
          * 3. A summary that was generated before GC even existed.
-         * 4. A summary that was generated with tombstone feature disabled.
          */
-        if (!this.tombstoneMode || (baseSnapshotData === null || baseSnapshotData === void 0 ? void 0 : baseSnapshotData.tombstones) === undefined) {
+        if (baseSnapshotData === undefined) {
             return;
         }
-        this.tombstones = Array.from(baseSnapshotData.tombstones);
-        this.runtime.updateTombstonedRoutes(this.tombstones);
+        // Initialize the deleted nodes from the snapshot. This is done irrespective of whether sweep is enabled or not
+        // to identify deleted nodes' usage.
+        if (baseSnapshotData.deletedNodes !== undefined) {
+            this.deletedNodes = new Set(baseSnapshotData.deletedNodes);
+        }
+        // If running in tombstone mode, initialize the tombstone state from the snapshot. Also, notify the runtime of
+        // tombstone routes.
+        if (this.tombstoneMode && baseSnapshotData.tombstones !== undefined) {
+            this.tombstones = Array.from(baseSnapshotData.tombstones);
+            this.runtime.updateTombstonedRoutes(this.tombstones);
+        }
     }
     /**
      * Update state from the given snapshot data. This is done during load and during refreshing state from a snapshot.
@@ -479,9 +491,30 @@ class GarbageCollector {
         }
         ;
         this.unreferencedNodesState.clear();
-        // If tombstone mode is enabled, update tombstone information and also update all tombstoned nodes in the
-        // container as per the state in the snapshot data.
-        if (this.tombstoneMode) {
+        // If running sweep, the tombstone state represents the list of nodes that have been deleted during sweep.
+        // If running in tombstone mode, the tombstone state represents the list of nodes that have been marked as
+        // tombstones.
+        // If this call is because we are refreshing from a snapshot due to an ack, it is likely that the GC state
+        // in the snapshot is newer than this client's. And so, the deleted / tombstone nodes need to be updated.
+        if (this.shouldRunSweep) {
+            const snapshotDeletedNodes = (snapshotData === null || snapshotData === void 0 ? void 0 : snapshotData.tombstones) ? new Set(snapshotData.tombstones) : undefined;
+            // If the snapshot contains deleted nodes that are not yet deleted by this client, ask the runtime to
+            // delete them.
+            if (snapshotDeletedNodes !== undefined) {
+                const newDeletedNodes = [];
+                for (const nodeId of snapshotDeletedNodes) {
+                    if (!this.deletedNodes.has(nodeId)) {
+                        newDeletedNodes.push(nodeId);
+                    }
+                }
+                if (newDeletedNodes.length > 0) {
+                    // Call container runtime to delete these nodes and add deleted nodes to this.deletedNodes.
+                }
+            }
+        }
+        else if (this.tombstoneMode) {
+            // The snapshot may contain more or fewer tombstone nodes than this client. Update tombstone state and
+            // notify the runtime to update its state as well.
             this.tombstones = (snapshotData === null || snapshotData === void 0 ? void 0 : snapshotData.tombstones) ? Array.from(snapshotData.tombstones) : [];
             this.runtime.updateTombstonedRoutes(this.tombstones);
         }
@@ -506,6 +539,7 @@ class GarbageCollector {
             this.latestSummaryData = {
                 serializedGCState: JSON.stringify(generateSortedGCState(snapshotData.gcState)),
                 serializedTombstones: JSON.stringify(snapshotData.tombstones),
+                serializedDeletedNodes: JSON.stringify(snapshotData.deletedNodes),
             };
         }
     }
@@ -625,17 +659,25 @@ class GarbageCollector {
             };
         }
         const serializedGCState = JSON.stringify(generateSortedGCState(gcState));
+        // Serialize and write deleted nodes, if any. This is done irrespective of whether sweep is enabled or not so
+        // to identify deleted nodes' usage.
+        const serializedDeletedNodes = this.deletedNodes.size > 0
+            ? JSON.stringify(Array.from(this.deletedNodes).sort())
+            : undefined;
+        // If running in tombstone mode, serialize and write tombstones, if any.
         const serializedTombstones = this.tombstoneMode
             ? (this.tombstones.length > 0 ? JSON.stringify(this.tombstones.sort()) : undefined)
             : undefined;
         /**
-         * Incremental summary of GC data - If any of the GC state or tombstone state hasn't changed since the last
-         * summary, send summary handles for them. Otherwise, send the data in summary blobs.
+         * Incremental summary of GC data - If none of GC state, deleted nodes or tombstones changed since last summary,
+         * write summary handle instead of summary tree for GC.
+         * Otherwise, write the GC summary tree. In the tree, for each of these that changed, write a summary blob and
+         * for each of these that did not change, write a summary handle.
          */
         if (this.trackGCState) {
-            this.pendingSummaryData = { serializedGCState, serializedTombstones };
+            this.pendingSummaryData = { serializedGCState, serializedTombstones, serializedDeletedNodes };
             if (trackState && !fullTree && this.latestSummaryData !== undefined) {
-                // If neither GC state or tombstone state changed, send a summary handle for the entire GC data.
+                // If nothing changed since last summary, send a summary handle for the entire GC data.
                 if (this.latestSummaryData.serializedGCState === serializedGCState
                     && this.latestSummaryData.serializedTombstones === serializedTombstones) {
                     const stats = (0, runtime_utils_1.mergeStats)();
@@ -649,24 +691,25 @@ class GarbageCollector {
                         stats,
                     };
                 }
-                // If either or both of GC state or tombstone state changed, build a GC summary tree.
-                return this.buildGCSummaryTree(serializedGCState, serializedTombstones, true /* trackState */);
+                // If some state changed, build a GC summary tree.
+                return this.buildGCSummaryTree(serializedGCState, serializedTombstones, serializedDeletedNodes, true /* trackState */);
             }
         }
         // If not tracking GC state, build a GC summary tree without any summary handles.
-        return this.buildGCSummaryTree(serializedGCState, serializedTombstones, false /* trackState */);
+        return this.buildGCSummaryTree(serializedGCState, serializedTombstones, serializedDeletedNodes, false /* trackState */);
     }
     /**
-     * Builds the GC summary tree which contains GC state and tombstone state.
-     * If trackState is false, both GC state and tombstone state are written as summary blobs.
-     * If trackState is true, summary blob is written for GC state or tombstone state if they changed.
+     * Builds the GC summary tree which contains GC state, deleted nodes and tombstones.
+     * If trackState is false, all of GC state, deleted nodes and tombstones are written as summary blobs.
+     * If trackState is true, only states that changed are written. Rest are written as handles.
      * @param serializedGCState - The GC state serialized as string.
-     * @param serializedTombstones - THe tombstone state serialized as string.
+     * @param serializedTombstones - The tombstone state serialized as string.
+     * @param serializedDeletedNodes - Deleted nodes serialized as string.
      * @param trackState - Whether we are tracking GC state across summaries.
      * @returns the GC summary tree.
      */
-    buildGCSummaryTree(serializedGCState, serializedTombstones, trackState) {
-        var _a, _b;
+    buildGCSummaryTree(serializedGCState, serializedTombstones, serializedDeletedNodes, trackState) {
+        var _a, _b, _c;
         const gcStateBlobKey = `${runtime_definitions_1.gcBlobPrefix}_root`;
         const builder = new runtime_utils_1.SummaryTreeBuilder();
         // If the GC state hasn't changed, write a summary handle, else write a summary blob for it.
@@ -676,16 +719,26 @@ class GarbageCollector {
         else {
             builder.addBlob(gcStateBlobKey, serializedGCState);
         }
-        // If there is no tombstone data, return only the GC state.
-        if (serializedTombstones === undefined) {
+        // If tombstones exist, write a summary handle if it hasn't changed. If it has changed, write a
+        // summary blob.
+        if (serializedTombstones !== undefined) {
+            if (((_b = this.latestSummaryData) === null || _b === void 0 ? void 0 : _b.serializedTombstones) === serializedTombstones && trackState) {
+                builder.addHandle(runtime_definitions_1.gcTombstoneBlobKey, protocol_definitions_1.SummaryType.Blob, `/${runtime_definitions_1.gcTreeKey}/${runtime_definitions_1.gcTombstoneBlobKey}`);
+            }
+            else {
+                builder.addBlob(runtime_definitions_1.gcTombstoneBlobKey, serializedTombstones);
+            }
+        }
+        // If there are no deleted nodes, return the summary tree.
+        if (serializedDeletedNodes === undefined) {
             return builder.getSummaryTree();
         }
-        // If the tombstone state hasn't changed, write a summary handle, else write a summary blob for it.
-        if (((_b = this.latestSummaryData) === null || _b === void 0 ? void 0 : _b.serializedTombstones) === serializedTombstones && trackState) {
-            builder.addHandle(runtime_definitions_1.gcTombstoneBlobKey, protocol_definitions_1.SummaryType.Blob, `/${runtime_definitions_1.gcTreeKey}/${runtime_definitions_1.gcTombstoneBlobKey}`);
+        // If the deleted nodes hasn't changed, write a summary handle, else write a summary blob for it.
+        if (((_c = this.latestSummaryData) === null || _c === void 0 ? void 0 : _c.serializedDeletedNodes) === serializedDeletedNodes && trackState) {
+            builder.addHandle(runtime_definitions_1.gcDeletedBlobKey, protocol_definitions_1.SummaryType.Blob, `/${runtime_definitions_1.gcTreeKey}/${runtime_definitions_1.gcDeletedBlobKey}`);
         }
         else {
-            builder.addBlob(runtime_definitions_1.gcTombstoneBlobKey, serializedTombstones);
+            builder.addBlob(runtime_definitions_1.gcDeletedBlobKey, serializedDeletedNodes);
         }
         return builder.getSummaryTree();
     }
@@ -810,6 +863,13 @@ class GarbageCollector {
             }, undefined /* packagePath */);
         }
     }
+    /**
+     * Returns whether a node with the given path has been deleted or not. This can be used by the runtime to identify
+     * cases where objects are used after they are deleted and throw / log errors accordingly.
+     */
+    isNodeDeleted(nodePath) {
+        return this.deletedNodes.has(nodePath);
+    }
     dispose() {
         var _a;
         (_a = this.sessionExpiryTimer) === null || _a === void 0 ? void 0 : _a.clear();
@@ -1121,7 +1181,7 @@ class GarbageCollector {
                     this.mc.logger.sendErrorEvent(event);
                 }
             }
-            // If SweepReady Usage Detection is enabed, the handler may close the interactive container.
+            // If SweepReady Usage Detection is enabled, the handler may close the interactive container.
             // Once Sweep is fully implemented, this will be removed since the objects will be gone
             // and errors will arise elsewhere in the runtime
             if (state === exports.UnreferencedState.SweepReady) {