@fluidframework/container-runtime 2.0.0-dev.7.2.0.204906 → 2.0.0-dev.7.3.0.206769

package/src/containerRuntime.ts

@@ -25,6 +25,7 @@ import {
 	ILoaderOptions,
 	ILoader,
 	LoaderHeader,
+	IGetPendingLocalStateProps,
 } from "@fluidframework/container-definitions";
 import {
 	IContainerRuntime,
@@ -512,6 +513,7 @@ export interface RuntimeHeaderData {
 	wait?: boolean;
 	viaHandle?: boolean;
 	allowTombstone?: boolean;
+	allowInactive?: boolean;
 }
 
 /** Default values for Runtime Headers */
@@ -519,6 +521,7 @@ export const defaultRuntimeHeaderData: Required<RuntimeHeaderData> = {
 	wait: true,
 	viaHandle: false,
 	allowTombstone: false,
+	allowInactive: false,
 };
 
 /**
@@ -988,7 +991,7 @@ export class ContainerRuntime
 		summaryOp: ISummaryContent,
 		referenceSequenceNumber?: number,
 	) => number;
-	private readonly submitSignalFn: (contents: any) => void;
+	private readonly submitSignalFn: (content: any, targetClientId?: string) => void;
 	public readonly disposeFn: (error?: ICriticalContainerError) => void;
 	public readonly closeFn: (error?: ICriticalContainerError) => void;
 
@@ -1185,11 +1188,6 @@ export class ContainerRuntime
 		return this.garbageCollector.tombstoneEnforcementAllowed;
 	}
 
-	/** If true, throw an error when a tombstone data store is retrieved */
-	public get gcThrowOnTombstoneLoad(): boolean {
-		return this.garbageCollector.throwOnTombstoneLoad;
-	}
-
 	/** If true, throw an error when a tombstone data store is used. */
 	public get gcThrowOnTombstoneUsage(): boolean {
 		return this.garbageCollector.throwOnTombstoneUsage;
@@ -1871,6 +1869,9 @@ export class ContainerRuntime
 		if (typeof request.headers?.[AllowTombstoneRequestHeaderKey] === "boolean") {
 			headerData.allowTombstone = request.headers[AllowTombstoneRequestHeaderKey];
 		}
+		if (typeof request.headers?.[AllowInactiveRequestHeaderKey] === "boolean") {
+			headerData.allowInactive = request.headers[AllowInactiveRequestHeaderKey];
+		}
 
 		// We allow Tombstone requests for sub-DataStore objects
 		if (requestForChild) {
@@ -1880,20 +1881,24 @@ export class ContainerRuntime
 		await this.dataStores.waitIfPendingAlias(id);
 		const internalId = this.internalId(id);
 		const dataStoreContext = await this.dataStores.getDataStore(internalId, headerData);
-		const dataStoreChannel = await dataStoreContext.realize();
 
 		// Remove query params, leading and trailing slashes from the url. This is done to make sure the format is
 		// the same as GC nodes id.
 		const urlWithoutQuery = trimLeadingAndTrailingSlashes(request.url.split("?")[0]);
+		// Get the initial snapshot details which contain the data store package path.
+		const details = await dataStoreContext.getInitialSnapshotDetails();
+
+		// Note that this will throw if the data store is inactive or tombstoned and throwing on incorrect usage
+		// is configured.
 		this.garbageCollector.nodeUpdated(
 			`/${urlWithoutQuery}`,
 			"Loaded",
 			undefined /* timestampMs */,
-			dataStoreContext.packagePath,
-			request?.headers,
+			details.pkg,
+			request,
+			headerData,
 		);
-
-		return dataStoreChannel;
+		return dataStoreContext.realize();
 	}
 
 	/** Adds the container's metadata to the given summary tree. */
@@ -2537,6 +2542,12 @@ export class ContainerRuntime
 				"entryPoint must be defined on data store runtime for using getAliasedDataStoreEntryPoint",
 			);
 		}
