@fluidframework/container-loader 2.0.0-dev.4.4.0.162574 → 2.0.0-dev.5.3.2.178189

package/src/containerContext.ts

@@ -3,165 +3,66 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { assert, LazyPromise, TypedEventEmitter } from "@fluidframework/common-utils";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import {
 	IAudience,
 	IContainerContext,
 	IDeltaManager,
 	ILoader,
-	IRuntime,
 	ICriticalContainerError,
 	AttachState,
 	ILoaderOptions,
-	IRuntimeFactory,
-	IProvideRuntimeFactory,
 	IFluidCodeDetails,
-	IFluidCodeDetailsComparer,
-	IProvideFluidCodeDetailsComparer,
-	ICodeDetailsLoader,
-	IFluidModuleWithDetails,
 	IBatchMessage,
 } from "@fluidframework/container-definitions";
-import { IRequest, IResponse, FluidObject } from "@fluidframework/core-interfaces";
+import { FluidObject } from "@fluidframework/core-interfaces";
 import { IDocumentStorageService } from "@fluidframework/driver-definitions";
-import { isFluidResolvedUrl } from "@fluidframework/driver-utils";
 import {
 	IClientConfiguration,
 	IClientDetails,
 	IDocumentMessage,
-	IQuorum,
 	IQuorumClients,
 	ISequencedDocumentMessage,
-	ISignalMessage,
 	ISnapshotTree,
-	ISummaryTree,
 	IVersion,
 	MessageType,
 	ISummaryContent,
 } from "@fluidframework/protocol-definitions";
-import { PerformanceEvent } from "@fluidframework/telemetry-utils";
-import { UsageError } from "@fluidframework/container-utils";
-import { Container } from "./container";
-
-const PackageNotFactoryError = "Code package does not implement IRuntimeFactory";
 
 /**
- * Events that {@link ContainerContext} can emit through its lifecycle.
- *
- * "runtimeInstantiated" - When an {@link @fluidframework/container-definitions#IRuntime} has been instantiated (by
- * calling instantiateRuntime() on the runtime factory), and this._runtime is set.
- *
- * "disposed" - When its dispose() method is called. The {@link ContainerContext} is no longer usable at that point.
+ * {@inheritDoc @fluidframework/container-definitions#IContainerContext}
  */
