@fluidframework/container-runtime 2.13.0 → 2.21.0

package/lib/gc/garbageCollection.js

@@ -11,7 +11,9 @@ import { TombstoneResponseHeaderKey } from "../containerRuntime.js";
 import { ClientSessionExpiredError } from "../error.js";
 import { ContainerMessageType } from "../messageTypes.js";
 import { generateGCConfigs } from "./gcConfigs.js";
-import { GCNodeType, GarbageCollectionMessageType, UnreferencedState, } from "./gcDefinitions.js";
+import { 
+// eslint-disable-next-line import/no-deprecated
+GCNodeType, GarbageCollectionMessageType, UnreferencedState, } from "./gcDefinitions.js";
 import { cloneGCData, concatGarbageCollectionData, dataStoreNodePathOnly, getGCDataFromSnapshot, urlToGCNodePath, } from "./gcHelpers.js";
 import { runGarbageCollection } from "./gcReferenceGraphAlgorithm.js";
 import { GCSummaryStateTracker } from "./gcSummaryStateTracker.js";
@@ -46,7 +48,9 @@ export class GarbageCollector {
     get shouldRunGC() {
         return this.configs.gcAllowed;
     }
-    /** Returns the count of data stores whose GC state updated since the last summary. */
+    /**
+     * Returns the count of data stores whose GC state updated since the last summary.
+     */
     get updatedDSCountSinceLastSummary() {
         return this.summaryStateTracker.updatedDSCountSinceLastSummary;
     }
@@ -66,9 +70,13 @@ export class GarbageCollector {
         this.unreferencedNodesState = new UnreferencedStateTrackerMap();
         // The number of times GC has successfully completed on this instance of GarbageCollector.
         this.completedRuns = 0;
-        /** API for ensuring the correct auto-recovery mitigations */
+        /**
+         * API for ensuring the correct auto-recovery mitigations
+         */
+        // TODO: consider hoisting this to an outer scope as an optimization
+        // eslint-disable-next-line unicorn/consistent-function-scoping
         this.autoRecovery = (() => {
-            // This uses a hidden state machine for forcing fullGC as part of autorecovery,
+            // This uses a hidden state machine for forcing fullGC as part of auto-recovery,
             // to regenerate the GC data for each node.
             //
             // Once fullGC has been requested, we need to wait until GC has run and the summary has been acked before clearing the state.
@@ -203,7 +211,7 @@ export class GarbageCollector {
                 if (nodeData.unreferencedTimestampMs !== undefined) {
                     this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(nodeData.unreferencedTimestampMs, this.configs.inactiveTimeoutMs, currentReferenceTimestampMs, this.configs.tombstoneTimeoutMs, this.configs.sweepGracePeriodMs));
                 }
-                gcNodes[nodeId] = Array.from(nodeData.outboundRoutes);
+                gcNodes[nodeId] = [...nodeData.outboundRoutes];
             }
             this.gcDataFromLastRun = { gcNodes };
         });
@@ -219,7 +227,7 @@ export class GarbageCollector {
             // state will re-summarize to reset any GC specific state in their summaries (like unreferenced flag).
             const gcNodes = {};
             for (const [nodeId, nodeData] of Object.entries(baseSnapshotData.gcState.gcNodes)) {
-                gcNodes[nodeId] = Array.from(nodeData.outboundRoutes);
+                gcNodes[nodeId] = [...nodeData.outboundRoutes];
             }
             // Run GC on the nodes in the base summary to get the routes used in each node in the container.
             // This is an optimization for space (vs performance) wherein we don't need to store the used routes of
@@ -261,7 +269,7 @@ export class GarbageCollector {
         // Initialize the tombstone state from the snapshot. Also, notify the runtime of tombstone routes.
         if (baseSnapshotData.tombstones !== undefined) {
             // Create a copy since we are writing from a source we don't control
-            this.tombstones = Array.from(baseSnapshotData.tombstones);
+            this.tombstones = [...baseSnapshotData.tombstones];
             this.runtime.updateTombstonedRoutes(this.tombstones);
         }
         await this.initializeOrUpdateGCState();
@@ -280,16 +288,16 @@ export class GarbageCollector {
             eventName: "InitializeOrUpdateGCState",
         }, async (event) => {
             // If the GC state hasn't been initialized yet, initialize it and return.
-            if (!initialized) {
-                await this.initializeGCStateFromBaseSnapshotP;
-            }
-            else {
+            if (initialized) {
                 // If the GC state has been initialized, update the tracking of unreferenced nodes as per the current
                 // reference timestamp.
                 for (const [, nodeStateTracker] of this.unreferencedNodesState) {
                     nodeStateTracker.updateTracking(currentReferenceTimestampMs);
                 }
             }
+            else {
+                await this.initializeGCStateFromBaseSnapshotP;
+            }
             event.end({
                 details: { initialized, unrefNodeCount: this.unreferencedNodesState.size },
             });
@@ -363,10 +371,11 @@ export class GarbageCollector {
             return undefined;
         }
         return PerformanceEvent.timedExecAsync(logger, { eventName: "GarbageCollection" }, async (event) => {
-            /** Pre-GC steps */
+            // #region Pre-GC steps
             // Ensure that state has been initialized from the base snapshot data.
             await this.initializeGCStateFromBaseSnapshotP;
-            /** GC step */
+            // #endregion
+            // #region GC step
             const gcStats = await this.runGC(fullGC, currentReferenceTimestampMs, logger);
             event.end({
                 ...gcStats,
@@ -376,7 +385,8 @@ export class GarbageCollector {
                     tombstone: this.configs.throwOnTombstoneLoad,
                 },
             });
-            /** Post-GC steps */
+            // #endregion
+            // #region Post-GC steps
             // Log pending unreferenced events such as a node being used after inactive. This is done after GC runs and
             // updates its state so that we don't send false positives based on intermediate state. For example, we may get
             // reference to an unreferenced node from another unreferenced node which means the node wasn't revived.
@@ -386,6 +396,7 @@ export class GarbageCollector {
             this.autoRecovery.onCompletedGCRun();
             this.newReferencesSinceLastRun.clear();
             this.completedRuns++;
+            // #endregion
             return gcStats;
         }, { end: true, cancel: "error" });
     }
@@ -516,6 +527,7 @@ export class GarbageCollector {
             // local state when processing the op.
             const sweepReadyDSAndBlobs = nodesToDelete.filter((nodeId) => {
                 const nodeType = this.runtime.getNodeType(nodeId);
+                // eslint-disable-next-line import/no-deprecated
                 return nodeType === GCNodeType.DataStore || nodeType === GCNodeType.Blob;
             });
             const contents = {
@@ -579,7 +591,7 @@ export class GarbageCollector {
          */
         const gcDataSuperSet = concatGarbageCollectionData(previousGCData, currentGCData);
         const newOutboundRoutesSinceLastRun = [];
-        this.newReferencesSinceLastRun.forEach((outboundRoutes, sourceNodeId) => {
+        for (const [sourceNodeId, outboundRoutes] of this.newReferencesSinceLastRun) {
             if (gcDataSuperSet.gcNodes[sourceNodeId] === undefined) {
                 gcDataSuperSet.gcNodes[sourceNodeId] = outboundRoutes;
             }
@@ -587,7 +599,7 @@ export class GarbageCollector {
                 gcDataSuperSet.gcNodes[sourceNodeId].push(...outboundRoutes);
             }
             newOutboundRoutesSinceLastRun.push(...outboundRoutes);
-        });
+        }
         /**
          * Run GC on the above reference graph starting with root and all new outbound routes. This will generate a
          * list of all nodes that could have been referenced since the last run. If any of these nodes are unreferenced,
@@ -619,6 +631,7 @@ export class GarbageCollector {
         }
         return this.summaryStateTracker.summarize(trackState && !fullTree, gcState, this.deletedNodes, this.tombstones);
     }
+    // eslint-disable-next-line import/no-deprecated
     getMetadata() {
         return {
             /**
@@ -663,8 +676,9 @@ export class GarbageCollector {
                     this.autoRecovery.requestFullGCOnNextRun();
                     break;
                 }
-                default:
+                default: {
                     throw DataProcessingError.create(`Garbage collection message of unknown type ${gcMessageType}`, "processMessage");
+                }
             }
         }
     }
@@ -683,7 +697,7 @@ export class GarbageCollector {
         // The ids in the sweep-ready nodes do not contain DDS node ids. This is an optimization to reduce the size
         // of the GC op. Since GC applies to data store only, all its DDSes are deleted along with it. So, get the
         // DDS nodes ID from the unreferenced nodes state.
-        const allSweepReadyNodeIds = Array.from(sweepReadyNodeIds);
+        const allSweepReadyNodeIds = [...sweepReadyNodeIds];
         for (const [id] of this.unreferencedNodesState) {
             // Ignore data store nodes since they would already be in the list.
             const pathParts = id.split("/");
@@ -720,7 +734,7 @@ export class GarbageCollector {
         // trackedId will be either DataStore or Blob ID (not sub-DataStore ID, since some of those are unrecognized by GC)
         const trackedId = node.path;
         const isTombstoned = this.tombstones.includes(trackedId);
-        const fullPath = request !== undefined ? urlToGCNodePath(request.url) : trackedId;
+        const fullPath = request === undefined ? trackedId : urlToGCNodePath(request.url);
         // This will log if appropriate
         this.telemetryTracker.nodeUsed(trackedId, {
             id: fullPath,
@@ -746,6 +760,7 @@ export class GarbageCollector {
         const nodeType = this.runtime.getNodeType(fullPath);
         // Unless this is a Loaded event for a Blob or DataStore, we're done after telemetry tracking
         const loadedBlobOrDataStore = reason === "Loaded" &&
+            // eslint-disable-next-line import/no-deprecated
             (nodeType === GCNodeType.Blob || nodeType === GCNodeType.DataStore);
         if (!loadedBlobOrDataStore) {
             return;
@@ -850,7 +865,9 @@ export class GarbageCollector {
      * @param gcResult - The result of the current GC run.
      * @returns the stats of the mark phase run.
      */
+    // eslint-disable-next-line import/no-deprecated
     getMarkPhaseStats(gcResult) {
+        // eslint-disable-next-line import/no-deprecated
         const markPhaseStats = {
             nodeCount: 0,
             dataStoreCount: 0,
@@ -874,6 +891,7 @@ export class GarbageCollector {
             if (!isReferenced) {
                 markPhaseStats.unrefNodeCount++;
             }
+            // eslint-disable-next-line import/no-deprecated
             if (this.runtime.getNodeType(nodeId) === GCNodeType.DataStore) {
                 markPhaseStats.dataStoreCount++;
                 if (stateUpdated) {
@@ -883,6 +901,7 @@ export class GarbageCollector {
                     markPhaseStats.unrefDataStoreCount++;
                 }
             }
+            // eslint-disable-next-line import/no-deprecated
             if (this.runtime.getNodeType(nodeId) === GCNodeType.Blob) {
                 markPhaseStats.attachmentBlobCount++;
                 if (stateUpdated) {
@@ -909,9 +928,12 @@ export class GarbageCollector {
      * @param markPhaseStats - The stats of the mark phase run.
      * @returns the stats of the sweep phase run.
      */
-    getSweepPhaseStats(deletedNodes, sweepReadyNodes, markPhaseStats) {
+    getSweepPhaseStats(deletedNodes, sweepReadyNodes, 
+    // eslint-disable-next-line import/no-deprecated
+    markPhaseStats) {
         // Initialize the life time node counts to the mark phase node counts. If sweep is not enabled,
         // these will be the life time node count for this container.
+        // eslint-disable-next-line import/no-deprecated
         const sweepPhaseStats = {
             lifetimeNodeCount: markPhaseStats.nodeCount,
             lifetimeDataStoreCount: markPhaseStats.dataStoreCount,
@@ -922,24 +944,31 @@ export class GarbageCollector {
         };
         // The runtime can't reliably identify the type of deleted nodes. So, get the type here. This should
         // be good enough because the only types that participate in GC today are data stores, DDSes and blobs.
+        // eslint-disable-next-line import/no-deprecated, unicorn/consistent-function-scoping
         const getDeletedNodeType = (nodeId) => {
             const pathParts = nodeId.split("/");
             if (pathParts[1] === blobManagerBasePath) {
+                // eslint-disable-next-line import/no-deprecated
                 return GCNodeType.Blob;
             }
             if (pathParts.length === 2) {
+                // eslint-disable-next-line import/no-deprecated
                 return GCNodeType.DataStore;
             }
             if (pathParts.length === 3) {
+                // eslint-disable-next-line import/no-deprecated
                 return GCNodeType.SubDataStore;
             }
+            // eslint-disable-next-line import/no-deprecated
             return GCNodeType.Other;
         };
         for (const nodeId of deletedNodes) {
             sweepPhaseStats.deletedNodeCount++;
             const nodeType = getDeletedNodeType(nodeId);
+            // eslint-disable-next-line import/no-deprecated
             if (nodeType === GCNodeType.DataStore) {
                 sweepPhaseStats.deletedDataStoreCount++;
+                // eslint-disable-next-line import/no-deprecated
             }
             else if (nodeType === GCNodeType.Blob) {
                 sweepPhaseStats.deletedAttachmentBlobCount++;
@@ -959,8 +988,10 @@ export class GarbageCollector {
         for (const nodeId of sweepReadyNodes) {
             sweepPhaseStats.deletedNodeCount++;
             const nodeType = this.runtime.getNodeType(nodeId);
+            // eslint-disable-next-line import/no-deprecated
             if (nodeType === GCNodeType.DataStore) {
                 sweepPhaseStats.deletedDataStoreCount++;
+                // eslint-disable-next-line import/no-deprecated
             }
             else if (nodeType === GCNodeType.Blob) {
                 sweepPhaseStats.deletedAttachmentBlobCount++;