@fluidframework/container-runtime 2.0.0-internal.1.0.0.84253 → 2.0.0-internal.1.1.0

package/dist/garbageCollection.js

@@ -15,7 +15,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GarbageCollector = exports.GCNodeType = exports.defaultSessionExpiryDurationMs = exports.oneDayMs = exports.trackGCStateKey = exports.disableSessionExpiryKey = exports.runSessionExpiryKey = exports.gcBlobPrefix = exports.gcTreeKey = void 0;
+exports.GarbageCollector = exports.UnreferencedStateTracker = exports.UnreferencedState = exports.GCNodeType = exports.defaultSessionExpiryDurationMs = exports.defaultInactiveTimeoutMs = exports.oneDayMs = exports.trackGCStateKey = exports.disableSessionExpiryKey = exports.runSessionExpiryKey = exports.gcTestModeKey = exports.runSweepKey = exports.runGCKey = exports.gcBlobPrefix = exports.gcTreeKey = void 0;
 const common_utils_1 = require("@fluidframework/common-utils");
 const container_utils_1 = require("@fluidframework/container-utils");
 const garbage_collector_1 = require("@fluidframework/garbage-collector");
@@ -33,11 +33,11 @@ exports.gcTreeKey = "gc";
 // They prefix for GC blobs in the GC tree in summary.
 exports.gcBlobPrefix = "__gc";
 // Feature gate key to turn GC on / off.
-const runGCKey = "Fluid.GarbageCollection.RunGC";
+exports.runGCKey = "Fluid.GarbageCollection.RunGC";
 // Feature gate key to turn GC sweep on / off.
-// const runSweepKey = "Fluid.GarbageCollection.RunSweep";
+exports.runSweepKey = "Fluid.GarbageCollection.RunSweep";
 // Feature gate key to turn GC test mode on / off.
-const gcTestModeKey = "Fluid.GarbageCollection.GCTestMode";
+exports.gcTestModeKey = "Fluid.GarbageCollection.GCTestMode";
 // Feature gate key to write GC data at the root of the summary tree.
 const writeAtRootKey = "Fluid.GarbageCollection.WriteDataAtRoot";
 // Feature gate key to expire a session after a set period of time.
@@ -50,7 +50,7 @@ exports.trackGCStateKey = "Fluid.GarbageCollection.TrackGCState";
 const disableSweepLogKey = "Fluid.GarbageCollection.DisableSweepLog";
 // One day in milliseconds.
 exports.oneDayMs = 1 * 24 * 60 * 60 * 1000;