-type ContextLifecycleEvents = "runtimeInstantiated" | "disposed";
-
 export class ContainerContext implements IContainerContext {
-	public static async createOrLoad(
-		container: Container,
-		scope: FluidObject,
-		codeLoader: ICodeDetailsLoader,
-		codeDetails: IFluidCodeDetails,
-		baseSnapshot: ISnapshotTree | undefined,
-		deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
-		quorum: IQuorum,
-		loader: ILoader,
-		submitFn: (type: MessageType, contents: any, batch: boolean, appData: any) => number,
-		submitSummaryFn: (summaryOp: ISummaryContent, referenceSequenceNumber?: number) => number,
-		submitBatchFn: (batch: IBatchMessage[], referenceSequenceNumber?: number) => number,
-		submitSignalFn: (contents: any) => void,
-		disposeFn: (error?: ICriticalContainerError) => void,
-		closeFn: (error?: ICriticalContainerError) => void,
-		version: string,
-		updateDirtyContainerState: (dirty: boolean) => void,
-		existing: boolean,
-		pendingLocalState?: unknown,
-	): Promise<ContainerContext> {
-		const context = new ContainerContext(
-			container,
-			scope,
-			codeLoader,
-			codeDetails,
-			baseSnapshot,
-			deltaManager,
-			quorum,
-			loader,
-			submitFn,
-			submitSummaryFn,
-			submitBatchFn,
-			submitSignalFn,
-			disposeFn,
-			closeFn,
-			version,
-			updateDirtyContainerState,
-			existing,
-			pendingLocalState,
-		);
-		await context.instantiateRuntime(existing);
-		return context;
-	}
-
-	public readonly taggedLogger: ITelemetryLogger;
-	public readonly supportedFeatures: ReadonlyMap<string, unknown>;
+	public readonly supportedFeatures: ReadonlyMap<string, unknown> = new Map([
+		/**
+		 * This version of the loader accepts `referenceSequenceNumber`, provided by the container runtime,
+		 * as a parameter to the `submitBatchFn` and `submitSummaryFn` functions.
+		 * This is then used to set the reference sequence numbers of the submitted ops in the DeltaManager.
+		 */
+		["referenceSequenceNumbers", true],
+	]);
 
 	public get clientId(): string | undefined {
-		return this.container.clientId;
+		return this._getClientId();
 	}
 
 	/**
 	 * DISCLAIMER: this id is only for telemetry purposes. Not suitable for any other usages.
 	 */
 	public get id(): string {
-		const resolvedUrl = this.container.resolvedUrl;
-		if (isFluidResolvedUrl(resolvedUrl)) {
-			return resolvedUrl.id;
-		}
-		return "";
-	}
-
-	public get clientDetails(): IClientDetails {
-		return this.container.clientDetails;
+		return this._getContainerDiagnosticId() ?? "";
 	}
 
-	private _connected: boolean;
 	/**
 	 * When true, ops are free to flow
 	 * When false, ops should be kept as pending or rejected
 	 */
 	public get connected(): boolean {
-		return this._connected;
-	}
-
-	public get canSummarize(): boolean {
-		return "summarize" in this.runtime;
+		return this._getConnected();
 	}
 
 	public get serviceConfiguration(): IClientConfiguration | undefined {
-		return this.container.serviceConfiguration;
-	}
-
-	public get audience(): IAudience {
-		return this.container.audience;
-	}
-
-	public get options(): ILoaderOptions {
-		return this.container.options;
-	}
-
-	public get baseSnapshot() {
-		return this._baseSnapshot;
-	}
-
-	public get storage(): IDocumentStorageService {
-		return this.container.storage;
-	}
-
-	private _runtime: IRuntime | undefined;
-	private get runtime() {
-		if (this._runtime === undefined) {
-			throw new Error("Attempted to access runtime before it was defined");
-		}
-		return this._runtime;
+		return this._getServiceConfiguration();
 	}
 
 	private _disposed = false;
@@ -170,59 +71,15 @@ export class ContainerContext implements IContainerContext {
 		return this._disposed;
 	}
 
-	public get codeDetails() {
-		return this._codeDetails;
-	}
-
-	private readonly _quorum: IQuorum;
-	public get quorum(): IQuorumClients {
-		return this._quorum;
-	}
-
-	private readonly _fluidModuleP: Promise<IFluidModuleWithDetails>;
-
-	/**
-	 * {@inheritDoc @fluidframework/container-definitions#IContainerContext.getEntryPoint}
-	 */
-	public async getEntryPoint?(): Promise<FluidObject | undefined> {
-		if (this._disposed) {
-			throw new UsageError("The context is already disposed");
-		}
-		if (this._runtime !== undefined) {
-			return this._runtime?.getEntryPoint?.();
-		}
-		return new Promise<FluidObject | undefined>((resolve, reject) => {
-			const runtimeInstantiatedHandler = () => {
-				assert(
-					this._runtime !== undefined,
-					0x5a3 /* runtimeInstantiated fired but runtime is still undefined */,
-				);
-				resolve(this._runtime.getEntryPoint?.());
-				this.lifecycleEvents.off("disposed", disposedHandler);
-			};
-			const disposedHandler = () => {
-				reject(new Error("ContainerContext was disposed"));
-				this.lifecycleEvents.off("runtimeInstantiated", runtimeInstantiatedHandler);
-			};
-			this.lifecycleEvents.once("runtimeInstantiated", runtimeInstantiatedHandler);
-			this.lifecycleEvents.once("disposed", disposedHandler);
-		});
-	}
-
-	/**
-	 * Emits events about the container context's lifecycle.
-	 * Use it to coordinate things inside the ContainerContext class.
-	 */
-	private readonly lifecycleEvents = new TypedEventEmitter<ContextLifecycleEvents>();
-
 	constructor(
-		private readonly container: Container,
+		public readonly options: ILoaderOptions,
 		public readonly scope: FluidObject,
-		private readonly codeLoader: ICodeDetailsLoader,
-		private readonly _codeDetails: IFluidCodeDetails,
-		private readonly _baseSnapshot: ISnapshotTree | undefined,
+		public readonly baseSnapshot: ISnapshotTree | undefined,
+		private readonly _version: IVersion | undefined,
 		public readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
-		quorum: IQuorum,
+		public readonly storage: IDocumentStorageService,
+		public readonly quorum: IQuorumClients,
+		public readonly audience: IAudience,
 		public readonly loader: ILoader,
 		public readonly submitFn: (
 			type: MessageType,
@@ -242,194 +99,29 @@ export class ContainerContext implements IContainerContext {
 		public readonly submitSignalFn: (contents: any) => void,
 		public readonly disposeFn: (error?: ICriticalContainerError) => void,
 		public readonly closeFn: (error?: ICriticalContainerError) => void,
-		public readonly version: string,
 		public readonly updateDirtyContainerState: (dirty: boolean) => void,
+		public readonly getAbsoluteUrl: (relativeUrl: string) => Promise<string | undefined>,
+		private readonly _getContainerDiagnosticId: () => string | undefined,
+		private readonly _getClientId: () => string | undefined,
+		private readonly _getServiceConfiguration: () => IClientConfiguration | undefined,
+		private readonly _getAttachState: () => AttachState,
+		private readonly _getConnected: () => boolean,
+		public readonly getSpecifiedCodeDetails: () => IFluidCodeDetails | undefined,
+		public readonly clientDetails: IClientDetails,
 		public readonly existing: boolean,
+		public readonly taggedLogger: ITelemetryLoggerExt,
 		public readonly pendingLocalState?: unknown,
-	) {
-		this._connected = this.container.connected;
-		this._quorum = quorum;
-		this.taggedLogger = container.subLogger;
-		this._fluidModuleP = new LazyPromise<IFluidModuleWithDetails>(async () =>
-			this.loadCodeModule(_codeDetails),
-		);
-
-		this.supportedFeatures = new Map([
-			/**
-			 * This version of the loader accepts `referenceSequenceNumber`, provided by the container runtime,
-			 * as a parameter to the `submitBatchFn` and `submitSummaryFn` functions.
-			 * This is then used to set the reference sequence numbers of the submitted ops in the DeltaManager.
-			 */
-			["referenceSequenceNumbers", true],
-		]);
-		this.attachListener();
-	}
-
-	/**
-	 * @deprecated Temporary migratory API, to be removed when customers no longer need it.
-	 * When removed, `ContainerContext` should only take an {@link @fluidframework/container-definitions#IQuorumClients}
-	 * rather than an {@link @fluidframework/protocol-definitions#IQuorum}.
-	 * See {@link @fluidframework/container-definitions#IContainerContext} for more details.
-	 */
-	public getSpecifiedCodeDetails(): IFluidCodeDetails | undefined {
-		return (this._quorum.get("code") ?? this._quorum.get("code2")) as
-			| IFluidCodeDetails
-			| undefined;
-	}
+	) {}
 
 	public dispose(error?: Error): void {
-		if (this._disposed) {
-			return;
-		}
 		this._disposed = true;
-
-		this.lifecycleEvents.emit("disposed");
-		this.runtime.dispose(error);
-		this._quorum.dispose();
-		this.deltaManager.dispose();
 	}
 
 	public getLoadedFromVersion(): IVersion | undefined {
-		return this.container.loadedFromVersion;
+		return this._version;
 	}
 
 	public get attachState(): AttachState {
-		return this.container.attachState;
-	}
-
-	/**
-	 * Create a summary. Used when attaching or serializing a detached container.
-	 *
-	 * @param blobRedirectTable - A table passed during the attach process. While detached, blob upload is supported
-	 * using IDs generated locally. After attach, these IDs cannot be used, so this table maps the old local IDs to the
-	 * new storage IDs so requests can be redirected.
-	 */
-	public createSummary(blobRedirectTable?: Map<string, string>): ISummaryTree {
-		return this.runtime.createSummary(blobRedirectTable);
-	}
-
-	public setConnectionState(connected: boolean, clientId?: string) {
-		const runtime = this.runtime;
-		this._connected = connected;
-		runtime.setConnectionState(connected, clientId);
-	}
-
-	public process(message: ISequencedDocumentMessage, local: boolean) {
-		this.runtime.process(message, local);
-	}
-
-	public processSignal(message: ISignalMessage, local: boolean) {
-		this.runtime.processSignal(message, local);
-	}
-
-	public async request(path: IRequest): Promise<IResponse> {
-		return this.runtime.request(path);
-	}
-
-	public async getAbsoluteUrl(relativeUrl: string): Promise<string | undefined> {
-		return this.container.getAbsoluteUrl(relativeUrl);
-	}
-
-	public getPendingLocalState(): unknown {
-		return this.runtime.getPendingLocalState();
-	}
-
-	/**
-	 * Determines if the current code details of the context
-	 * satisfy the incoming constraint code details
-	 */
-	public async satisfies(constraintCodeDetails: IFluidCodeDetails) {
-		const comparers: IFluidCodeDetailsComparer[] = [];
-
-		const maybeCompareCodeLoader = this.codeLoader;
-		if (maybeCompareCodeLoader.IFluidCodeDetailsComparer !== undefined) {
-			comparers.push(maybeCompareCodeLoader.IFluidCodeDetailsComparer);
-		}
-
-		const moduleWithDetails = await this._fluidModuleP;
-		const maybeCompareExport: Partial<IProvideFluidCodeDetailsComparer> | undefined =
-			moduleWithDetails.module?.fluidExport;
-		if (maybeCompareExport?.IFluidCodeDetailsComparer !== undefined) {
-			comparers.push(maybeCompareExport.IFluidCodeDetailsComparer);
-		}
-
-		// if there are not comparers it is not possible to know
-		// if the current satisfy the incoming, so return false,
-		// as assuming they do not satisfy is safer .e.g we will
-		// reload, rather than potentially running with
-		// incompatible code
-		if (comparers.length === 0) {
-			return false;
-		}
-
-		for (const comparer of comparers) {
-			const satisfies = await comparer.satisfies(
-				moduleWithDetails.details,
-				constraintCodeDetails,
-			);
-			if (satisfies === false) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	public async notifyOpReplay(message: ISequencedDocumentMessage): Promise<void> {
-		return this.runtime.notifyOpReplay?.(message);
-	}
-
-	// #region private
-
-	private async getRuntimeFactory(): Promise<IRuntimeFactory> {
-		const fluidExport: FluidObject<IProvideRuntimeFactory> | undefined = (
-			await this._fluidModuleP
-		).module?.fluidExport;
-		const runtimeFactory = fluidExport?.IRuntimeFactory;
-		if (runtimeFactory === undefined) {
-			throw new Error(PackageNotFactoryError);
-		}
-
-		return runtimeFactory;
-	}
-
-	private async instantiateRuntime(existing: boolean) {
-		const runtimeFactory = await this.getRuntimeFactory();
-		this._runtime = await PerformanceEvent.timedExecAsync(
-			this.taggedLogger,
-			{ eventName: "InstantiateRuntime" },
-			async () => runtimeFactory.instantiateRuntime(this, existing),
-		);
-		this.lifecycleEvents.emit("runtimeInstantiated");
-	}
-
-	private attachListener() {
-		this.container.once("attaching", () => {
-			this.runtime.setAttachState(AttachState.Attaching);
-		});
-		this.container.once("attached", () => {
-			this.runtime.setAttachState(AttachState.Attached);
-		});
-	}
-
-	private async loadCodeModule(codeDetails: IFluidCodeDetails): Promise<IFluidModuleWithDetails> {
-		const loadCodeResult = await PerformanceEvent.timedExecAsync(
-			this.taggedLogger,
-			{ eventName: "CodeLoad" },
-			async () => this.codeLoader.load(codeDetails),
-		);
-
-		if ("module" in loadCodeResult) {
-			const { module, details } = loadCodeResult;
-			return {
-				module,
-				details: details ?? codeDetails,
-			};
-		} else {
-			// If "module" is not in the result, we are using a legacy ICodeLoader.  Fix the result up with details.
-			// Once usage drops to 0 we can remove this compat path.
-			this.taggedLogger.sendTelemetryEvent({ eventName: "LegacyCodeLoader" });
-			return loadCodeResult;
-		}
+		return this._getAttachState();
 	}
-	// #endregion
 }

package/src/containerStorageAdapter.ts

@@ -3,7 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { IDisposable, ITelemetryLogger } from "@fluidframework/common-definitions";
+import { IDisposable } from "@fluidframework/core-interfaces";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import { assert, bufferToString, stringToBuffer } from "@fluidframework/common-utils";
 import { ISnapshotTreeWithBlobContents } from "@fluidframework/container-definitions";
 import {
@@ -27,7 +28,6 @@ import { RetriableDocumentStorageService } from "./retriableDocumentStorageServi
 
 /**
  * Stringified blobs from a summary/snapshot tree.
- * @deprecated this is an internal interface and will not longer be exported in future versions
  * @internal
  */
 export interface ISerializableBlobContents {
@@ -60,7 +60,7 @@ export class ContainerStorageAdapter implements IDocumentStorageService, IDispos
 	 */
 	public constructor(
 		detachedBlobStorage: IDetachedBlobStorage | undefined,
-		private readonly logger: ITelemetryLogger,
+		private readonly logger: ITelemetryLoggerExt,
 		/**
 		 * ArrayBufferLikes or utf8 encoded strings, containing blobs from a snapshot
 		 */
@@ -183,7 +183,7 @@ export class ContainerStorageAdapter implements IDocumentStorageService, IDispos
 class BlobOnlyStorage implements IDocumentStorageService {
 	constructor(
 		private readonly detachedStorage: IDetachedBlobStorage | undefined,
-		private readonly logger: ITelemetryLogger,
+		private readonly logger: ITelemetryLoggerExt,
 	) {}
 
 	public async createBlob(content: ArrayBufferLike): Promise<ICreateBlobResponse> {
@@ -229,11 +229,13 @@ class BlobOnlyStorage implements IDocumentStorageService {
 	}
 }
 
-// runtime will write a tree to the summary containing only "attachment" type entries
-// which reference attachment blobs by ID. However, some drivers do not support this type
-// and will convert them to "blob" type entries. We want to avoid saving these to reduce
-// the size of stashed change blobs.
+// runtime will write a tree to the summary containing "attachment" type entries
+// which reference attachment blobs by ID, along with a blob containing the blob redirect table.
+// However, some drivers do not support the "attachment" type and will convert them to "blob" type
+// entries. We want to avoid saving these to reduce the size of stashed change blobs, but we
+// need to make sure the blob redirect table is saved.
 const blobsTreeName = ".blobs";
+const redirectTableBlobName = ".redirectTable";
 
 /**
  * Get blob contents of a snapshot tree from storage (or, ideally, cache)
@@ -255,7 +257,9 @@ async function getBlobContentsFromTreeCore(
 ) {
 	const treePs: Promise<any>[] = [];
 	for (const [key, subTree] of Object.entries(tree.trees)) {
-		if (!root || key !== blobsTreeName) {
+		if (root && key === blobsTreeName) {
+			treePs.push(getBlobManagerTreeFromTree(subTree, blobs, storage));
+		} else {
 			treePs.push(getBlobContentsFromTreeCore(subTree, blobs, storage, false));
 		}
 	}
@@ -267,6 +271,18 @@ async function getBlobContentsFromTreeCore(
 	return Promise.all(treePs);
 }
 
+// save redirect table from .blobs tree but nothing else
+async function getBlobManagerTreeFromTree(
+	tree: ISnapshotTree,
+	blobs: ISerializableBlobContents,
+	storage: IDocumentStorageService,
+) {
+	const id = tree.blobs[redirectTableBlobName];
+	const blob = await storage.readBlob(id);
+	// ArrayBufferLike will not survive JSON.stringify()
+	blobs[id] = bufferToString(blob, "utf8");
+}
+
 /**
  * Extract blob contents from a snapshot tree with blob contents
  */
@@ -284,7 +300,9 @@ function getBlobContentsFromTreeWithBlobContentsCore(
 	root = true,
 ) {
 	for (const [key, subTree] of Object.entries(tree.trees)) {
-		if (!root || key !== blobsTreeName) {
+		if (root && key === blobsTreeName) {
+			getBlobManagerTreeFromTreeWithBlobContents(subTree, blobs);
+		} else {
 			getBlobContentsFromTreeWithBlobContentsCore(subTree, blobs, false);
 		}
 	}
@@ -295,3 +313,15 @@ function getBlobContentsFromTreeWithBlobContentsCore(
 		blobs[id] = bufferToString(blob, "utf8");
 	}
 }
+
+// save redirect table from .blobs tree but nothing else
+function getBlobManagerTreeFromTreeWithBlobContents(
+	tree: ISnapshotTreeWithBlobContents,
+	blobs: ISerializableBlobContents,
+) {
+	const id = tree.blobs[redirectTableBlobName];
+	const blob = tree.blobsContents[id];
+	assert(blob !== undefined, 0x70f /* Blob must be present in blobsContents */);
+	// ArrayBufferLike will not survive JSON.stringify()
+	blobs[id] = bufferToString(blob, "utf8");
+}

package/src/contracts.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryProperties } from "@fluidframework/common-definitions";
+import { ITelemetryProperties } from "@fluidframework/core-interfaces";
 import {
 	IDeltaQueue,
 	ReadOnlyInfo,
@@ -148,8 +148,6 @@ export interface IConnectionManagerFactoryArgs {
 
 	/**
 	 * Called whenever ping/pong messages are roundtripped on connection.
-	 *
-	 * @deprecated No replacement API intended.
 	 */
 	readonly pongHandler: (latency: number) => void;
 
@@ -167,6 +165,16 @@ export interface IConnectionManagerFactoryArgs {
 	 * `undefined` indicates that user permissions are not yet known.
 	 */
 	readonly readonlyChangeHandler: (readonly?: boolean) => void;
+
+	/**
+	 * Called whenever we try to start establishing a new connection.
+	 */
+	readonly establishConnectionHandler: (reason: string) => void;
+
+	/**
+	 * Called whenever we cancel the connection in progress.
+	 */
+	readonly cancelConnectionHandler: (reason: string) => void;
 }
 
 /**