+		this.garbageCollector.nodeUpdated(
+			`/${internalId}`,
+			"Loaded",
+			undefined /* timestampMs */,
+			context.packagePath,
+		);
 		return channel.entryPoint;
 	}
 
@@ -2663,16 +2674,28 @@ export class ContainerRuntime
 	 * Submits the signal to be sent to other clients.
 	 * @param type - Type of the signal.
 	 * @param content - Content of the signal.
+	 * @param targetClientId - When specified, the signal is only sent to the provided client id.
 	 */
-	public submitSignal(type: string, content: any) {
+	public submitSignal(type: string, content: any, targetClientId?: string) {
 		this.verifyNotClosed();
 		const envelope = this.createNewSignalEnvelope(undefined /* address */, type, content);
-		return this.submitSignalFn(envelope);
+		return this.submitSignalFn(envelope, targetClientId);
 	}
 
-	public submitDataStoreSignal(address: string, type: string, content: any) {
+	/**
+	 * Submits the signal to be sent to other clients.
+	 * @param type - Type of the signal.
+	 * @param content - Content of the signal.
+	 * @param targetClientId - When specified, the signal is only sent to the provided client id.
+	 */
+	public submitDataStoreSignal(
+		address: string,
+		type: string,
+		content: any,
+		targetClientId?: string,
+	) {
 		const envelope = this.createNewSignalEnvelope(address, type, content);
-		return this.submitSignalFn(envelope);
+		return this.submitSignalFn(envelope, targetClientId);
 	}
 
 	public setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void {
@@ -3932,9 +3955,7 @@ export class ContainerRuntime
 
 	public notifyAttaching() {} // do nothing (deprecated method)
 
-	public async getPendingLocalState(props?: {
-		notifyImminentClosure: boolean;
-	}): Promise<unknown> {
+	public async getPendingLocalState(props?: IGetPendingLocalStateProps): Promise<unknown> {
 		return PerformanceEvent.timedExecAsync(
 			this.mc.logger,
 			{
@@ -3944,6 +3965,7 @@ export class ContainerRuntime
 			async (event) => {
 				this.verifyNotClosed();
 				const waitBlobsToAttach = props?.notifyImminentClosure;
+				const stopBlobAttachingSignal = props?.stopBlobAttachingSignal;
 				if (this._orderSequentiallyCalls !== 0) {
 					throw new UsageError("can't get state during orderSequentially");
 				}
@@ -3952,7 +3974,7 @@ export class ContainerRuntime
 				// to close current batch.
 				this.flush();
 				const pendingAttachmentBlobs = waitBlobsToAttach
-					? await this.blobManager.attachAndGetPendingBlobs()
+					? await this.blobManager.attachAndGetPendingBlobs(stopBlobAttachingSignal)
 					: undefined;
 				const pending = this.pendingStateManager.getLocalState();
 				if (!pendingAttachmentBlobs && !this.hasPendingMessages()) {

package/src/dataStoreContext.ts

@@ -487,7 +487,16 @@ export abstract class FluidDataStoreContext
 		local: boolean,
 		localOpMetadata: unknown,
 	): void {
-		this.verifyNotClosed("process", true, extractSafePropertiesFromMessage(messageArg));
+		const safeTelemetryProps = extractSafePropertiesFromMessage(messageArg);
+		// On op process, tombstone error is logged in garbage collector. So, set "checkTombstone" to false when calling
+		// "verifyNotClosed" which logs tombstone errors. Throw error if tombstoned and throwing on load is configured.
+		this.verifyNotClosed("process", false /* checkTombstone */, safeTelemetryProps);
+		if (this.tombstoned && this.throwOnTombstoneUsage) {
+			throw new DataCorruptionError(
+				"Context is tombstoned! Call site [process]",
+				safeTelemetryProps,
+			);
+		}
 
 		const innerContents = messageArg.contents as FluidDataStoreMessage;
 		const message = {
@@ -721,11 +730,17 @@ export abstract class FluidDataStoreContext
 		}
 	}
 
-	public submitSignal(type: string, content: any) {
+	/**
+	 * Submits the signal to be sent to other clients.
+	 * @param type - Type of the signal.
+	 * @param content - Content of the signal.
+	 * @param targetClientId - When specified, the signal is only sent to the provided client id.
+	 */
+	public submitSignal(type: string, content: any, targetClientId?: string) {
 		this.verifyNotClosed("submitSignal");
 
 		assert(!!this.channel, 0x147 /* "Channel must exist on submitting signal" */);
-		return this._containerRuntime.submitDataStoreSignal(this.id, type, content);
+		return this._containerRuntime.submitDataStoreSignal(this.id, type, content, targetClientId);
 	}
 
 	/**
@@ -1090,7 +1105,7 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
 		return message;
 	}
 
-	public async getInitialSnapshotDetails(): Promise<ISnapshotDetails> {
+	private readonly initialSnapshotDetailsP = new LazyPromise<ISnapshotDetails>(async () => {
 		let snapshot = this.snapshotTree;
 		let attributes: ReadFluidDataStoreAttributes;
 		let isRootDataStore = false;
@@ -1123,6 +1138,10 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
 			isRootDataStore,
 			snapshot,
 		};
+	});
+
+	public async getInitialSnapshotDetails(): Promise<ISnapshotDetails> {
+		return this.initialSnapshotDetailsP;
 	}
 
 	/**

package/src/dataStores.ts

@@ -50,12 +50,7 @@ import { buildSnapshotTree } from "@fluidframework/driver-utils";
 import { assert, Lazy } from "@fluidframework/core-utils";
 import { v4 as uuid } from "uuid";
 import { DataStoreContexts } from "./dataStoreContexts";
-import {
-	ContainerRuntime,
-	defaultRuntimeHeaderData,
-	RuntimeHeaderData,
-	TombstoneResponseHeaderKey,
-} from "./containerRuntime";
+import { ContainerRuntime, defaultRuntimeHeaderData, RuntimeHeaderData } from "./containerRuntime";
 import {
 	FluidDataStoreContext,
 	RemoteFluidDataStoreContext,
@@ -442,9 +437,6 @@ export class DataStores implements IDisposable {
 			const request: IRequest = { url: id };
 			throw responseToException(create404Response(request), request);
 		}
-
-		this.validateNotTombstoned(context, requestHeaderData);
-
 		return context;
 	}
 
@@ -464,8 +456,6 @@ export class DataStores implements IDisposable {
 		if (context === undefined) {
 			return undefined;
 		}
-		// Check if the data store is tombstoned. If so, we want to log a telemetry event.
-		this.checkIfTombstoned(context, requestHeaderData);
 		return context;
 	}
 
@@ -516,62 +506,6 @@ export class DataStores implements IDisposable {
 		}
 	}
 
-	/**
-	 * Checks if the data store has not been marked as tombstone by GC or not.
-	 * @param context - the data store context in question
-	 * @param requestHeaderData - the request header information to log if the validation detects the data store has been tombstoned
-	 * @returns true if the data store is tombstoned. Otherwise, returns false.
-	 */
-	private checkIfTombstoned(
-		context: FluidDataStoreContext,
-		requestHeaderData: RuntimeHeaderData,
-	) {
-		if (!context.tombstoned) {
-			return false;
-		}
-		const logErrorEvent =
-			this.runtime.gcThrowOnTombstoneLoad && !requestHeaderData.allowTombstone;
-		sendGCUnexpectedUsageEvent(
-			this.mc,
-			{
-				eventName: "GC_Tombstone_DataStore_Requested",
-				category: logErrorEvent ? "error" : "generic",
-				isSummarizerClient: this.runtime.clientDetails.type === summarizerClientType,
-				id: context.id,
-				headers: JSON.stringify(requestHeaderData),
-				gcTombstoneEnforcementAllowed: this.runtime.gcTombstoneEnforcementAllowed,
-			},
-			context.isLoaded ? context.packagePath : undefined,
-		);
-		return true;
-	}
-
-	/**
-	 * Validates that the data store context requested has not been marked as tombstone by GC.
-	 * @param context - the data store context in question
-	 * @param request - the request information to log if the validation detects the data store has been tombstoned
-	 * @param requestHeaderData - the request header information to log if the validation detects the data store has been tombstoned
-	 */
-	private validateNotTombstoned(
-		context: FluidDataStoreContext,
-		requestHeaderData: RuntimeHeaderData,
-	) {
-		if (this.checkIfTombstoned(context, requestHeaderData)) {
-			// The requested data store is removed by gc. Create a 404 gc response exception.
-			const request: IRequest = { url: context.id };
-			const error = responseToException(
-				createResponseError(404, "DataStore was deleted", request, {
-					[TombstoneResponseHeaderKey]: true,
-				}),
-				request,
-			);
-			// Throw an error if configured via options and via request headers.
-			if (this.runtime.gcThrowOnTombstoneLoad && !requestHeaderData.allowTombstone) {
-				throw error;
-			}
-		}
-	}
-
 	public processSignal(fluidDataStoreId: string, message: IInboundSignalMessage, local: boolean) {
 		this.validateNotDeleted(fluidDataStoreId);
 		const context = this.contexts.get(fluidDataStoreId);

package/src/deltaManagerProxyBase.ts

@@ -101,8 +101,8 @@ export class DeltaManagerProxyBase
 		super.dispose();
 	}
 
-	public submitSignal(content: any): void {
-		return this.deltaManager.submitSignal(content);
+	public submitSignal(content: any, targetClientId?: string): void {
+		return this.deltaManager.submitSignal(content, targetClientId);
 	}
 
 	public flush(): void {

package/src/gc/garbageCollection.ts

@@ -4,7 +4,7 @@
  */
 
 import { LazyPromise, Timer } from "@fluidframework/core-utils";
-import { IRequest, IRequestHeader } from "@fluidframework/core-interfaces";
+import { IRequest } from "@fluidframework/core-interfaces";
 import {
 	gcTreeKey,
 	IGarbageCollectionData,
@@ -23,9 +23,9 @@ import {
 } from "@fluidframework/telemetry-utils";
 
 import {
-	AllowInactiveRequestHeaderKey,
 	InactiveResponseHeaderKey,
-	RuntimeHeaders,
+	RuntimeHeaderData,
+	TombstoneResponseHeaderKey,
 } from "../containerRuntime";
 import { ClientSessionExpiredError } from "../error";
 import { IRefreshSummaryResult } from "../summary";
@@ -862,11 +862,13 @@ export class GarbageCollector implements IGarbageCollector {
 	}
 
 	/**
-	 * Called when a node with the given id is updated. If the node is inactive, log an error.
+	 * Called when a node with the given id is updated. If the node is inactive or tombstoned, this will log an error
+	 * or throw an error if failing on incorrect usage is configured.
 	 * @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.
+	 * @param request - The original request for loads to preserve it in telemetry.
 	 * @param requestHeaders - If the node was loaded via request path, the headers in the request.
 	 */
 	public nodeUpdated(
@@ -874,12 +876,15 @@ export class GarbageCollector implements IGarbageCollector {
 		reason: "Loaded" | "Changed",
 		timestampMs?: number,
 		packagePath?: readonly string[],
-		requestHeaders?: IRequestHeader,
+		request?: IRequest,
+		headerData?: RuntimeHeaderData,
 	) {
 		if (!this.configs.shouldRunGC) {
 			return;
 		}
 
+		const isTombstoned = this.tombstones.includes(nodePath);
+
 		// This will log if appropriate
 		this.telemetryTracker.nodeUsed({
 			id: nodePath,
@@ -888,35 +893,44 @@ export class GarbageCollector implements IGarbageCollector {
 				timestampMs ?? this.runtime.getCurrentReferenceTimestampMs(),
 			packagePath,
 			completedGCRuns: this.completedRuns,
-			isTombstoned: this.tombstones.includes(nodePath),
+			isTombstoned,
 			lastSummaryTime: this.getLastSummaryTimestampMs(),
-			viaHandle: requestHeaders?.[RuntimeHeaders.viaHandle],
+			headers: headerData,
 		});
 
+		const nodeType = this.runtime.getNodeType(nodePath);
+
 		// Unless this is a Loaded event for a Blob or DataStore, we're done after telemetry tracking
-		if (
-			reason !== "Loaded" ||
-			![GCNodeType.Blob, GCNodeType.DataStore].includes(this.runtime.getNodeType(nodePath))
-		) {
+		if (reason !== "Loaded" || ![GCNodeType.Blob, GCNodeType.DataStore].includes(nodeType)) {
 			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,
+		const errorRequest: IRequest = request ?? { url: nodePath };
+		// If the object is tombstoned and tombstone enforcement is configured, throw an error.
+		if (isTombstoned && this.throwOnTombstoneLoad && headerData?.allowTombstone !== true) {
+			// The requested data store is removed by gc. Create a 404 gc response exception.
+			throw responseToException(
+				createResponseError(404, `${nodeType} was tombstoned`, errorRequest, {
+					[TombstoneResponseHeaderKey]: true,
 				}),
-				request,
+				errorRequest,
 			);
-			throw error;
+		}
+
+		// If the object is inactive and inactive enforcement is configured, throw an error.
+		if (this.unreferencedNodesState.get(nodePath)?.state === "Inactive") {
+			const shouldThrowOnInactiveLoad =
+				!this.isSummarizerClient &&
+				this.configs.throwOnInactiveLoad === true &&
+				headerData?.allowInactive !== true;
+			if (shouldThrowOnInactiveLoad) {
+				throw responseToException(
+					createResponseError(404, `${nodeType} is inactive`, errorRequest, {
+						[InactiveResponseHeaderKey]: true,
+					}),
+					errorRequest,
+				);
+			}
 		}
 	}
 

package/src/gc/gcDefinitions.ts

@@ -4,7 +4,7 @@
  */
 
 import { ICriticalContainerError } from "@fluidframework/container-definitions";
-import { IRequestHeader } from "@fluidframework/core-interfaces";
+import { IRequest } from "@fluidframework/core-interfaces";
 import { ISnapshotTree } from "@fluidframework/protocol-definitions";
 import {
 	IGarbageCollectionData,
@@ -19,6 +19,7 @@ import {
 	ICreateContainerMetadata,
 	IRefreshSummaryResult,
 } from "../summary";
+import { RuntimeHeaderData } from "../containerRuntime";
 
 /**
  * @public
@@ -251,13 +252,17 @@ export interface IGarbageCollector {
 	getBaseGCDetails(): Promise<IGarbageCollectionDetailsBase>;
 	/** Called when the latest summary of the system has been refreshed. */
 	refreshLatestSummary(result: IRefreshSummaryResult): Promise<void>;
-	/** Called when a node is updated. Used to detect and log when an inactive node is changed or loaded. */
+	/**
+	 * Called when a node with the given path is updated. If the node is inactive or tombstoned, this will log an error
+	 * or throw an error if failing on incorrect usage is configured.
+	 */
 	nodeUpdated(
 		nodePath: string,
 		reason: "Loaded" | "Changed",
 		timestampMs?: number,
 		packagePath?: readonly string[],
-		requestHeaders?: IRequestHeader,
+		request?: IRequest,
+		headerData?: RuntimeHeaderData,
 	): void;
 	/** Called when a reference is added to a node. Used to identify nodes that were referenced between summaries. */
 	addedOutboundReference(fromNodePath: string, toNodePath: string): void;