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

package/src/dataStoreContext.ts

@@ -82,14 +82,9 @@ import {
 function createAttributes(
     pkg: readonly string[],
     isRootDataStore: boolean,
-    disableIsolatedChannels: boolean,
 ): WriteFluidDataStoreAttributes {
     const stringifiedPkg = JSON.stringify(pkg);
-    return disableIsolatedChannels ? {
-        pkg: stringifiedPkg,
-        snapshotFormatVersion: "0.1",
-        isRootDataStore,
-    } : {
+    return {
         pkg: stringifiedPkg,
         summaryFormatVersion: 2,
         isRootDataStore,
@@ -98,9 +93,8 @@ function createAttributes(
 export function createAttributesBlob(
     pkg: readonly string[],
     isRootDataStore: boolean,
-    disableIsolatedChannels: boolean,
 ): ITreeEntry {
-    const attributes = createAttributes(pkg, isRootDataStore, disableIsolatedChannels);
+    const attributes = createAttributes(pkg, isRootDataStore);
     return new BlobTreeEntry(dataStoreAttributesBlobName, JSON.stringify(attributes));
 }
 
@@ -123,7 +117,6 @@ export interface IFluidDataStoreContextProps {
     readonly scope: FluidObject;
     readonly createSummarizerNodeFn: CreateChildSummarizerNodeFn;
     readonly writeGCDataAtRoot: boolean;
-    readonly disableIsolatedChannels: boolean;
     readonly pkg?: Readonly<string[]>;
 }
 
@@ -255,7 +248,6 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
     public readonly storage: IDocumentStorageService;
     public readonly scope: FluidObject;
     private readonly writeGCDataAtRoot: boolean;
-    protected readonly disableIsolatedChannels: boolean;
     protected pkg?: readonly string[];
 
     constructor(
@@ -271,7 +263,6 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
         this.storage = props.storage;
         this.scope = props.scope;
         this.writeGCDataAtRoot = props.writeGCDataAtRoot;
-        this.disableIsolatedChannels = props.disableIsolatedChannels;
         this.pkg = props.pkg;
 
         // URIs use slashes as delimiters. Handles use URIs.
@@ -387,8 +378,8 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
     /**
      * Notifies this object about changes in the connection state.
      * @param value - New connection state.
-     * @param clientId - ID of the client. It's old ID when in disconnected state and
-     * it's new client ID when we are connecting or connected.
+     * @param clientId - ID of the client. Its old ID when in disconnected state and
+     * its new client ID when we are connecting or connected.
      */
     public setConnectionState(connected: boolean, clientId?: string) {
         this.verifyNotClosed();
@@ -468,18 +459,15 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
 
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const summarizeResult = await this.channel!.summarize(fullTree, trackState, telemetryContext);
-        let pathPartsForChildren: string[] | undefined;
 
-        if (!this.disableIsolatedChannels) {
-            // Wrap dds summaries in .channels subtree.
-            wrapSummaryInChannelsTree(summarizeResult);
-            pathPartsForChildren = [channelsTreeName];
-        }
+        // Wrap dds summaries in .channels subtree.
+        wrapSummaryInChannelsTree(summarizeResult);
+        const pathPartsForChildren = [channelsTreeName];
 
         // Add data store's attributes to the summary.
         const { pkg } = await this.getInitialSnapshotDetails();
         const isRoot = await this.isRoot();
-        const attributes = createAttributes(pkg, isRoot, this.disableIsolatedChannels);
+        const attributes = createAttributes(pkg, isRoot);
         addBlobToSummary(summarizeResult, dataStoreAttributesBlobName, JSON.stringify(attributes));
 
         // Add GC data to the summary if it's not written at the root.
@@ -921,16 +909,13 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
 
         const summarizeResult = this.channel.getAttachSummary();
 
-        if (!this.disableIsolatedChannels) {
-            // Wrap dds summaries in .channels subtree.
-            wrapSummaryInChannelsTree(summarizeResult);
-        }
+        // Wrap dds summaries in .channels subtree.
+        wrapSummaryInChannelsTree(summarizeResult);
 
         // Add data store's attributes to the summary.
         const attributes = createAttributes(
             this.pkg,
             this.isInMemoryRoot(),
-            this.disableIsolatedChannels,
         );
         addBlobToSummary(summarizeResult, dataStoreAttributesBlobName, JSON.stringify(attributes));
 

package/src/dataStores.ts

@@ -143,7 +143,6 @@ export class DataStores implements IDisposable {
                         { type: CreateSummarizerNodeSource.FromSummary },
                     ),
                     writeGCDataAtRoot: this.writeGCDataAtRoot,
-                    disableIsolatedChannels: this.runtime.disableIsolatedChannels,
                 });
             } else {
                 if (typeof value !== "object") {
@@ -164,7 +163,6 @@ export class DataStores implements IDisposable {
                     snapshotTree,
                     isRootDataStore: undefined,
                     writeGCDataAtRoot: this.writeGCDataAtRoot,
-                    disableIsolatedChannels: this.runtime.disableIsolatedChannels,
                 });
             }
             this.contexts.addBoundOrRemoted(dataStoreContext);
@@ -245,13 +243,11 @@ export class DataStores implements IDisposable {
                         entries: [createAttributesBlob(
                             pkg,
                             true /* isRootDataStore */,
-                            this.runtime.disableIsolatedChannels,
                         )],
                     },
                 },
             ),
             writeGCDataAtRoot: this.writeGCDataAtRoot,
-            disableIsolatedChannels: this.runtime.disableIsolatedChannels,
             pkg,
         });
 