-const defaultInactiveTimeoutMs = 7 * exports.oneDayMs; // 7 days
+exports.defaultInactiveTimeoutMs = 7 * exports.oneDayMs; // 7 days
 exports.defaultSessionExpiryDurationMs = 30 * exports.oneDayMs; // 30 days
 /** The types of GC nodes in the GC reference graph. */
 exports.GCNodeType = {
@@ -64,7 +64,7 @@ exports.GCNodeType = {
     Other: "Other",
 };
 /** The state of node that is unreferenced. */
-const UnreferencedState = {
+exports.UnreferencedState = {
     /** The node is active, i.e., it can become referenced again. */
     Active: "Active",
     /** The node is inactive, i.e., it should not become referenced. */
@@ -87,9 +87,23 @@ class UnreferencedStateTracker {
         this.unreferencedTimestampMs = unreferencedTimestampMs;
         this.inactiveTimeoutMs = inactiveTimeoutMs;
         this.sweepTimeoutMs = sweepTimeoutMs;
-        this._state = UnreferencedState.Active;
-        // If there is no current reference timestamp, don't track the node's unreferenced state. This will happen
-        // later when updateTracking is called with a reference timestamp.
+        this._state = exports.UnreferencedState.Active;
+        if (this.sweepTimeoutMs !== undefined) {
+            (0, common_utils_1.assert)(this.inactiveTimeoutMs <= this.sweepTimeoutMs, 0x3b0 /* inactive timeout must not be greater than the sweep timeout */);
+        }
+        this.sweepTimer = new TimerWithNoDefaultTimeout(() => {
+            this._state = exports.UnreferencedState.SweepReady;
+            (0, common_utils_1.assert)(!this.inactiveTimer.hasTimer, 0x3b1 /* inactiveTimer still running after sweepTimer fired! */);
+        });
+        this.inactiveTimer = new TimerWithNoDefaultTimeout(() => {
+            this._state = exports.UnreferencedState.Inactive;
+            // After the node becomes inactive, start the sweep timer after which the node will be ready for sweep.
+            if (this.sweepTimeoutMs !== undefined) {
+                this.sweepTimer.restart(this.sweepTimeoutMs - this.inactiveTimeoutMs);
+            }
+        });
+        // If there is no current reference timestamp, can't track the node's unreferenced state at this time.
+        // This will happen later when updateTracking is called with a reference timestamp.
         if (currentReferenceTimestampMs !== undefined) {
             this.updateTracking(currentReferenceTimestampMs);
         }
@@ -102,47 +116,34 @@ class UnreferencedStateTracker {
         const unreferencedDurationMs = currentReferenceTimestampMs - this.unreferencedTimestampMs;
         // If the node has been unreferenced for sweep timeout amount of time, update the state to SweepReady.
         if (this.sweepTimeoutMs !== undefined && unreferencedDurationMs >= this.sweepTimeoutMs) {
-            this._state = UnreferencedState.SweepReady;
+            this._state = exports.UnreferencedState.SweepReady;
             this.clearTimers();
             return;
         }
         // If the node has been unreferenced for inactive timeoutMs amount of time, update the state to inactive.
         // Also, start a timer for the sweep timeout.
         if (unreferencedDurationMs >= this.inactiveTimeoutMs) {
-            this._state = UnreferencedState.Inactive;
-            this.clearTimers();
+            this._state = exports.UnreferencedState.Inactive;
+            this.inactiveTimer.clear();
             if (this.sweepTimeoutMs !== undefined) {
-                setLongTimeout(this.sweepTimeoutMs - unreferencedDurationMs, () => { this._state = UnreferencedState.SweepReady; }, (timer) => { this.sweepTimer = timer; });
+                this.sweepTimer.restart(this.sweepTimeoutMs - unreferencedDurationMs);
             }
             return;
         }
-        // The node is still active. Start the inactive timer for the remaining duration.
-        const remainingDurationMs = this.inactiveTimeoutMs - unreferencedDurationMs;
-        if (this.inactiveTimer === undefined) {
-            const inactiveTimeoutHandler = () => {
-                this._state = UnreferencedState.Inactive;
-                // After the node becomes inactive, start the sweep timer after which the node will be ready for sweep.
-                if (this.sweepTimeoutMs !== undefined) {
-                    setLongTimeout(this.sweepTimeoutMs - this.inactiveTimeoutMs, () => { this._state = UnreferencedState.SweepReady; }, (timer) => { this.sweepTimer = timer; });
-                }
-            };
-            this.inactiveTimer = new common_utils_1.Timer(remainingDurationMs, () => inactiveTimeoutHandler());
-        }
-        this.inactiveTimer.restart(remainingDurationMs);
+        // The node is still active. Ensure the inactive timer is running with the proper remaining duration.
+        this.inactiveTimer.restart(this.inactiveTimeoutMs - unreferencedDurationMs);
     }
     clearTimers() {
-        var _a;
-        (_a = this.inactiveTimer) === null || _a === void 0 ? void 0 : _a.clear();
-        if (this.sweepTimer !== undefined) {
-            clearTimeout(this.sweepTimer);
-        }
+        this.inactiveTimer.clear();
+        this.sweepTimer.clear();
     }
     /** Stop tracking this node. Reset the unreferenced timers and state, if any. */
     stopTracking() {
         this.clearTimers();
-        this._state = UnreferencedState.Active;
+        this._state = exports.UnreferencedState.Active;
     }
 }
+exports.UnreferencedStateTracker = UnreferencedStateTracker;
 /**
  * The garbage collector for the container runtime. It consolidates the garbage collection functionality and maintains
  * its state across summaries.
@@ -228,7 +229,7 @@ class GarbageCollector {
             this.gcEnabled = this.gcOptions.gcAllowed !== false;
             // The sweep phase has to be explicitly enabled by setting the sweepAllowed flag in GC options to true.
             this.sweepEnabled = this.gcOptions.sweepAllowed === true;
-            // Set the Session Expiry only if the flag is enabled or the test option is set.
+            // Set the Session Expiry only if the flag is enabled and GC is enabled.
             if (this.mc.config.getBoolean(exports.runSessionExpiryKey) && this.gcEnabled) {
                 this.sessionExpiryTimeoutMs = (_b = this.gcOptions.sessionExpiryTimeoutMs) !== null && _b !== void 0 ? _b : exports.defaultSessionExpiryDurationMs;
             }
@@ -238,7 +239,8 @@ class GarbageCollector {
             // If Test Override config is set, override Session Expiry timeout.
             const overrideSessionExpiryTimeoutMs = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.SessionExpiryMs");
             const timeoutMs = overrideSessionExpiryTimeoutMs !== null && overrideSessionExpiryTimeoutMs !== void 0 ? overrideSessionExpiryTimeoutMs : this.sessionExpiryTimeoutMs;
-            setLongTimeout(timeoutMs, () => { this.runtime.closeFn(new container_utils_1.ClientSessionExpiredError(`Client session expired.`, timeoutMs)); }, (timer) => { this.sessionExpiryTimer = timer; });
+            this.sessionExpiryTimer = new common_utils_1.Timer(timeoutMs, () => { this.runtime.closeFn(new container_utils_1.ClientSessionExpiredError(`Client session expired.`, timeoutMs)); });
+            this.sessionExpiryTimer.start();
             // TEMPORARY: Hardcode a default of 2 days which is the value used in the ODSP driver.
             // This unblocks the Sweep Log (see logSweepEvents function).
             // This will be removed before sweep is fully implemented.
@@ -262,7 +264,7 @@ class GarbageCollector {
          * 2. GC should not be disabled via disableGC GC option.
          * These conditions can be overridden via runGCKey feature flag.
          */
-        this.shouldRunGC = (_d = this.mc.config.getBoolean(runGCKey)) !== null && _d !== void 0 ? _d : (
+        this.shouldRunGC = (_d = this.mc.config.getBoolean(exports.runGCKey)) !== null && _d !== void 0 ? _d : (
         // GC must be enabled for the document.
         this.gcEnabled
             // GC must not be disabled via GC options.
@@ -280,13 +282,13 @@ class GarbageCollector {
         // && (this.mc.config.getBoolean(runSweepKey) ?? this.sweepEnabled);
         this.trackGCState = this.mc.config.getBoolean(exports.trackGCStateKey) === true;
         // Override inactive timeout if test config or gc options to override it is set.
-        this.inactiveTimeoutMs = (_f = (_e = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.InactiveTimeoutMs")) !== null && _e !== void 0 ? _e : this.gcOptions.inactiveTimeoutMs) !== null && _f !== void 0 ? _f : defaultInactiveTimeoutMs;
+        this.inactiveTimeoutMs = (_f = (_e = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.InactiveTimeoutMs")) !== null && _e !== void 0 ? _e : this.gcOptions.inactiveTimeoutMs) !== null && _f !== void 0 ? _f : exports.defaultInactiveTimeoutMs;
         // Inactive timeout must be greater than sweep timeout since a node goes from active -> inactive -> sweep ready.
         if (this.sweepTimeoutMs !== undefined && this.inactiveTimeoutMs > this.sweepTimeoutMs) {
-            throw new container_utils_1.UsageError("inactive timeout should not be greated than the sweep timeout");
+            throw new container_utils_1.UsageError("inactive timeout should not be greater than the sweep timeout");
         }
         // Whether we are running in test mode. In this mode, unreferenced nodes are immediately deleted.
-        this.testMode = (_g = this.mc.config.getBoolean(gcTestModeKey)) !== null && _g !== void 0 ? _g : this.gcOptions.runGCInTestMode === true;
+        this.testMode = (_g = this.mc.config.getBoolean(exports.gcTestModeKey)) !== null && _g !== void 0 ? _g : this.gcOptions.runGCInTestMode === true;
         // GC state is written into root of the summary tree by default. Can be overridden via feature flag for now.
         this._writeDataAtRoot = (_h = this.mc.config.getBoolean(writeAtRootKey)) !== null && _h !== void 0 ? _h : true;
         if (this._writeDataAtRoot) {
@@ -385,7 +387,7 @@ class GarbageCollector {
             // each node in the summary.
             const usedRoutes = (0, garbage_collector_1.runGarbageCollection)(gcNodes, ["/"]).referencedNodeIds;
             const baseGCDetailsMap = (0, garbage_collector_1.unpackChildNodesGCDetails)({ gcData: { gcNodes }, usedRoutes });
-            // Currently, the nodes may write the GC data. So, we need to update it's base GC details with the
+            // Currently, the nodes may write the GC data. So, we need to update its base GC details with the
             // unreferenced timestamp. Once we start writing the GC data here, we won't need to do this anymore.
             for (const [nodeId, nodeData] of Object.entries(baseState.gcNodes)) {
                 if (nodeData.unreferencedTimestampMs !== undefined) {
@@ -596,7 +598,7 @@ class GarbageCollector {
             return;
         }
         const nodeStateTracker = this.unreferencedNodesState.get(nodePath);
-        if (nodeStateTracker && nodeStateTracker.state !== UnreferencedState.Active) {
+        if (nodeStateTracker && nodeStateTracker.state !== exports.UnreferencedState.Active) {
             this.inactiveNodeUsed(reason, nodePath, nodeStateTracker, undefined /* fromNodeId */, packagePath, timestampMs, requestHeaders);
         }
     }
@@ -616,15 +618,14 @@ class GarbageCollector {
         outboundRoutes.push(toNodePath);
         this.newReferencesSinceLastRun.set(fromNodePath, outboundRoutes);
         const nodeStateTracker = this.unreferencedNodesState.get(toNodePath);
-        if (nodeStateTracker && nodeStateTracker.state !== UnreferencedState.Active) {
+        if (nodeStateTracker && nodeStateTracker.state !== exports.UnreferencedState.Active) {
             this.inactiveNodeUsed("Revived", toNodePath, nodeStateTracker, fromNodePath);
         }
     }
     dispose() {
-        if (this.sessionExpiryTimer !== undefined) {
-            clearTimeout(this.sessionExpiryTimer);
-            this.sessionExpiryTimer = undefined;
-        }
+        var _a;
+        (_a = this.sessionExpiryTimer) === null || _a === void 0 ? void 0 : _a.clear();
+        this.sessionExpiryTimer = undefined;
     }
     /**
      * Updates the state of the system as per the current GC run. It does the following:
@@ -848,7 +849,7 @@ class GarbageCollector {
             return;
         }
         this.unreferencedNodesState.forEach((nodeStateTracker, nodeId) => {
-            if (nodeStateTracker.state !== UnreferencedState.SweepReady) {
+            if (nodeStateTracker.state !== exports.UnreferencedState.SweepReady) {
                 return;
             }
             const nodeType = this.runtime.getNodeType(nodeId);
@@ -879,7 +880,7 @@ class GarbageCollector {
         // If there is no reference timestamp to work with, no ops have been processed after creation. If so, skip
         // logging as nothing interesting would have happened worth logging.
         // If the node is active, skip logging.
-        if (currentReferenceTimestampMs === undefined || nodeStateTracker.state === UnreferencedState.Active) {
+        if (currentReferenceTimestampMs === undefined || nodeStateTracker.state === exports.UnreferencedState.Active) {
             return;
         }
         // For non-summarizer clients, only log "Loaded" type events since these objects may not be loaded in the
@@ -904,7 +905,7 @@ class GarbageCollector {
             type: nodeType,
             unrefTime: nodeStateTracker.unreferencedTimestampMs,
             age: currentReferenceTimestampMs - nodeStateTracker.unreferencedTimestampMs,
-            timeout: nodeStateTracker.state === UnreferencedState.Inactive
+            timeout: nodeStateTracker.state === exports.UnreferencedState.Inactive
                 ? this.inactiveTimeoutMs
                 : this.sweepTimeoutMs,
             completedGCRuns: this.completedRuns,
@@ -933,7 +934,7 @@ class GarbageCollector {
              * revived and a Revived event will be logged for it.
              */
             const nodeStateTracker = this.unreferencedNodesState.get(eventProps.id);
-            const active = nodeStateTracker === undefined || nodeStateTracker.state === UnreferencedState.Active;
+            const active = nodeStateTracker === undefined || nodeStateTracker.state === exports.UnreferencedState.Active;
             if ((usageType === "Revived") === active) {
                 const pkg = await this.getNodePackagePath(eventProps.id);
                 const fromPkg = eventProps.fromId ? await this.getNodePackagePath(eventProps.fromId) : undefined;
@@ -976,23 +977,18 @@ function generateSortedGCState(gcState) {
     }
     return sortedGCState;
 }
-/**
- * setLongTimeout is used for timeouts longer than setTimeout's ~24.8 day max
- * @param timeoutMs - the total time the timeout needs to last in ms
- * @param timeoutFn - the function to execute when the timer ends
- * @param setTimerFn - the function used to update your timer variable
- */
-function setLongTimeout(timeoutMs, timeoutFn, setTimerFn) {
-    // The setTimeout max is 24.8 days before looping occurs.
-    const maxTimeout = 2147483647;
-    let timer;
-    if (timeoutMs > maxTimeout) {
-        const newTimeoutMs = timeoutMs - maxTimeout;
-        timer = setTimeout(() => setLongTimeout(newTimeoutMs, timeoutFn, setTimerFn), maxTimeout);
+/** A wrapper around common-utils Timer that requires the timeout when calling start/restart */
+class TimerWithNoDefaultTimeout extends common_utils_1.Timer {
+    constructor(callback) {
+        // The default timeout/handlers will never be used since start/restart pass overrides below
+        super(0, () => { throw new Error("DefaultHandler should not be used"); });
+        this.callback = callback;
+    }
+    start(timeoutMs) {
+        super.start(timeoutMs, this.callback);
     }
-    else {
-        timer = setTimeout(() => timeoutFn(), timeoutMs);
+    restart(timeoutMs) {
+        super.restart(timeoutMs, this.callback);
     }
-    setTimerFn(timer);
 }
 //# sourceMappingURL=garbageCollection.js.map