@fluidframework/container-runtime 2.0.0-internal.6.1.1 → 2.0.0-internal.6.2.0

package/src/dataStore.ts

@@ -3,10 +3,9 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLoggerExt, TelemetryDataTag } from "@fluidframework/telemetry-utils";
+import { ITelemetryLoggerExt, TelemetryDataTag, UsageError } from "@fluidframework/telemetry-utils";
 import { assert, unreachableCase } from "@fluidframework/common-utils";
 import { AttachState } from "@fluidframework/container-definitions";
-import { UsageError } from "@fluidframework/container-utils";
 import { FluidObject, IFluidHandle, IRequest, IResponse } from "@fluidframework/core-interfaces";
 import {
 	AliasResult,

package/src/dataStoreContext.ts

@@ -57,6 +57,9 @@ import {
 import { addBlobToSummary, convertSummaryTreeToITree } from "@fluidframework/runtime-utils";
 import {
 	createChildMonitoringContext,
+	DataCorruptionError,
+	DataProcessingError,
+	extractSafePropertiesFromMessage,
 	generateStack,
 	ITelemetryLoggerExt,
 	LoggingError,
@@ -64,12 +67,6 @@ import {
 	tagCodeArtifacts,
 	ThresholdCounter,
 } from "@fluidframework/telemetry-utils";
-import {
-	DataCorruptionError,
-	DataProcessingError,
-	extractSafePropertiesFromMessage,
-} from "@fluidframework/container-utils";
-
 import {
 	dataStoreAttributesBlobName,
 	hasIsolatedChannels,

package/src/dataStoreContexts.ts

@@ -3,10 +3,9 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
 import { assert, Deferred } from "@fluidframework/common-utils";
 import { Lazy } from "@fluidframework/core-utils";
-import { IDisposable } from "@fluidframework/core-interfaces";
+import { IDisposable, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { createChildLogger, ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import { FluidDataStoreContext, LocalFluidDataStoreContext } from "./dataStoreContext";
 

package/src/dataStoreRegistry.ts

@@ -2,7 +2,7 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { UsageError } from "@fluidframework/container-utils";
+import { UsageError } from "@fluidframework/telemetry-utils";
 import {
 	FluidDataStoreRegistryEntry,
 	IFluidDataStoreRegistry,

package/src/dataStores.ts

@@ -3,10 +3,6 @@
  * Licensed under the MIT License.
  */
 
-import {
-	DataCorruptionError,
-	extractSafePropertiesFromMessage,
-} from "@fluidframework/container-utils";
 import {
 	ITelemetryBaseLogger,
 	IDisposable,
@@ -42,9 +38,11 @@ import {
 	unpackChildNodesUsedRoutes,
 } from "@fluidframework/runtime-utils";
 import {
+	createChildMonitoringContext,
+	DataCorruptionError,
+	extractSafePropertiesFromMessage,
 	LoggingError,
 	MonitoringContext,
-	createChildMonitoringContext,
 	tagCodeArtifacts,
 } from "@fluidframework/telemetry-utils";
 import { AttachState } from "@fluidframework/container-definitions";

package/src/error.ts

@@ -0,0 +1,18 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ContainerErrorTypes } from "@fluidframework/container-definitions";
+import { IFluidErrorBase, LoggingError } from "@fluidframework/telemetry-utils";
+
+/**
+ * Error indicating that a client's session has reached its time limit and is closed.
+ */
+export class ClientSessionExpiredError extends LoggingError implements IFluidErrorBase {
+	readonly errorType = ContainerErrorTypes.clientSessionExpiredError;
+
+	constructor(message: string, readonly expiryMs: number) {
+		super(message, { timeoutMs: expiryMs });
+	}
+}

package/src/gc/garbageCollection.ts

@@ -5,8 +5,7 @@
 
 import { Timer } from "@fluidframework/common-utils";
 import { LazyPromise } from "@fluidframework/core-utils";
-import { ClientSessionExpiredError, DataProcessingError } from "@fluidframework/container-utils";
-import { IRequestHeader } from "@fluidframework/core-interfaces";
+import { IRequest, IRequestHeader } from "@fluidframework/core-interfaces";
 import {
 	gcTreeKey,
 	IGarbageCollectionData,
@@ -14,16 +13,26 @@ import {
 	ISummarizeResult,
 	ITelemetryContext,
 } from "@fluidframework/runtime-definitions";
-import { ReadAndParseBlob } from "@fluidframework/runtime-utils";
+import {
+	ReadAndParseBlob,
+	createResponseError,
+	responseToException,
+} from "@fluidframework/runtime-utils";
 import {
 	createChildLogger,
 	createChildMonitoringContext,
+	DataProcessingError,
 	ITelemetryLoggerExt,
 	MonitoringContext,
 	PerformanceEvent,
 } from "@fluidframework/telemetry-utils";
 
-import { RuntimeHeaders } from "../containerRuntime";
+import {
+	AllowInactiveRequestHeaderKey,
+	InactiveResponseHeaderKey,
+	RuntimeHeaders,
+} from "../containerRuntime";
+import { ClientSessionExpiredError } from "../error";
 import { RefreshSummaryResult } from "../summary";
 import { generateGCConfigs } from "./gcConfigs";
 import {
@@ -876,7 +885,7 @@ export class GarbageCollector implements IGarbageCollector {
 
 	/**
 	 * Called when a node with the given id is updated. If the node is inactive, log an error.
-	 * @param nodePath - The id of the node that changed.
+	 * @param nodePath - The path of the node that changed.
 	 * @param reason - Whether the node was loaded or changed.
 	 * @param timestampMs - The timestamp when the node changed.
 	 * @param packagePath - The package path of the node. This may not be available if the node hasn't been loaded yet.
@@ -893,6 +902,7 @@ export class GarbageCollector implements IGarbageCollector {
 			return;
 		}
 
+		// This will log if appropriate
 		this.telemetryTracker.nodeUsed({
 			id: nodePath,
 			usageType: reason,
@@ -904,6 +914,29 @@ export class GarbageCollector implements IGarbageCollector {
 			lastSummaryTime: this.getLastSummaryTimestampMs(),
 			viaHandle: requestHeaders?.[RuntimeHeaders.viaHandle],
 		});
+
+		// Unless this is a Loaded event, we're done after telemetry tracking
+		if (reason !== "Loaded") {
+			return;
+		}
+
+		// We may throw when loading an Inactive object, depending on these preconditions
+		const shouldThrowOnInactiveLoad =
+			!this.isSummarizerClient &&
+			this.configs.throwOnInactiveLoad === true &&
+			requestHeaders?.[AllowInactiveRequestHeaderKey] !== true;
+		const state = this.unreferencedNodesState.get(nodePath)?.state;
+
+		if (shouldThrowOnInactiveLoad && state === "Inactive") {
+			const request: IRequest = { url: nodePath };
+			const error = responseToException(
+				createResponseError(404, "Object is inactive", request, {
+					[InactiveResponseHeaderKey]: true,
+				}),
+				request,
+			);
+			throw error;
+		}
 	}
 
 	/**

package/src/gc/gcConfigs.ts

@@ -3,8 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { UsageError } from "@fluidframework/container-utils";
-import { MonitoringContext } from "@fluidframework/telemetry-utils";
+import { MonitoringContext, UsageError } from "@fluidframework/telemetry-utils";
 import { IContainerRuntimeMetadata } from "../summary";
 import {
 	currentGCVersion,
@@ -153,6 +152,8 @@ export function generateGCConfigs(
 		throw new UsageError("inactive timeout should not be greater than the sweep timeout");
 	}
 
+	const throwOnInactiveLoad: boolean | undefined = createParams.gcOptions.throwOnInactiveLoad;
+
 	// Whether we are running in test mode. In this mode, unreferenced nodes are immediately deleted.
 	const testMode =
 		mc.config.getBoolean(gcTestModeKey) ?? createParams.gcOptions.runGCInTestMode === true;
@@ -172,6 +173,7 @@ export function generateGCConfigs(
 		sessionExpiryTimeoutMs,
 		sweepTimeoutMs,
 		inactiveTimeoutMs,
+		throwOnInactiveLoad,
 		persistedGcFeatureMatrix,
 		gcVersionInBaseSnapshot,
 		gcVersionInEffect,

package/src/gc/gcDefinitions.ts

@@ -349,6 +349,8 @@ export interface IGarbageCollectorConfigs {
 	readonly sweepTimeoutMs: number | undefined;
 	/** The time after which an unreferenced node is inactive. */
 	readonly inactiveTimeoutMs: number;
+	/** It is easier for users to diagnose InactiveObject usage if we throw on load, which this option enables */
+	readonly throwOnInactiveLoad: boolean | undefined;
 	/** Tracks whether GC should run in test mode. In this mode, unreferenced objects are deleted immediately. */
 	readonly testMode: boolean;
 	/**

package/src/gc/gcTelemetry.ts

@@ -23,6 +23,7 @@ import {
 	runSweepKey,
 } from "./gcDefinitions";
 import { UnreferencedStateTracker } from "./gcUnreferencedStateTracker";
+// eslint-disable-next-line import/no-deprecated
 import { tagAsCodeArtifact } from "./gcHelpers";
 
 type NodeUsageType = "Changed" | "Loaded" | "Revived";
@@ -183,6 +184,7 @@ export class GCTelemetryTracker {
 				{
 					eventName: `GC_Tombstone_${nodeType}_Revived`,
 					category: "generic",
+					// eslint-disable-next-line import/no-deprecated
 					url: tagAsCodeArtifact(id),
 					gcTombstoneEnforcementAllowed: this.gcTombstoneEnforcementAllowed,
 				},

package/src/id-compressor/appendOnlySortedMap.ts

@@ -3,10 +3,9 @@
  * Licensed under the MIT License.
  */
 
+/* eslint-disable tsdoc/syntax */
 /* eslint-disable no-bitwise */
-
 import { assert } from "@fluidframework/common-utils";
-import { fail } from "./utils";
 
 /**
  * A map in which entries are always added in key-sorted order.
@@ -133,7 +132,7 @@ export class AppendOnlySortedMap<K, V> {
 	}
 
 	/**
-	 * Adds a new key/value pair to the map. `key` must be \> to all keys in the map.
+	 * Adds a new key/value pair to the map. `key` must be > to all keys in the map.
 	 * @param key - the key to add.
 	 * @param value - the value to add.
 	 */
@@ -141,7 +140,27 @@ export class AppendOnlySortedMap<K, V> {
 		const { elements } = this;
 		const { length } = elements;
 		if (length !== 0 && this.comparator(key, this.maxKey() as K) <= 0) {
-			fail("Inserted key must be > all others in the map.");
+			throw new Error("Inserted key must be > all others in the map.");
+		}
+		elements.push(key);
+		elements.push(value);
+	}
+
+	/**
+	 * Replaces the last key/value pair with the given one. If the map is empty, it simply appends.
+	 * `key` must be > to all keys in the map prior to the one replaced.
+	 * @param key - the key to add.
+	 * @param value - the value to add.
+	 */
+	public replaceLast(key: K, value: V): void {
+		const { elements, comparator } = this;
+		const { length } = elements;
+		if (length !== 0) {
+			elements.pop();
+			elements.pop();
+			if (comparator(key, this.maxKey() as K) <= 0) {
+				throw new Error("Inserted key must be > all others in the map.");
+			}
 		}
 		elements.push(key);
 		elements.push(value);
@@ -217,7 +236,7 @@ export class AppendOnlySortedMap<K, V> {
 			if (prev !== undefined) {
 				assert(
 					this.comparator(kv[0], prev[0]) > 0,
-					0x47f /* Keys in map must be sorted. */,
+					0x752 /* Keys in map must be sorted. */,
 				);
 			}
 			prev = kv;
@@ -338,90 +357,10 @@ export class AppendOnlySortedMap<K, V> {
 			} else if (c === 0) {
 				return keyIndex;
 			} else {
-				fail("Invalid comparator.");
+				throw new Error("Invalid comparator.");
 			}
 			mid = (low + high) >> 1;
 		}
 		return (mid * 2) ^ AppendOnlySortedMap.failureXor;
 	}
 }
-
-/**
- * A map in which entries are always added in both key-sorted and value-sorted order.
- * Supports appending and searching.
- */
-export class AppendOnlyDoublySortedMap<K, V, S> extends AppendOnlySortedMap<K, V> {
-	public constructor(
-		keyComparator: (a: K, b: K) => number,
-		private readonly extractSearchValue: (value: V) => S,
-		private readonly valueComparator: (search: S, value: S) => number,
-	) {
-		super(keyComparator);
-	}
-
-	public override append(key: K, value: V): void {
-		if (
-			this.elements.length !== 0 &&
-			this.valueComparator(
-				this.extractSearchValue(value),
-				this.extractSearchValue(this.maxValue() as V),
-			) <= 0
-		) {
-			fail("Inserted value must be > all others in the map.");
-		}
-		super.append(key, value);
-	}
-
-	private readonly compareValues = (search: S, _: K, value: V): number => {
-		return this.valueComparator(search, this.extractSearchValue(value));
-	};
-
-	// /**
-	//  * @param value - the value to lookup.
-	//  * @returns the key associated with `value` if such an entry exists, and undefined otherwise.
-	//  */
-	// public getByValue(value: S): K | undefined {
-	//     const index = AppendOnlySortedMap.keyIndexOf(this.elements, value, this.compareValues);
-	//     return this.elements[index]?.[0];
-	// }
-
-	/**
-	 * @param searchValue - the search value to lookup.
-	 * @returns the entry who's value, when run through the extractor provided to the constructor, matches
-	 * `searchValue`. If no such entry exists, this method returns the next lower entry as determined by the value
-	 * comparator provided to the constructor. If no such entry exists, this method returns undefined.
-	 */
-	public getPairOrNextLowerByValue(searchValue: S): readonly [K, V] | undefined {
-		return this.getPairOrNextLowerBy(searchValue, this.compareValues);
-	}
-
-	/**
-	 * @param searchValue - the search value to lookup.
-	 * @returns the entry who's value, when run through the extractor provided to the constructor, matches `searchValue`. If no such entry
-	 * exists, this method returns the next higher entry as determined by the value comparator provided to the constructor. If no such entry
-	 * exists, this method returns undefined.
-	 */
-	public getPairOrNextHigherByValue(searchValue: S): readonly [K, V] | undefined {
-		return this.getPairOrNextHigherBy(searchValue, this.compareValues);
-	}
-
-	/**
-	 * Test-only expensive assertions to check the internal validity of the data structure.
-	 */
-	public override assertValid(): void {
-		super.assertValid();
-		let prev: readonly [unknown, V] | undefined;
-		for (const kv of this.entries()) {
-			if (prev !== undefined) {
-				assert(
-					this.valueComparator(
-						this.extractSearchValue(kv[1]),
-						this.extractSearchValue(prev[1]),
-					) > 0,
-					0x480 /* Values in map must be sorted. */,
-				);
-			}
-			prev = kv;
-		}
-	}
-}

package/src/id-compressor/finalSpace.ts

@@ -0,0 +1,67 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/common-utils";
+import { IdCluster, clustersEqual, lastAllocatedFinal, lastFinalizedFinal } from "./sessions";
+import { FinalCompressedId } from "./identifiers";
+
+/**
+ * All IDs that have been finalized (acked), grouped into clusters sorted by their base final IDs.
+ * These clusters span the positive integer space and are not sparse, meaning a cluster's base final
+ * ID will always be one greater than the last final ID in the previous cluster (or 0 if there is not one).
+ */
+export class FinalSpace {
+	private readonly clusterList: IdCluster[] = [];
+
+	public get clusters(): readonly IdCluster[] {
+		return this.clusterList;
+	}
+
+	public getLastCluster(): IdCluster | undefined {
+		return this.clusterList[this.clusterList.length - 1];
+	}
+
+	public addCluster(newCluster: IdCluster) {
+		const lastCluster = this.getLastCluster();
+		assert(
+			lastCluster === undefined ||
+				// eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+				newCluster.baseFinalId === lastCluster.baseFinalId + lastCluster.capacity,
+			0x753 /* Cluster insert to final_space is out of order. */,
+		);
+		this.clusterList.push(newCluster);
+	}
+
+	/**
+	 * @returns the upper bound (exclusive) of finalized IDs in final space, i.e. one greater than the last final ID in the last cluster.
+	 * Note: this does not include allocated but unfinalized space in clusters.
+	 */
+	public getFinalizedIdLimit(): FinalCompressedId {
+		const lastCluster = this.getLastCluster();
+		return lastCluster === undefined
+			? (0 as FinalCompressedId)
+			: (((lastFinalizedFinal(lastCluster) as number) + 1) as FinalCompressedId);
+	}
+
+	/**
+	 * @returns the upper bound (exclusive) of allocated IDs in final space, i.e. one greater than the last final ID in the last cluster.
+	 * Note: this does includes all allocated IDs in clusters.
+	 */
+	public getAllocatedIdLimit(): FinalCompressedId {
+		const lastCluster = this.getLastCluster();
+		return lastCluster === undefined
+			? (0 as FinalCompressedId)
+			: (((lastAllocatedFinal(lastCluster) as number) + 1) as FinalCompressedId);
+	}
+
+	public equals(other: FinalSpace): boolean {
+		for (let i = 0; i < this.clusterList.length; i++) {
+			if (!clustersEqual(this.clusterList[i], other.clusterList[i])) {
+				return false;
+			}
+		}
+		return this.clusterList.length === other.clusterList.length;
+	}
+}