@fluidframework/container-runtime 2.0.0-internal.8.0.0 → 2.0.0-internal.8.0.2

package/dist/gc/garbageCollection.d.ts

@@ -60,30 +60,26 @@ export declare class GarbageCollector implements IGarbageCollector {
     private readonly getNodePackagePath;
     /** Returns the timestamp of the last summary generated for this container. */
     private readonly getLastSummaryTimestampMs;
-    /** Returns true if connection is active, i.e. it's "write" connection and the runtime is connected. */
-    private readonly activeConnection;
     private readonly submitMessage;
     get summaryStateNeedsReset(): boolean;
     /** Returns the count of data stores whose GC state updated since the last summary. */
     get updatedDSCountSinceLastSummary(): number;
     protected constructor(createParams: IGarbageCollectorCreateParams);
     /**
-     * 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.
+     * Called during container initialization. Initializes the tombstone and deleted nodes state from the base snapshot.
+     * Also, initializes the GC state including unreferenced nodes tracking if a current reference timestamp exists.
+     * Note that if there is any GC state in the base snapshot, then there will definitely be a reference timestamp
+     * to work with - The GC state would have been generated using a timestamp which is part of the snapshot.
      */
     initializeBaseState(): Promise<void>;
     /**
-     * Update state from the given snapshot data. This is done during load and during refreshing state from a snapshot.
-     * All current tracking is reset and updated from the data in the snapshot.
-     * @param snapshotData - The snapshot data to update state from. If this is undefined, all GC state and tracking
-     * is reset.
-     * @param currentReferenceTimestampMs - The current reference timestamp for marking unreferenced nodes' unreferenced
-     * timestamp.
+     * Initialize the GC state if not already initialized. If GC state is already initialized, update the unreferenced
+     * state tracking as per the current reference timestamp.
      */
-    private updateStateFromSnapshotData;
+    private initializeOrUpdateGCState;
     /**
      * Called when the connection state of the runtime changes, i.e., it connects or disconnects. GC subscribes to this
-     * to initialize the base state for non-summarizer clients so that they can track inactive / sweep-ready nodes.
+     * to initialize or update the unreference state tracking.
      * @param connected - Whether the runtime connected / disconnected.
      * @param clientId - The clientId of this runtime.
      */

package/dist/gc/garbageCollection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"garbageCollection.d.ts","sourceRoot":"","sources":["../../src/gc/garbageCollection.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAC3D,OAAO,EAGN,6BAA6B,EAC7B,gBAAgB,EAChB,iBAAiB,EACjB,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EAIN,mBAAmB,EAGnB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAEN,iBAAiB,EAEjB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAwB,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAClF,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAEnD,OAAO,EAEN,iBAAiB,EACjB,6BAA6B,EAG7B,QAAQ,EAER,WAAW,EAMX,MAAM,iBAAiB,CAAC;AAazB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,gBAAiB,YAAW,iBAAiB;WAC3C,MAAM,CAAC,YAAY,EAAE,6BAA6B,GAAG,iBAAiB;IAIpF,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAoB;IAEvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;IAEnD,IAAW,WAAW,IAAI,OAAO,CAEhC;IAGD,OAAO,CAAC,iBAAiB,CAAqC;IAG9D,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAoC;IAE9E,OAAO,CAAC,UAAU,CAAgB;IAElC,OAAO,CAAC,YAAY,CAA0B;IAG9C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAsD;IAExF,OAAO,CAAC,QAAQ,CAAC,kCAAkC,CAAgB;IAEnE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAyC;IAExE,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAoD;IAE3F,OAAO,CAAC,kBAAkB,CAAoB;IAG9C,OAAO,CAAC,aAAa,CAAK;IAE1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA4B;IACpD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAU;IAE7C,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAwB;IAC5D,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAqB;IAEtD,iFAAiF;IACjF,IAAW,2BAA2B,IAAI,OAAO,CAEhD;IACD,uEAAuE;IACvE,IAAW,oBAAoB,IAAI,OAAO,CAEzC;IACD,kEAAkE;IAClE,IAAW,qBAAqB,IAAI,OAAO,CAE1C;IAED,8DAA8D;IAC9D,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAES;IAC5C,8EAA8E;IAC9E,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAA2B;IACrE,uGAAuG;IACvG,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAgB;IAEjD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA+C;IAE7E,IAAW,sBAAsB,IAAI,OAAO,CAE3C;IAED,sFAAsF;IACtF,IAAW,8BAA8B,IAAI,MAAM,CAElD;IAED,SAAS,aAAa,YAAY,EAAE,6BAA6B;IAsKjE;;;OAGG;IACU,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC;IA2BjD;;;;;;;OAOG;IACH,OAAO,CAAC,2BAA2B;IA6EnC;;;;;OAKG;IACI,kBAAkB,CAAC,SAAS,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAmBlF;;;OAGG;IACU,gBAAgB,IAAI,OAAO,CAAC,6BAA6B,CAAC;IAIvE;;;OAGG;IACU,cAAc,CAC1B,OAAO,EAAE;QACR,0CAA0C;QAC1C,MAAM,CAAC,EAAE,mBAAmB,CAAC;QAC7B,sDAAsD;QACtD,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,oCAAoC;QACpC,MAAM,CAAC,EAAE,OAAO,CAAC;KACjB,EACD,gBAAgB,CAAC,EAAE,iBAAiB,GAClC,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IAwEhC;;;;;;;;;;;;OAYG;YACW,KAAK;IA2CnB;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,YAAY;IAqDpB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,aAAa;IAgErB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,gCAAgC;IAqExC;;;;OAIG;IACI,SAAS,CACf,QAAQ,EAAE,OAAO,EACjB,UAAU,EAAE,OAAO,EACnB,gBAAgB,CAAC,EAAE,iBAAiB,GAClC,gBAAgB,GAAG,SAAS;IAuBxB,WAAW,IAAI,WAAW;IAcjC;;OAEG;IACU,oBAAoB,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/E;;;;OAIG;IACI,cAAc,CAAC,OAAO,EAAE,yBAAyB,EAAE,KAAK,EAAE,OAAO;IAyBxE;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IAqC7B;;;;;;;;;OASG;IACI,WAAW,CACjB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,QAAQ,GAAG,SAAS,EAC5B,WAAW,CAAC,EAAE,MAAM,EACpB,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,EAC/B,OAAO,CAAC,EAAE,QAAQ,EAClB,UAAU,CAAC,EAAE,iBAAiB;IAyD/B;;;;;;OAMG;IACI,sBAAsB,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAqBtE;;;OAGG;IACI,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIxC,OAAO,IAAI,IAAI;IAKtB;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IA0DzB;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;CAkD1B"}
+{"version":3,"file":"garbageCollection.d.ts","sourceRoot":"","sources":["../../src/gc/garbageCollection.ts"],"names":[],"mappings":"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"}

package/dist/gc/garbageCollection.js

@@ -9,6 +9,7 @@ const core_utils_1 = require("@fluidframework/core-utils");
 const runtime_definitions_1 = require("@fluidframework/runtime-definitions");
 const runtime_utils_1 = require("@fluidframework/runtime-utils");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
+const blobManager_1 = require("../blobManager");
 const containerRuntime_1 = require("../containerRuntime");
 const error_1 = require("../error");
 const messageTypes_1 = require("../messageTypes");
@@ -83,7 +84,6 @@ class GarbageCollector {
         this.isSummarizerClient = createParams.isSummarizerClient;
         this.getNodePackagePath = createParams.getNodePackagePath;
         this.getLastSummaryTimestampMs = createParams.getLastSummaryTimestampMs;
-        this.activeConnection = createParams.activeConnection;
         this.submitMessage = createParams.submitMessage;
         const baseSnapshot = createParams.baseSnapshot;
         const readAndParseBlob = createParams.readAndParseBlob;
@@ -144,28 +144,14 @@ class GarbageCollector {
             }
         });
         /**
-         * Set up the initializer which initializes the GC state from the data in base snapshot. This is done when
-         * connected in write mode or when GC runs the first time. It sets up all unreferenced nodes from the base
-         * GC state and updates their inactive or sweep-ready state.
+         * Set up the initializer which initializes the GC state from the data in base snapshot. It sets up GC data
+         * from the base GC state and starts tracking the state of unreferenced nodes.
+         *
+         * Must only be called if there is a current reference timestamp.
          */
         this.initializeGCStateFromBaseSnapshotP = new core_utils_1.LazyPromise(async () => {
-            /**
-             * If there is no current reference timestamp, skip initialization. We need the current timestamp to track
-             * how long objects have been unreferenced and if they can be deleted.
-             *
-             * Note that the only scenario where there is no reference timestamp is when no ops have ever been processed
-             * for this container and it is in read mode. In this scenario, there is no point in running GC anyway
-             * because references in the container do not change without any ops, i.e., there is nothing to collect.
-             */
             const currentReferenceTimestampMs = this.runtime.getCurrentReferenceTimestampMs();
-            if (currentReferenceTimestampMs === undefined) {
-                // Log an event so we can evaluate how often we run into this scenario.
-                this.mc.logger.sendErrorEvent({
-                    eventName: "GarbageCollectorInitializedWithoutTimestamp",
-                    gcConfigs: JSON.stringify(this.configs),
-                });
-                return;
-            }
+            (0, core_utils_1.assert)(currentReferenceTimestampMs !== undefined, "Trying to initialize GC state without current timestamp");
             /**
              * The base snapshot data will not be present if the container is loaded from:
              * 1. The first summary created by the detached container.
@@ -173,11 +159,20 @@ class GarbageCollector {
              * 3. A summary that was generated before GC even existed.
              */
             const baseSnapshotData = await this.baseSnapshotDataP;
-            if (baseSnapshotData === undefined) {
+            this.summaryStateTracker.initializeBaseState(baseSnapshotData);
+            if (baseSnapshotData?.gcState === undefined) {
                 return;
             }
-            this.updateStateFromSnapshotData(baseSnapshotData, currentReferenceTimestampMs);
-            this.summaryStateTracker.initializeBaseState(baseSnapshotData);
+            // Update unreferenced state tracking as per the GC state in the snapshot data and update gcDataFromLastRun
+            // to the GC data from the snapshot data.
+            const gcNodes = {};
+            for (const [nodeId, nodeData] of Object.entries(baseSnapshotData.gcState.gcNodes)) {
+                if (nodeData.unreferencedTimestampMs !== undefined) {
+                    this.unreferencedNodesState.set(nodeId, new gcUnreferencedStateTracker_1.UnreferencedStateTracker(nodeData.unreferencedTimestampMs, this.configs.inactiveTimeoutMs, currentReferenceTimestampMs, this.configs.sweepTimeoutMs, this.configs.sweepGracePeriodMs));
+                }
+                gcNodes[nodeId] = Array.from(nodeData.outboundRoutes);
+            }
+            this.gcDataFromLastRun = { gcNodes };
         });
         // Get the GC details from the GC state in the base summary. This is returned in getBaseGCDetails which is
         // used to initialize the GC state of all the nodes in the container.
@@ -206,8 +201,10 @@ class GarbageCollector {
         });
     }
     /**
-     * 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.
+     * Called during container initialization. Initializes the tombstone and deleted nodes state from the base snapshot.
+     * Also, initializes the GC state including unreferenced nodes tracking if a current reference timestamp exists.
+     * Note that if there is any GC state in the base snapshot, then there will definitely be a reference timestamp
+     * to work with - The GC state would have been generated using a timestamp which is part of the snapshot.
      */
     async initializeBaseState() {
         const baseSnapshotData = await this.baseSnapshotDataP;
@@ -232,98 +229,51 @@ class GarbageCollector {
             this.tombstones = Array.from(baseSnapshotData.tombstones);
             this.runtime.updateTombstonedRoutes(this.tombstones);
         }
+        await this.initializeOrUpdateGCState();
     }
     /**
-     * Update state from the given snapshot data. This is done during load and during refreshing state from a snapshot.
-     * All current tracking is reset and updated from the data in the snapshot.
-     * @param snapshotData - The snapshot data to update state from. If this is undefined, all GC state and tracking
-     * is reset.
-     * @param currentReferenceTimestampMs - The current reference timestamp for marking unreferenced nodes' unreferenced
-     * timestamp.
+     * Initialize the GC state if not already initialized. If GC state is already initialized, update the unreferenced
+     * state tracking as per the current reference timestamp.
      */