@@ -356,7 +352,6 @@ export class DataStores implements IDisposable {
             snapshotTree: undefined,
             isRootDataStore: isRoot,
             writeGCDataAtRoot: this.writeGCDataAtRoot,
-            disableIsolatedChannels: this.runtime.disableIsolatedChannels,
         });
         this.contexts.addUnbound(context);
         return context;
@@ -378,7 +373,6 @@ export class DataStores implements IDisposable {
             snapshotTree: undefined,
             isRootDataStore: false,
             writeGCDataAtRoot: this.writeGCDataAtRoot,
-            disableIsolatedChannels: this.runtime.disableIsolatedChannels,
             createProps: props,
         });
         this.contexts.addUnbound(context);

package/src/garbageCollection.ts

@@ -61,11 +61,11 @@ export const gcTreeKey = "gc";
 export const gcBlobPrefix = "__gc";
 
 // Feature gate key to turn GC on / off.
-const runGCKey = "Fluid.GarbageCollection.RunGC";
+export const runGCKey = "Fluid.GarbageCollection.RunGC";
 // Feature gate key to turn GC sweep on / off.
-// const runSweepKey = "Fluid.GarbageCollection.RunSweep";
+export const runSweepKey = "Fluid.GarbageCollection.RunSweep";
 // Feature gate key to turn GC test mode on / off.
-const gcTestModeKey = "Fluid.GarbageCollection.GCTestMode";
+export const 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.
@@ -80,7 +80,7 @@ const disableSweepLogKey = "Fluid.GarbageCollection.DisableSweepLog";
 // One day in milliseconds.
 export const oneDayMs = 1 * 24 * 60 * 60 * 1000;
 
-const defaultInactiveTimeoutMs = 7 * oneDayMs; // 7 days
+export const defaultInactiveTimeoutMs = 7 * oneDayMs; // 7 days
 export const defaultSessionExpiryDurationMs = 30 * oneDayMs; // 30 days
 
 /** The statistics of the system state after a garbage collection run. */
@@ -190,14 +190,14 @@ export interface IGarbageCollectorCreateParams {
 }
 
 /** The state of node that is unreferenced. */
-const UnreferencedState = {
+export const 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. */
     Inactive: "Inactive",
     /** The node is ready to be deleted by the sweep phase. */
     SweepReady: "SweepReady",
-};
+} as const;
 export type UnreferencedState = typeof UnreferencedState[keyof typeof UnreferencedState];
 
 /** The event that is logged when unreferenced node is used after a certain time. */
