@fluidframework/container-runtime 2.0.0-internal.3.3.1 → 2.0.0-internal.3.4.0

package/src/containerRuntime.ts

@@ -1001,6 +1001,12 @@ export class ContainerRuntime
 	 */
 	public readonly gcTombstoneEnforcementAllowed: boolean;
 
+	/**
+	 * GUID to identify a document in telemetry
+	 * ! Note: should not be used for anything other than telemetry and is not considered a stable GUID
+	 */
+	private readonly telemetryDocumentId: string;
+
 	/**
 	 * @internal
 	 */
@@ -1074,6 +1080,8 @@ export class ContainerRuntime
 			}),
 		});
 
+		this.telemetryDocumentId = metadata?.telemetryDocumentId ?? uuid();
+
 		this.disableAttachReorder = this.mc.config.getBoolean(
 			"Fluid.ContainerRuntime.disableAttachOpReorder",
 		);
@@ -1226,8 +1234,6 @@ export class ContainerRuntime
 				}
 			},
 			(blobPath: string) => this.garbageCollector.nodeUpdated(blobPath, "Loaded"),
-			(fromPath: string, toPath: string) =>
-				this.garbageCollector.addedOutboundReference(fromPath, toPath),
 			(blobPath: string) => this.garbageCollector.isNodeDeleted(blobPath),
 			this,
 			pendingRuntimeState?.pendingAttachmentBlobs,
@@ -1428,6 +1434,7 @@ export class ContainerRuntime
 				disableAttachReorder: this.disableAttachReorder,
 				disablePartialFlush,
 			}),
+			telemetryDocumentId: this.telemetryDocumentId,
 		});
 
 		ReportOpPerfTelemetry(this.context.clientId, this.deltaManager, this.logger);
@@ -1608,6 +1615,7 @@ export class ContainerRuntime
 			message:
 				extractSummaryMetadataMessage(this.deltaManager.lastMessage) ??
 				this.messageAtLastSummary,
+			telemetryDocumentId: this.telemetryDocumentId,
 		};
 		addBlobToSummary(summaryTree, metadataBlobName, JSON.stringify(metadata));
 	}