-    updateStateFromSnapshotData(snapshotData, currentReferenceTimestampMs) {
-        /**
-         * Note: "newReferencesSinceLastRun" is not reset here. This is done because there may be references since the
-         * snapshot that we are updating state from. For example, this client may have processed ops till seq#1000 and
-         * its refreshing state from a summary that happened at seq#900. In this case, there may be references between
-         * seq#901 and seq#1000 that we don't want to reset.
-         * Unfortunately, there is no way to track the seq# of ops that add references, so we choose to not reset any
-         * references here. This should be fine because, in the worst case, we may end up updating the unreferenced
-         * timestamp of a node which will delay its deletion. Although not ideal, this will only happen in rare
-         * scenarios, so it should be okay.
-         */
-        // Clear all existing unreferenced state tracking.
-        for (const [, nodeStateTracker] of this.unreferencedNodesState) {
-            nodeStateTracker.stopTracking();
-        }
-        this.unreferencedNodesState.clear();
-        // 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.configs.shouldRunSweep) {
-            const snapshotDeletedNodes = snapshotData?.deletedNodes
-                ? new Set(snapshotData.deletedNodes)
-                : 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.configs.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?.tombstones ? Array.from(snapshotData.tombstones) : [];
-            this.runtime.updateTombstonedRoutes(this.tombstones);
+    async initializeOrUpdateGCState() {
+        const currentReferenceTimestampMs = this.runtime.getCurrentReferenceTimestampMs();
+        if (currentReferenceTimestampMs === undefined) {
+            return;
         }
-        // If there is no snapshot data, it means this snapshot was generated with GC disabled. Unset all GC state.
-        if (snapshotData?.gcState === undefined) {
-            this.gcDataFromLastRun = undefined;
+        // If the GC state hasn't been initialized yet, initialize it and return.
+        if (this.gcDataFromLastRun === undefined) {
+            await this.initializeGCStateFromBaseSnapshotP;
             return;
         }
-        // Update unreferenced state tracking as per the GC state in the snapshot data and update gcDataFromLastRun
-        // to the GC data from the snapshot data.
-        const gcNodes = {};
-        for (const [nodeId, nodeData] of Object.entries(snapshotData.gcState.gcNodes)) {
-            if (nodeData.unreferencedTimestampMs !== undefined) {
-                this.unreferencedNodesState.set(nodeId, new gcUnreferencedStateTracker_1.UnreferencedStateTracker(nodeData.unreferencedTimestampMs, this.configs.inactiveTimeoutMs, currentReferenceTimestampMs, this.configs.sweepTimeoutMs, this.configs.sweepGracePeriodMs));
-            }
-            gcNodes[nodeId] = Array.from(nodeData.outboundRoutes);
+        // 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);
         }
-        this.gcDataFromLastRun = { gcNodes };
     }
     /**
      * Called when the connection state of the runtime changes, i.e., it connects or disconnects. GC subscribes to this
-     * to initialize the base state for non-summarizer clients so that they can track inactive / sweep-ready nodes.
+     * to initialize or update the unreference state tracking.
      * @param connected - Whether the runtime connected / disconnected.
      * @param clientId - The clientId of this runtime.
      */
     setConnectionState(connected, clientId) {
         /**
-         * For all clients, initialize the base state when the container becomes active, i.e., it transitions
-         * to "write" mode. This will ensure that the container's own join op is processed and there is a recent
-         * reference timestamp that will be used to update the state of unreferenced nodes. Also, all trailing ops which
-         * could affect the GC state will have been processed.
+         * When the client connects (or reconnects), attempt to initialize or update the GC state. This will keep
+         * the unreferenced state tracking updated as per the reference timestamp at the time of connection.
          *
-         * If GC is up-to-date for the client and the summarizing client, there will be an doubling of both
-         * InactiveObject_Loaded and SweepReady_Loaded errors, as there will be one from the sending client and one from
-         * the receiving summarizer client.
-         *
-         * Ideally, this initialization should only be done for summarizer client. However, we are currently rolling out
-         * sweep in phases and we want to track when inactive and sweep-ready objects are used in any client.
+         * During GC initialization and during connections in read mode, it is possible that either no ops are
+         * processed or only trailing ops are processed. This means that the GC state is not initialized or initialized
+         * with an older reference timestamp. So, doing this on every connection will keep the unreferenced state
+         * tracking up-to-date.
          */
-        if (this.activeConnection() && this.configs.shouldRunGC) {
-            this.initializeGCStateFromBaseSnapshotP.catch((error) => { });
+        if (connected && this.configs.shouldRunGC) {
+            this.initializeOrUpdateGCState().catch((error) => {
+                this.mc.logger.sendErrorEvent({
+                    eventName: "GCInitializationOrUpdateFailed",
+                    gcConfigs: JSON.stringify(this.configs),
+                }, error);
+            });
         }
     }
     /**
@@ -380,8 +330,11 @@ class GarbageCollector {
             const gcStats = await this.runGC(fullGC, currentReferenceTimestampMs, logger);
             event.end({
                 ...gcStats,
-                timestamp: currentReferenceTimestampMs,
-                sweep: this.configs.shouldRunSweep,
+                details: {
+                    timestamp: currentReferenceTimestampMs,
+                    sweep: this.configs.shouldRunSweep,
+                    tombstone: this.configs.throwOnTombstoneLoad,
+                },
             });
             /** Post-GC steps */
             // Log pending unreferenced events such as a node being used after inactive. This is done after GC runs and
@@ -874,9 +827,24 @@ class GarbageCollector {
             deletedDataStoreCount: 0,
             deletedAttachmentBlobCount: 0,
         };
+        // 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.
+        const getDeletedNodeType = (nodeId) => {
+            const pathParts = nodeId.split("/");
+            if (pathParts[1] === blobManager_1.BlobManager.basePath) {
+                return gcDefinitions_1.GCNodeType.Blob;
+            }
+            if (pathParts.length === 2) {
+                return gcDefinitions_1.GCNodeType.DataStore;
+            }
+            if (pathParts.length === 3) {
+                return gcDefinitions_1.GCNodeType.SubDataStore;
+            }
+            return gcDefinitions_1.GCNodeType.Other;
+        };
         for (const nodeId of deletedNodes) {
             sweepPhaseStats.deletedNodeCount++;
-            const nodeType = this.runtime.getNodeType(nodeId);
+            const nodeType = getDeletedNodeType(nodeId);
             if (nodeType === gcDefinitions_1.GCNodeType.DataStore) {
                 sweepPhaseStats.deletedDataStoreCount++;
             }