@@ -220,14 +220,16 @@ interface IUnreferencedEventProps {
  * Helper class that tracks the state of an unreferenced node such as the time it was unreferenced and if it can
  * be deleted by the sweep phase.
  */
-class UnreferencedStateTracker {
+export class UnreferencedStateTracker {
     private _state: UnreferencedState = UnreferencedState.Active;
     public get state(): UnreferencedState {
         return this._state;
     }
 
-    private inactiveTimer: Timer | undefined;
-    private sweepTimer: ReturnType<typeof setTimeout> | undefined;
+    /** Timer to indicate when an unreferenced object is considered Inactive */
+    private readonly inactiveTimer: TimerWithNoDefaultTimeout;
+    /** Timer to indicate when an unreferenced object is Sweep-Ready */
+    private readonly sweepTimer: TimerWithNoDefaultTimeout;
 
     constructor(
         public readonly unreferencedTimestampMs: number,
@@ -238,8 +240,29 @@ class UnreferencedStateTracker {
         /** The current reference timestamp; undefined if no ops have ever been processed which can happen in tests. */
         currentReferenceTimestampMs?: number,
     ) {
-        // 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.
+        if (this.sweepTimeoutMs !== undefined) {
+            assert(this.inactiveTimeoutMs <= this.sweepTimeoutMs,
+                0x3b0 /* inactive timeout must not be greater than the sweep timeout */);
+        }
+
+        this.sweepTimer = new TimerWithNoDefaultTimeout(
+            () => {
+                this._state = UnreferencedState.SweepReady;
+                assert(!this.inactiveTimer.hasTimer, 0x3b1 /* inactiveTimer still running after sweepTimer fired! */);
+            },
+        );
+
+        this.inactiveTimer = new TimerWithNoDefaultTimeout(() => {
+            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) {
+                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);
         }
@@ -260,42 +283,21 @@ class UnreferencedStateTracker {
         // Also, start a timer for the sweep timeout.
         if (unreferencedDurationMs >= this.inactiveTimeoutMs) {
             this._state = UnreferencedState.Inactive;
-            this.clearTimers();
+            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 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);
     }
 
     private clearTimers() {
-        this.inactiveTimer?.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. */
@@ -412,8 +414,8 @@ export class GarbageCollector implements IGarbageCollector {
     private readonly baseGCDetailsP: Promise<Map<string, IGarbageCollectionDetailsBase>>;
     // Map of node ids to their unreferenced state tracker.
     private readonly unreferencedNodesState: Map<string, UnreferencedStateTracker> = new Map();
-    // The timeout responsible for closing the container when the session has expired
-    private sessionExpiryTimer?: ReturnType<typeof setTimeout>;
+    // The Timer responsible for closing the container when the session has expired
+    private sessionExpiryTimer: Timer | undefined;
 
     // Keeps track of unreferenced events that are logged for a node. This is used to limit the log generation to one
     // per event per node.
@@ -484,7 +486,7 @@ export class GarbageCollector implements IGarbageCollector {
             // 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(runSessionExpiryKey) && this.gcEnabled) {
                 this.sessionExpiryTimeoutMs = this.gcOptions.sessionExpiryTimeoutMs ?? defaultSessionExpiryDurationMs;
             }
@@ -497,11 +499,11 @@ export class GarbageCollector implements IGarbageCollector {
                 this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.SessionExpiryMs");
             const timeoutMs = overrideSessionExpiryTimeoutMs ?? this.sessionExpiryTimeoutMs;
 
-            setLongTimeout(
+            this.sessionExpiryTimer = new Timer(
                 timeoutMs,
                 () => { this.runtime.closeFn(new ClientSessionExpiredError(`Client session expired.`, timeoutMs)); },
-                (timer) => { this.sessionExpiryTimer = timer; },
             );
+            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).
@@ -557,7 +559,7 @@ export class GarbageCollector implements IGarbageCollector {
 
         // 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 UsageError("inactive timeout should not be greated than the sweep timeout");
+            throw new 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.
@@ -688,7 +690,7 @@ export class GarbageCollector implements IGarbageCollector {
             const usedRoutes = runGarbageCollection(gcNodes, ["/"]).referencedNodeIds;
 
             const baseGCDetailsMap = 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) {
@@ -986,10 +988,8 @@ export class GarbageCollector implements IGarbageCollector {
     }
 
     public dispose(): void {
-        if (this.sessionExpiryTimer !== undefined) {
-            clearTimeout(this.sessionExpiryTimer);
-            this.sessionExpiryTimer = undefined;
-        }
+        this.sessionExpiryTimer?.clear();
+        this.sessionExpiryTimer = undefined;
     }
 
     /**
@@ -1416,25 +1416,20 @@ function generateSortedGCState(gcState: IGarbageCollectionState): IGarbageCollec
     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: number,
-    timeoutFn: () => void,
-    setTimerFn: (timer: ReturnType<typeof setTimeout>) => void,
-) {
-    // The setTimeout max is 24.8 days before looping occurs.
-    const maxTimeout = 2147483647;
-    let timer: ReturnType<typeof setTimeout>;
-    if (timeoutMs > maxTimeout) {
-        const newTimeoutMs = timeoutMs - maxTimeout;
-        timer = setTimeout(() => setLongTimeout(newTimeoutMs, timeoutFn, setTimerFn), maxTimeout);
-    } else {
-        timer = setTimeout(() => timeoutFn(), timeoutMs);
+/** A wrapper around common-utils Timer that requires the timeout when calling start/restart */
+class TimerWithNoDefaultTimeout extends Timer {
+    constructor(
+        private readonly callback: () => void,
+    ) {
+        // The default timeout/handlers will never be used since start/restart pass overrides below
+        super(0, () => { throw new Error("DefaultHandler should not be used"); });
+    }
+
+    start(timeoutMs: number) {
+        super.start(timeoutMs, this.callback);
+    }
+
+    restart(timeoutMs: number): void {
+        super.restart(timeoutMs, this.callback);
     }
-    setTimerFn(timer);
 }

package/src/index.ts

@@ -14,12 +14,10 @@ export {
     ISummaryConfigurationDisableSummarizer,
     ISummaryConfigurationDisableHeuristics,
     IContainerRuntimeOptions,
-    IPendingRuntimeState,
     IRootSummaryTreeWithStats,
     isRuntimeMessage,
     RuntimeMessage,
     unpackRuntimeMessage,
-    ScheduleManager,
     agentSchedulerId,
     ContainerRuntime,
     RuntimeHeaders,
@@ -41,6 +39,7 @@ export {
     IPendingMessage,
     IPendingState,
 } from "./pendingStateManager";
+export { ScheduleManager } from "./scheduleManager";
 export { Summarizer } from "./summarizer";
 export {
     EnqueueSummarizeResult,

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.0.0-internal.1.0.0.84253";
+export const pkgVersion = "2.0.0-internal.1.1.0";

package/src/pendingStateManager.ts

@@ -14,6 +14,7 @@ import { FlushMode } from "@fluidframework/runtime-definitions";
 import { wrapError } from "@fluidframework/telemetry-utils";
 import Deque from "double-ended-queue";
 import { ContainerMessageType } from "./containerRuntime";
+import { pkgVersion } from "./packageVersion";
 
 /**
  * This represents a message that has been submitted and is added to the pending queue when `submit` is called on the
@@ -368,8 +369,23 @@ export class PendingStateManager implements IDisposable {
         } else {
             // Get the batch metadata from the last message in the batch.
             const batchEndMetadata = message.metadata?.batch;
-            assert(batchBeginMetadata === true, 0x16f /* "Did not receive batch begin metadata" */);
-            assert(batchEndMetadata === false, 0x170 /* "Did not receive batch end metadata" */);
+            if (batchBeginMetadata !== true || batchEndMetadata !== false) {
+                this.stateHandler.close(DataProcessingError.create(
+                    "Pending batch inconsistency", // Formerly known as asserts 0x16f and 0x170
+                    "processPendingLocalMessage",
+                    message,
+                    {
+                        runtimeVersion: pkgVersion,
+                        batchClientId: this.pendingBatchBeginMessage.clientId,
+                        clientId: this.stateHandler.clientId(),
+                        hasBatchStart: batchBeginMetadata === true,
+                        hasBatchEnd: batchEndMetadata === false,
+                        messageType: message.type,
+                        batchStartSequenceNumber: this.pendingBatchBeginMessage.clientSequenceNumber,
+                        pendingMessagesCount: this.pendingMessagesCount,
+                        nextPendingState: nextPendingState.type,
+                    }));
+            }
         }
 
         // Clear the pending batch state now that we have processed the entire batch.