@@ -2544,7 +2552,7 @@ export class ContainerRuntime
 	 * @param options - options controlling how the summary is generated or submitted
 	 */
 	public async submitSummary(options: ISubmitSummaryOptions): Promise<SubmitSummaryResult> {
-		const { fullTree, refreshLatestAck, summaryLogger } = options;
+		const { fullTree = false, refreshLatestAck, summaryLogger } = options;
 		// The summary number for this summary. This will be updated during the summary process, so get it now and
 		// use it for all events logged during this summary.
 		const summaryNumber = this.nextSummaryNumber;
@@ -2639,7 +2647,7 @@ export class ContainerRuntime
 			const forcedFullTree = this.garbageCollector.summaryStateNeedsReset;
 			try {
 				summarizeResult = await this.summarize({
-					fullTree: fullTree ?? forcedFullTree,
+					fullTree: fullTree || forcedFullTree,
 					trackState: true,
 					summaryLogger: summaryNumberLogger,
 					runGC: this.garbageCollector.shouldRunGC,

package/src/gc/garbageCollection.ts

@@ -153,7 +153,7 @@ export class GarbageCollector implements IGarbageCollector {
 	private readonly activeConnection: () => boolean;
 
 	public get summaryStateNeedsReset(): boolean {
-		return this.summaryStateTracker.doesSummaryStateNeedReset();
+		return this.summaryStateTracker.doesSummaryStateNeedReset;
 	}
 
 	/** Handler to respond to when a SweepReady object is used */
@@ -201,11 +201,8 @@ export class GarbageCollector implements IGarbageCollector {
 		}
 
 		this.summaryStateTracker = new GCSummaryStateTracker(
-			this.shouldRunGC,
-			this.configs.tombstoneMode,
-			this.mc,
+			this.configs,
 			baseSnapshot?.trees[gcTreeKey] !== undefined /* wasGCRunInBaseSnapshot */,
-			this.configs.gcVersionInBaseSnapshot,
 		);
 
 		// Get the GC data from the base snapshot. Use LazyPromise because we only want to do this once since it
@@ -469,8 +466,7 @@ export class GarbageCollector implements IGarbageCollector {
 	): Promise<IGCStats | undefined> {
 		const fullGC =
 			options.fullGC ??
-			(this.configs.runFullGC === true ||
-				this.summaryStateTracker.doesSummaryStateNeedReset());
+			(this.configs.runFullGC === true || this.summaryStateTracker.doesSummaryStateNeedReset);
 		const logger = options.logger
 			? ChildLogger.create(options.logger, undefined, {
 					all: { completedGCRuns: () => this.completedRuns },
@@ -622,7 +618,7 @@ export class GarbageCollector implements IGarbageCollector {
 			gcFeature: this.configs.gcEnabled ? this.summaryStateTracker.currentGCVersion : 0,
 			gcFeatureMatrix: this.configs.persistedGcFeatureMatrix,
 			sessionExpiryTimeoutMs: this.configs.sessionExpiryTimeoutMs,
-			sweepEnabled: this.configs.sweepEnabled,
+			sweepEnabled: false, // DEPRECATED - to be removed
 			sweepTimeoutMs: this.configs.sweepTimeoutMs,
 		};
 	}

package/src/gc/gcConfigs.ts

@@ -3,17 +3,20 @@
  * Licensed under the MIT License.
  */
 
-import { UsageError } from "@fluidframework/driver-utils";
+import { UsageError } from "@fluidframework/container-utils";
 import { MonitoringContext } from "@fluidframework/telemetry-utils";
 import { IContainerRuntimeMetadata } from "../summary";
 import {
+	currentGCVersion,
 	defaultInactiveTimeoutMs,
 	defaultSessionExpiryDurationMs,
 	disableTombstoneKey,
 	GCFeatureMatrix,
+	gcSweepGenerationOptionName,
 	gcTestModeKey,
 	gcTombstoneGenerationOptionName,
 	GCVersion,
+	gcVersionUpgradeToV2Key,
 	IGarbageCollectorConfigs,
 	IGCRuntimeOptions,
 	maxSnapshotCacheExpiryMs,
@@ -21,8 +24,9 @@ import {
 	runGCKey,
 	runSessionExpiryKey,
 	runSweepKey,
+	stableGCVersion,
 } from "./gcDefinitions";
-import { getGCVersion } from "./gcHelpers";
+import { getGCVersion, shouldAllowGcSweep } from "./gcHelpers";
 
 /**
  * Generates configurations for the Garbage Collector that it uses to determine what to run and how.
@@ -42,7 +46,6 @@ export function generateGCConfigs(
 	},
 ): IGarbageCollectorConfigs {
 	let gcEnabled: boolean;
-	let sweepEnabled: boolean;
 	let sessionExpiryTimeoutMs: number | undefined;
 	let sweepTimeoutMs: number | undefined;
 	let persistedGcFeatureMatrix: GCFeatureMatrix | undefined;
@@ -60,15 +63,16 @@ export function generateGCConfigs(
 		// Existing documents which did not have createParams.metadata blob or had GC disabled have version as 0. For all
 		// other existing documents, GC is enabled.
 		gcEnabled = gcVersionInBaseSnapshot > 0;
-		sweepEnabled = createParams.metadata?.sweepEnabled ?? false;
 		sessionExpiryTimeoutMs = createParams.metadata?.sessionExpiryTimeoutMs;
 		sweepTimeoutMs =
 			createParams.metadata?.sweepTimeoutMs ?? computeSweepTimeout(sessionExpiryTimeoutMs); // Backfill old documents that didn't persist this
 		persistedGcFeatureMatrix = createParams.metadata?.gcFeatureMatrix;
 	} else {
-		// Sweep should not be enabled without enabling GC mark phase. We could silently disable sweep in this
-		// scenario but explicitly failing makes it clearer and promotes correct usage.
-		if (createParams.gcOptions.sweepAllowed && createParams.gcOptions.gcAllowed === false) {
+		const tombstoneGeneration = createParams.gcOptions[gcTombstoneGenerationOptionName];
+		const sweepGeneration = createParams.gcOptions[gcSweepGenerationOptionName];
+
+		// Sweep should not be enabled (via sweepGeneration value) without enabling GC mark phase.
+		if (sweepGeneration !== undefined && createParams.gcOptions.gcAllowed === false) {
 			throw new UsageError("GC sweep phase cannot be enabled without enabling GC mark phase");
 		}
 
@@ -80,8 +84,6 @@ export function generateGCConfigs(
 		// For new documents, GC is enabled by default. It can be explicitly disabled by setting the gcAllowed
 		// flag in GC options to false.
 		gcEnabled = createParams.gcOptions.gcAllowed !== false;
-		// The sweep phase has to be explicitly enabled by setting the sweepAllowed flag in GC options to true.
-		sweepEnabled = createParams.gcOptions.sweepAllowed === true;
 
 		// Set the Session Expiry if GC is enabled and session expiry flag isn't explicitly set to false.
 		if (gcEnabled && mc.config.getBoolean(runSessionExpiryKey) !== false) {
@@ -90,13 +92,20 @@ export function generateGCConfigs(
 		}
 		sweepTimeoutMs = testOverrideSweepTimeoutMs ?? computeSweepTimeout(sessionExpiryTimeoutMs);
 
-		if (createParams.gcOptions[gcTombstoneGenerationOptionName] !== undefined) {
+		if (tombstoneGeneration !== undefined || sweepGeneration !== undefined) {
 			persistedGcFeatureMatrix = {
-				tombstoneGeneration: createParams.gcOptions[gcTombstoneGenerationOptionName],
+				tombstoneGeneration,
+				sweepGeneration,
 			};
 		}
 	}
 
+	// Is sweepEnabled for this document?
+	const sweepEnabled = shouldAllowGcSweep(
+		persistedGcFeatureMatrix ?? {} /* persistedGenerations */,
+		createParams.gcOptions[gcSweepGenerationOptionName] /* currentGeneration */,
+	);
+
 	/**
 	 * Whether GC should run or not. The following conditions have to be met to run sweep:
 	 *
@@ -120,7 +129,7 @@ export function generateGCConfigs(
 	 * 2. Sweep timeout should be available. Without this, we wouldn't know when an object should be deleted.
 	 * 3. The driver must implement the policy limiting the age of snapshots used for loading. Otherwise
 	 * the Sweep Timeout calculation is not valid. We use the persisted value to ensure consistency over time.
-	 * 4. Sweep should be enabled for this container (this.sweepEnabled). This can be overridden via runSweep
+	 * 4. Sweep should be enabled for this container. This can be overridden via runSweep
 	 * feature flag.
 	 */
 	const shouldRunSweep =
@@ -147,6 +156,10 @@ export function generateGCConfigs(
 	const tombstoneMode = !shouldRunSweep && mc.config.getBoolean(disableTombstoneKey) !== true;
 	const runFullGC = createParams.gcOptions.runFullGC;
 
+	// If version upgrade is not enabled, fall back to the stable GC version.
+	const gcVersionInEffect =
+		mc.config.getBoolean(gcVersionUpgradeToV2Key) === true ? currentGCVersion : stableGCVersion;
+
 	return {
 		gcEnabled,
 		sweepEnabled,
@@ -160,6 +173,7 @@ export function generateGCConfigs(
 		inactiveTimeoutMs,
 		persistedGcFeatureMatrix,
 		gcVersionInBaseSnapshot,
+		gcVersionInEffect,
 	};
 }
 

package/src/gc/gcDefinitions.ts

@@ -23,8 +23,21 @@ export const stableGCVersion: GCVersion = 1;
 /** The current version of garbage collection. */
 export const currentGCVersion: GCVersion = 2;
 
-/** This undocumented GC Option (on ContainerRuntime Options) allows an app to disable enforcing GC on old documents by incrementing this value */
+/**
+ * This undocumented GC Option (on ContainerRuntime Options) allows an app to disable enforcing GC on old documents by incrementing this value
+ *
+ * If unset, GC Tombstone phase will operate as otherwise configured
+ * Otherwise, only enforce GC Tombstone if the passed in value matches the persisted value
+ */
 export const gcTombstoneGenerationOptionName = "gcTombstoneGeneration";
+/**
+ * This GC Option (on ContainerRuntime Options) allows an app to disable GC Sweep on old documents by incrementing this value.
+ *
+ * If unset altogether, Sweep will be disabled.
+ * If 0 is passed in, Sweep will be enabled for any document with gcSweepGeneration OR gcTombstoneGeneration as 0.
+ * If any other number is passed in, Sweep will be enabled only for documents with the same value persisted.
+ */
+export const gcSweepGenerationOptionName = "gcSweepGeneration";
 
 // Feature gate key to turn GC on / off.
 export const runGCKey = "Fluid.GarbageCollection.RunGC";
@@ -68,10 +81,16 @@ export const defaultSessionExpiryDurationMs = 30 * oneDayMs; // 30 days
 export interface GCFeatureMatrix {
 	/**
 	 * The Tombstone Generation value in effect when this file was created.
-	 * Gives a way for an app to disqualify old files from GC Tombstone enforcement
-	 * Provided via Container Runtime Options
+	 * Gives a way for an app to disqualify old files from GC Tombstone enforcement.
+	 * Provided via Container Runtime Options.
 	 */
 	tombstoneGeneration?: number;
+	/**
+	 * The Sweep Generation value in effect when this file was created.
+	 * Gives a way for an app to disqualify old files from GC Sweep.
+	 * Provided via Container Runtime Options.
+	 */
+	sweepGeneration?: number;
 }
 
 export interface IGCMetadata {
@@ -97,6 +116,8 @@ export interface IGCMetadata {
 	 */
 	readonly gcFeatureMatrix?: GCFeatureMatrix;
 	/**
+	 * @deprecated - @see GCFeatureMatrix.sweepGeneration
+	 *
 	 * Tells whether the GC sweep phase is enabled for this container.
 	 * - True means sweep phase is enabled.
 	 * - False means sweep phase is disabled. If GC is disabled as per gcFeature, sweep is also disabled.
@@ -255,6 +276,8 @@ export interface IGCRuntimeOptions {
 	gcAllowed?: boolean;
 
 	/**
+	 * @deprecated -  @see gcSweepGenerationOptionName and @see GCFeatureMatrix.sweepGeneration
+	 *
 	 * Flag that if true, enables GC's sweep phase for a new container.
 	 *
 	 * This will allow GC to eventually delete unreferenced objects from the container.
@@ -336,6 +359,8 @@ export interface IGarbageCollectorConfigs {
 	readonly persistedGcFeatureMatrix: GCFeatureMatrix | undefined;
 	/** The version of GC in the base snapshot. */
 	readonly gcVersionInBaseSnapshot: GCVersion | undefined;
+	/** The current version of GC data in the running code */
+	readonly gcVersionInEffect: GCVersion;
 }
 
 /** The state of node that is unreferenced. */

package/src/gc/gcHelpers.ts

@@ -23,6 +23,7 @@ import {
 } from "../summary";
 import {
 	disableTombstoneKey,
+	GCFeatureMatrix,
 	GCVersion,
 	IGCMetadata,
 	runSweepKey,
@@ -65,14 +66,19 @@ export function sendGCUnexpectedUsageEvent(
 }
 
 /**
+ * Indicates whether Tombstone Enforcement is allowed for this document based on the current/persisted
+ * TombstoneGeneration values
+ *
  * In order to protect old documents that were created at a time when known bugs exist that violate GC's invariants
- * such that enforcing GC (Fail on Tombstone load/usage, GC Sweep) would cause legitimate data loss,
+ * such that enforcing GC Tombstone (Failing on Tombstone load/usage) would cause legitimate data loss,
  * the container author may increment the generation value for Tombstone such that containers created
  * with a different value will not be subjected to GC enforcement.
+ *
  * If no generation is provided at runtime, this defaults to return true to maintain expected default behavior
- * @param persistedGeneration - The persisted feature support value
- * @param currentGeneration - The current app-provided feature support value
- * @returns true if GC Enforcement (Fail on Tombstone load/usage) should be allowed
+ *
+ * @param persistedGeneration - The persisted tombstoneGeneration value
+ * @param currentGeneration - The current app-provided tombstoneGeneration value
+ * @returns true if GC Tombstone enforcement (Fail on Tombstone load/usage) should be allowed for this document
  */
 export function shouldAllowGcTombstoneEnforcement(
 	persistedGeneration: number | undefined,
@@ -85,6 +91,41 @@ export function shouldAllowGcTombstoneEnforcement(
 	return persistedGeneration === currentGeneration;
 }
 
+/**
+ * Indicates whether Sweep is allowed for this document based on the GC Feature Matrix and current SweepGeneration
+ *
+ * In order to protect old documents that were created at a time when known bugs exist that violate GC's invariants
+ * such that enforcing GC Sweep would cause legitimate data loss, the container author may increment the generation value for Sweep
+ * such that containers created with a different value will not be subjected to GC Sweep.
+ *
+ * If no generation is provided, Sweep will be disabled.
+ * Passing 0 is a special case: Sweep will be enabled for any document with gcSweepGeneration OR gcTombstoneGeneration as 0.
+ *
+ * @param persistedGenerations - The persisted sweep/tombstone generations from the GC Feature Matrix
+ * @param currentGeneration - The current app-provided sweepGeneration value
+ * @returns true if GC Sweep should be allowed for this document
+ */
+export function shouldAllowGcSweep(
+	persistedGenerations: Pick<GCFeatureMatrix, "sweepGeneration" | "tombstoneGeneration">,
+	currentGeneration: number | undefined,
+): boolean {
+	// If no Generation value is provided for this session, default to false
+	if (currentGeneration === undefined) {
+		return false;
+	}
+
+	// 0 is a special case: It matches both SweepGeneration and TombstoneGeneration
+	// This is an optimistic measure to maximize coverage of GC Sweep if no bumps to TombstoneGeneration are needed before enabling Sweep.
+	if (currentGeneration === 0) {
+		return (
+			persistedGenerations.sweepGeneration === 0 ||
+			persistedGenerations.tombstoneGeneration === 0
+		);
+	}
+
+	return persistedGenerations.sweepGeneration === currentGeneration;
+}
+
 /**
  * Sorts the given GC state as per the id of the GC nodes. It also sorts the outbound routes array of each node.
  */

package/src/gc/gcSummaryStateTracker.ts

@@ -21,15 +21,10 @@ import {
 	RefreshSummaryResult,
 	SummaryTreeBuilder,
 } from "@fluidframework/runtime-utils";
-import { MonitoringContext } from "@fluidframework/telemetry-utils";
 import { IContainerRuntimeMetadata, metadataBlobName } from "../summary";
-import {
-	currentGCVersion,
-	GCVersion,
-	gcVersionUpgradeToV2Key,
-	stableGCVersion,
-} from "./gcDefinitions";
+import { GCVersion } from "./gcDefinitions";
 import { generateSortedGCState, getGCVersion } from "./gcHelpers";
+import { IGarbageCollectorConfigs } from ".";
 
 /**
  * The GC data that is tracked for a summary.
@@ -48,7 +43,7 @@ interface IGCSummaryTrackingData {
  */
 export class GCSummaryStateTracker {
 	// The current version of GC running.
-	public readonly currentGCVersion: GCVersion;
+	public readonly currentGCVersion: GCVersion = this.configs.gcVersionInEffect;
 	// This is the version of GC data in the latest summary being tracked.
 	private latestSummaryGCVersion: GCVersion;
 
@@ -62,24 +57,17 @@ export class GCSummaryStateTracker {
 
 	constructor(
 		// Tells whether GC should run or not.
-		private readonly shouldRunGC: boolean,
-		// Tells whether tombstone mode is enabled or not.
-		private readonly tombstoneMode: boolean,
-		private readonly mc: MonitoringContext,
+		private readonly configs: Pick<
+			IGarbageCollectorConfigs,
+			"shouldRunGC" | "tombstoneMode" | "gcVersionInBaseSnapshot" | "gcVersionInEffect"
+		>,
 		// Tells whether GC was run in the base snapshot this container loaded from.
 		wasGCRunInBaseSnapshot: boolean,
-		// The GC version in the base snapshot this container loaded from.
-		gcVersionInBaseSnapshot: GCVersion | undefined,
 	) {
 		this.wasGCRunInLatestSummary = wasGCRunInBaseSnapshot;
-		// If version upgrade is not enabled, fall back to the stable GC version.
-		this.currentGCVersion =
-			this.mc.config.getBoolean(gcVersionUpgradeToV2Key) === true
-				? currentGCVersion
-				: stableGCVersion;
 		// For existing document, the latest summary is the one that we loaded from. So, use its GC version as the
 		// latest tracked GC version. For new documents, we will be writing the first summary with the current version.
-		this.latestSummaryGCVersion = gcVersionInBaseSnapshot ?? this.currentGCVersion;
+		this.latestSummaryGCVersion = this.configs.gcVersionInBaseSnapshot ?? this.currentGCVersion;
 	}
 
 	/**
@@ -96,8 +84,8 @@ export class GCSummaryStateTracker {
 	 * Note that the state will be reset only once for the first summary generated after this returns true. After that,
 	 * this will return false.
 	 */
-	public doesGCStateNeedReset(): boolean {
-		return this.wasGCRunInLatestSummary !== this.shouldRunGC;
+	public get doesGCStateNeedReset(): boolean {
+		return this.wasGCRunInLatestSummary !== this.configs.shouldRunGC;
 	}
 
 	/**
@@ -115,10 +103,10 @@ export class GCSummaryStateTracker {
 	 *
 	 * 4.2. This client's latest summary was updated from a snapshot that has a different GC version.
 	 */
-	public doesSummaryStateNeedReset(): boolean {
+	public get doesSummaryStateNeedReset(): boolean {
 		return (
-			this.doesGCStateNeedReset() ||
-			(this.shouldRunGC && this.latestSummaryGCVersion !== this.currentGCVersion)
+			this.doesGCStateNeedReset ||
+			(this.configs.shouldRunGC && this.latestSummaryGCVersion !== this.currentGCVersion)
 		);
 	}
 
@@ -135,7 +123,7 @@ export class GCSummaryStateTracker {
 		deletedNodes: Set<string>,
 		tombstones: string[],
 	): ISummarizeResult | undefined {
-		if (!this.shouldRunGC) {
+		if (!this.configs.shouldRunGC) {
 			return;
 		}
 
@@ -145,7 +133,7 @@ export class GCSummaryStateTracker {
 		const serializedDeletedNodes =
 			deletedNodes.size > 0 ? JSON.stringify(Array.from(deletedNodes).sort()) : undefined;
 		// If running in tombstone mode, serialize and write tombstones, if any.
-		const serializedTombstones = this.tombstoneMode
+		const serializedTombstones = this.configs.tombstoneMode
 			? tombstones.length > 0
 				? JSON.stringify(tombstones.sort())
 				: undefined
@@ -276,10 +264,10 @@ export class GCSummaryStateTracker {
 		// Note that this has to be updated if GC did not run too. Otherwise, `gcStateNeedsReset` will always return
 		// true in scenarios where GC is disabled but enabled in the snapshot we loaded from.
 		if (result.latestSummaryUpdated && result.wasSummaryTracked) {
-			this.wasGCRunInLatestSummary = this.shouldRunGC;
+			this.wasGCRunInLatestSummary = this.configs.shouldRunGC;
 		}
 
-		if (!result.latestSummaryUpdated || !this.shouldRunGC) {
+		if (!result.latestSummaryUpdated || !this.configs.shouldRunGC) {
 			return undefined;
 		}
 

package/src/gc/index.ts

@@ -12,6 +12,8 @@ export {
 	GCNodeType,
 	gcTestModeKey,
 	gcTombstoneGenerationOptionName,
+	gcSweepGenerationOptionName,
+	GCFeatureMatrix,
 	GCVersion,
 	gcVersionUpgradeToV2Key,
 	IGarbageCollectionRuntime, // Deprecated
@@ -36,6 +38,7 @@ export {
 	getSnapshotDataFromOldSnapshotFormat,
 	sendGCUnexpectedUsageEvent,
 	shouldAllowGcTombstoneEnforcement,
+	shouldAllowGcSweep,
 } from "./gcHelpers";
 export { GCSummaryStateTracker } from "./gcSummaryStateTracker";
 export {

package/src/packageVersion.ts

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

package/src/summary/summaryFormat.ts

@@ -89,6 +89,8 @@ export interface IContainerRuntimeMetadata extends ICreateContainerMetadata, IGC
 	readonly disableIsolatedChannels?: true;
 	/** The summary number for a container's summary. Incremented on summaries throughout its lifetime. */
 	readonly summaryNumber?: number;
+	/** GUID to identify a document in telemetry */
+	readonly telemetryDocumentId?: string;
 }
 
 export interface ICreateContainerMetadata {