@fluidframework/container-loader 2.0.0-internal.4.3.0 → 2.0.0-internal.5.0.0

package/src/containerContext.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLogger } from "@fluidframework/common-definitions";
+import { ITelemetryLoggerExt, PerformanceEvent } from "@fluidframework/telemetry-utils";
 import { assert, LazyPromise, TypedEventEmitter } from "@fluidframework/common-utils";
 import {
 	IAudience,
@@ -25,7 +25,6 @@ import {
 } from "@fluidframework/container-definitions";
 import { IRequest, IResponse, FluidObject } from "@fluidframework/core-interfaces";
 import { IDocumentStorageService } from "@fluidframework/driver-definitions";
-import { isFluidResolvedUrl } from "@fluidframework/driver-utils";
 import {
 	IClientConfiguration,
 	IClientDetails,
@@ -40,7 +39,6 @@ import {
 	MessageType,
 	ISummaryContent,
 } from "@fluidframework/protocol-definitions";
-import { PerformanceEvent } from "@fluidframework/telemetry-utils";
 import { UsageError } from "@fluidframework/container-utils";
 import { Container } from "./container";
 
@@ -101,7 +99,7 @@ export class ContainerContext implements IContainerContext {
 		return context;
 	}
 
-	public readonly taggedLogger: ITelemetryLogger;
+	public readonly taggedLogger: ITelemetryLoggerExt;
 	public readonly supportedFeatures: ReadonlyMap<string, unknown>;
 
 	public get clientId(): string | undefined {
@@ -112,11 +110,7 @@ export class ContainerContext implements IContainerContext {
 	 * 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 "";
+		return this.container.resolvedUrl?.id ?? "";
 	}
 
 	public get clientDetails(): IClientDetails {

package/src/containerStorageAdapter.ts

@@ -3,7 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { IDisposable, ITelemetryLogger } from "@fluidframework/common-definitions";
+import { IDisposable } from "@fluidframework/common-definitions";
+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> {

package/src/contracts.ts

@@ -20,7 +20,7 @@ import {
 	IClientDetails,
 	ISignalMessage,
 } from "@fluidframework/protocol-definitions";
-import { IContainerPackageInfo } from "@fluidframework/driver-definitions";
+import { IAnyDriverError, IContainerPackageInfo } from "@fluidframework/driver-definitions";
 
 export enum ReconnectMode {
 	Never = "Never",
@@ -95,7 +95,7 @@ export interface IConnectionManager {
 	/**
 	 * Initiates connection to relay service (noop if already connected).
 	 */
-	connect(connectionMode?: ConnectionMode): void;
+	connect(reason: string, connectionMode?: ConnectionMode): void;
 
 	/**
 	 * Disposed connection manager
@@ -139,7 +139,7 @@ export interface IConnectionManagerFactoryArgs {
 	/**
 	 * Called whenever connection to relay service is lost.
 	 */
-	readonly disconnectHandler: (reason: string) => void;
+	readonly disconnectHandler: (reason: string, error?: IAnyDriverError) => void;
 
 	/**
 	 * Called whenever new connection to rely service is established

package/src/deltaManager.ts

@@ -6,7 +6,6 @@
 import { default as AbortController } from "abort-controller";
 import { v4 as uuid } from "uuid";
 import {
-	ITelemetryLogger,
 	IEventProvider,
 	ITelemetryProperties,
 	ITelemetryErrorEvent,
@@ -21,11 +20,17 @@ import {
 	IConnectionDetailsInternal,
 } from "@fluidframework/container-definitions";
 import { assert, TypedEventEmitter } from "@fluidframework/common-utils";
-import { normalizeError, logIfFalse, safeRaiseEvent } from "@fluidframework/telemetry-utils";
+import {
+	normalizeError,
+	logIfFalse,
+	safeRaiseEvent,
+	ITelemetryLoggerExt,
+} from "@fluidframework/telemetry-utils";
 import {
 	IDocumentDeltaStorageService,
 	IDocumentService,
 	DriverErrorType,
+	IAnyDriverError,
 } from "@fluidframework/driver-definitions";
 import {
 	IDocumentMessage,
@@ -339,7 +344,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 
 	constructor(
 		private readonly serviceProvider: () => IDocumentService | undefined,
-		private readonly logger: ITelemetryLogger,
+		private readonly logger: ITelemetryLoggerExt,
 		private readonly _active: () => boolean,
 		createConnectionManager: (props: IConnectionManagerFactoryArgs) => TConnectionManager,
 	) {
@@ -357,7 +362,8 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 			reconnectionDelayHandler: (delayMs: number, error: unknown) =>
 				this.emitDelayInfo(this.deltaStreamDelayId, delayMs, error),
 			closeHandler: (error: any) => this.close(error),
-			disconnectHandler: (reason: string) => this.disconnectHandler(reason),
+			disconnectHandler: (reason: string, error?: IAnyDriverError) =>
+				this.disconnectHandler(reason, error),
 			connectHandler: (connection: IConnectionDetailsInternal) =>
 				this.connectHandler(connection),
 			pongHandler: (latency: number) => this.emit("pong", latency),
@@ -539,7 +545,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 			this.fetchMissingDeltas(args.reason);
 		}
 
-		this.connectionManager.connect(args.mode);
+		this.connectionManager.connect(args.reason, args.mode);
 	}
 
 	private async getDeltas(
@@ -676,7 +682,6 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 			this.disposeInternal(error);
 		} else {
 			this.emit("closed", error);
-			this.disposeInternal(error); // ! TODO: remove this call when Container close no longer disposes
 		}
 	}
 
@@ -700,9 +705,9 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		}
 	}
 
-	private disconnectHandler(reason: string) {
+	private disconnectHandler(reason: string, error?: IAnyDriverError) {
 		this.messageBuffer.length = 0;
-		this.emit("disconnect", reason);
+		this.emit("disconnect", reason, error);
 	}
 
 	/**

package/src/index.ts

@@ -4,14 +4,7 @@
  */
 
 export { ConnectionState } from "./connectionState";
-export {
-	IContainerConfig,
-	IContainerExperimental,
-	IContainerLoadOptions,
-	IPendingContainerState,
-	waitContainerToCatchUp,
-} from "./container";
-export { ISerializableBlobContents } from "./containerStorageAdapter";
+export { IContainerExperimental, waitContainerToCatchUp } from "./container";
 export {
 	ICodeDetailsLoader,
 	IDetachedBlobStorage,

package/src/loader.ts

@@ -4,7 +4,18 @@
  */
 
 import { v4 as uuid } from "uuid";
-import { ITelemetryBaseLogger, ITelemetryLogger } from "@fluidframework/common-definitions";
+import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
+import {
+	ITelemetryLoggerExt,
+	ChildLogger,
+	DebugLogger,
+	IConfigProviderBase,
+	loggerToMonitoringContext,
+	mixinMonitoringContext,
+	MonitoringContext,
+	PerformanceEvent,
+	sessionStorageConfigProvider,
+} from "@fluidframework/telemetry-utils";
 import {
 	FluidObject,
 	IFluidRouter,
@@ -22,24 +33,13 @@ import {
 	IProvideFluidCodeDetailsComparer,
 	IFluidCodeDetails,
 } from "@fluidframework/container-definitions";
-import {
-	ChildLogger,
-	DebugLogger,
-	IConfigProviderBase,
-	loggerToMonitoringContext,
-	mixinMonitoringContext,
-	MonitoringContext,
-	PerformanceEvent,
-	sessionStorageConfigProvider,
-} from "@fluidframework/telemetry-utils";
 import {
 	IDocumentServiceFactory,
 	IDocumentStorageService,
-	IFluidResolvedUrl,
+	IResolvedUrl,
 	IUrlResolver,
 } from "@fluidframework/driver-definitions";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
-import { ensureFluidResolvedUrl } from "@fluidframework/driver-utils";
 import { Container, IPendingContainerState } from "./container";
 import { IParsedUrl, parseUrl } from "./utils";
 import { pkgVersion } from "./packageVersion";
@@ -53,8 +53,15 @@ function canUseCache(request: IRequest): boolean {
 	return request.headers[LoaderHeader.cache] !== false;
 }
 
+function ensureResolvedUrlDefined(
+	resolved: IResolvedUrl | undefined,
+): asserts resolved is IResolvedUrl {
+	if (resolved === undefined) {
+		throw new Error(`Object is not a IResolveUrl.`);
+	}
+}
 /**
- * @deprecated - In the next release RelativeLoader will no longer be exported. It is an internal class that should not be used directly.
+ * @internal
  */
 export class RelativeLoader implements ILoader {
 	constructor(
@@ -71,15 +78,19 @@ export class RelativeLoader implements ILoader {
 			if (canUseCache(request)) {
 				return this.container;
 			} else {
-				const resolvedUrl = this.container.resolvedUrl;
-				ensureFluidResolvedUrl(resolvedUrl);
-				const container = await Container.load(this.loader as Loader, {
-					canReconnect: request.headers?.[LoaderHeader.reconnect],
-					clientDetailsOverride: request.headers?.[LoaderHeader.clientDetails],
-					resolvedUrl: { ...resolvedUrl },
-					version: request.headers?.[LoaderHeader.version] ?? undefined,
-					loadMode: request.headers?.[LoaderHeader.loadMode],
-				});
+				ensureResolvedUrlDefined(this.container.resolvedUrl);
+				const container = await Container.clone(
+					this.container,
+					{
+						resolvedUrl: { ...this.container.resolvedUrl },
+						version: request.headers?.[LoaderHeader.version] ?? undefined,
+						loadMode: request.headers?.[LoaderHeader.loadMode],
+					},
+					{
+						canReconnect: request.headers?.[LoaderHeader.reconnect],
+						clientDetailsOverride: request.headers?.[LoaderHeader.clientDetails],
+					},
+				);
 				return container;
 			}
 		}
@@ -237,12 +248,18 @@ export interface ILoaderServices {
 	/**
 	 * The logger downstream consumers should construct their loggers from
 	 */
-	readonly subLogger: ITelemetryLogger;
+	readonly subLogger: ITelemetryLoggerExt;
 
 	/**
 	 * Blobs storage for detached containers.
 	 */
 	readonly detachedBlobStorage?: IDetachedBlobStorage;
+
+	/**
+	 * Optional property for allowing the container to use a custom
+	 * protocol implementation for handling the quorum and/or the audience.
+	 */
+	readonly protocolHandlerBuilder?: ProtocolHandlerBuilder;
 }
 
 /**
@@ -266,7 +283,7 @@ export async function requestResolvedObjectFromContainer(
 	container: IContainer,
 	headers?: IRequestHeader,
 ): Promise<IResponse> {
-	ensureFluidResolvedUrl(container.resolvedUrl);
+	ensureResolvedUrlDefined(container.resolvedUrl);
 	const parsedUrl = parseUrl(container.resolvedUrl.url);
 
 	if (parsedUrl === undefined) {
@@ -289,7 +306,6 @@ export class Loader implements IHostLoader {
 	private readonly containers = new Map<string, Promise<Container>>();
 	public readonly services: ILoaderServices;
 	private readonly mc: MonitoringContext;
-	private readonly protocolHandlerBuilder: ProtocolHandlerBuilder | undefined;
 
 	constructor(loaderProps: ILoaderProps) {
 		const scope: FluidObject<ILoader> = { ...loaderProps.scope };
@@ -310,16 +326,12 @@ export class Loader implements IHostLoader {
 		);
 
 		this.services = {
-			urlResolver: loaderProps.urlResolver,
-			documentServiceFactory: loaderProps.documentServiceFactory,
-			codeLoader: loaderProps.codeLoader,
-			options: loaderProps.options ?? {},
+			...loaderProps,
 			scope,
 			subLogger: subMc.logger,
-			detachedBlobStorage: loaderProps.detachedBlobStorage,
+			options: loaderProps.options ?? {},
 		};
 		this.mc = loggerToMonitoringContext(ChildLogger.create(this.services.subLogger, "Loader"));
-		this.protocolHandlerBuilder = loaderProps.protocolHandlerBuilder;
 	}
 
 	public get IFluidRouter(): IFluidRouter {
@@ -327,15 +339,11 @@ export class Loader implements IHostLoader {
 	}
 
 	public async createDetachedContainer(codeDetails: IFluidCodeDetails): Promise<IContainer> {
-		const container = await Container.createDetached(
-			this,
-			codeDetails,
-			this.protocolHandlerBuilder,
-		);
+		const container = await Container.createDetached(this.services, codeDetails);
 
 		if (this.cachingEnabled) {
 			container.once("attached", () => {
-				ensureFluidResolvedUrl(container.resolvedUrl);
+				ensureResolvedUrlDefined(container.resolvedUrl);
 				const parsedUrl = parseUrl(container.resolvedUrl.url);
 				if (parsedUrl !== undefined) {
 					this.addToContainerCache(parsedUrl.id, Promise.resolve(container));
@@ -347,7 +355,7 @@ export class Loader implements IHostLoader {
 	}
 
 	public async rehydrateDetachedContainerFromSnapshot(snapshot: string): Promise<IContainer> {
-		return Container.rehydrateDetachedFromSnapshot(this, snapshot, this.protocolHandlerBuilder);
+		return Container.rehydrateDetachedFromSnapshot(this.services, snapshot);
 	}
 
 	public async resolve(request: IRequest, pendingLocalState?: string): Promise<IContainer> {
@@ -404,7 +412,7 @@ export class Loader implements IHostLoader {
 		pendingLocalState?: IPendingContainerState,
 	): Promise<{ container: Container; parsed: IParsedUrl }> {
 		const resolvedAsFluid = await this.services.urlResolver.resolve(request);
-		ensureFluidResolvedUrl(resolvedAsFluid);
+		ensureResolvedUrlDefined(resolvedAsFluid);
 
 		// Parse URL into data stores
 		const parsed = parseUrl(resolvedAsFluid.url);
@@ -489,20 +497,21 @@ export class Loader implements IHostLoader {
 
 	private async loadContainer(
 		request: IRequest,
-		resolved: IFluidResolvedUrl,
+		resolvedUrl: IResolvedUrl,
 		pendingLocalState?: IPendingContainerState,
 	): Promise<Container> {
 		return Container.load(
-			this,
 			{
-				canReconnect: request.headers?.[LoaderHeader.reconnect],
-				clientDetailsOverride: request.headers?.[LoaderHeader.clientDetails],
-				resolvedUrl: resolved,
+				resolvedUrl,
 				version: request.headers?.[LoaderHeader.version] ?? undefined,
 				loadMode: request.headers?.[LoaderHeader.loadMode],
+				pendingLocalState,
+			},
+			{
+				canReconnect: request.headers?.[LoaderHeader.reconnect],
+				clientDetailsOverride: request.headers?.[LoaderHeader.clientDetails],
+				...this.services,
 			},
-			pendingLocalState,
-			this.protocolHandlerBuilder,
 		);
 	}
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-loader";
-export const pkgVersion = "2.0.0-internal.4.3.0";
+export const pkgVersion = "2.0.0-internal.5.0.0";

package/src/retriableDocumentStorageService.ts

@@ -18,14 +18,15 @@ import {
 	ISummaryTree,
 	IVersion,
 } from "@fluidframework/protocol-definitions";
-import { IDisposable, ITelemetryLogger } from "@fluidframework/common-definitions";
+import { IDisposable } from "@fluidframework/common-definitions";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import { runWithRetry } from "@fluidframework/driver-utils";
 
 export class RetriableDocumentStorageService implements IDocumentStorageService, IDisposable {
 	private _disposed = false;
 	constructor(
 		private readonly internalStorageService: IDocumentStorageService,
-		private readonly logger: ITelemetryLogger,
+		private readonly logger: ITelemetryLoggerExt,
 	) {}
 
 	public get policies(): IDocumentStorageServicePolicies | undefined {