@fluidframework/container-loader 0.59.2000-63294 → 0.59.3000-66610

package/src/container.ts

@@ -89,6 +89,7 @@ import {
     normalizeError,
     MonitoringContext,
     loggerToMonitoringContext,
+    wrapError,
 } from "@fluidframework/telemetry-utils";
 import { Audience } from "./audience";
 import { ContainerContext } from "./containerContext";
@@ -101,8 +102,8 @@ import { ConnectionStateHandler, ILocalSequencedClient } from "./connectionState
 import { RetriableDocumentStorageService } from "./retriableDocumentStorageService";
 import { ProtocolTreeStorageService } from "./protocolTreeDocumentStorageService";
 import { BlobOnlyStorage, ContainerStorageAdapter } from "./containerStorageAdapter";
-import { getSnapshotTreeFromSerializedContainer } from "./utils";
-import { QuorumProxy } from "./quorum";
+import { getProtocolSnapshotTree, getSnapshotTreeFromSerializedContainer } from "./utils";
+import { initQuorumValuesFromCodeDetails, getCodeDetailsFromQuorumValues, QuorumProxy } from "./quorum";
 import { CollabWindowTracker } from "./collabWindowTracker";
 import { ConnectionManager } from "./connectionManager";
 
@@ -166,17 +167,27 @@ export enum ConnectionState {
  * @returns true: container is up to date, it processed all the ops that were know at the time of first connection
  *          false: storage does not provide indication of how far the client is. Container processed
  *          all the ops known to it, but it maybe still behind.
+ * @throws an error beginning with `"Container closed"` if the container is closed before it catches up.
  */
 export async function waitContainerToCatchUp(container: IContainer) {
     // Make sure we stop waiting if container is closed.
     if (container.closed) {
-        throw new Error("Container is closed");
+        throw new UsageError("waitContainerToCatchUp: Container closed");
     }
 
     return new Promise<boolean>((resolve, reject) => {
         const deltaManager = container.deltaManager;
 
-        container.on("closed", reject);
+        const closedCallback = (err?: ICriticalContainerError | undefined) => {
+            container.off("closed", closedCallback);
+            const baseMessage = "Container closed while waiting to catch up";
+            reject(
+                err !== undefined
+                    ? wrapError(err, (innerMessage) => new GenericError(`${baseMessage}: ${innerMessage}`))
+                    : new GenericError(baseMessage),
+            );
+        };
+        container.on("closed", closedCallback);
 
         const waitForOps = () => {
             assert(container.connectionState !== ConnectionState.Disconnected,
@@ -187,11 +198,13 @@ export async function waitContainerToCatchUp(container: IContainer) {
             assert(deltaManager.lastSequenceNumber <= connectionOpSeqNumber,
                 0x266 /* "lastKnownSeqNumber should never be below last processed sequence number" */);
             if (deltaManager.lastSequenceNumber === connectionOpSeqNumber) {
+                container.off("closed", closedCallback);
                 resolve(hasCheckpointSequenceNumber);
                 return;
             }
             const callbackOps = (message: ISequencedDocumentMessage) => {
                 if (connectionOpSeqNumber <= message.sequenceNumber) {
+                    container.off("closed", closedCallback);
                     resolve(hasCheckpointSequenceNumber);
                     deltaManager.off("op", callbackOps);
                 }
@@ -517,11 +530,11 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         return this._dirtyContainer;
     }
 
-    private get serviceFactory() {return this.loader.services.documentServiceFactory;}
-    private get urlResolver() {return this.loader.services.urlResolver;}
+    private get serviceFactory() { return this.loader.services.documentServiceFactory; }
+    private get urlResolver() { return this.loader.services.urlResolver; }
     public readonly options: ILoaderOptions;
-    private get scope() { return this.loader.services.scope;}
-    private get codeLoader() { return this.loader.services.codeLoader;}
+    private get scope() { return this.loader.services.scope; }
+    private get codeLoader() { return this.loader.services.codeLoader; }
 
     constructor(
         private readonly loader: Loader,
@@ -726,7 +739,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                 // Driver need to ensure all caches are cleared on critical errors
                 this.service?.dispose(error);
             } catch (exception) {
-                this.mc.logger.sendErrorEvent({ eventName: "ContainerCloseException"}, exception);
+                this.mc.logger.sendErrorEvent({ eventName: "ContainerCloseException" }, exception);
             }
 
             this.mc.logger.sendTelemetryEvent(
@@ -885,7 +898,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                 if (!this.closed) {
                     this.resumeInternal({ fetchOpsFromStorage: false, reason: "createDetached" });
                 }
-            } catch(error) {
+            } catch (error) {
                 // add resolved URL on error object so that host has the ability to find this document and delete it
                 const newError = normalizeError(error);
                 const resolvedUrl = this.resolvedUrl;
@@ -956,11 +969,9 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
     public connect() {
         if (this.closed) {
             throw new UsageError(`The Container is closed and cannot be connected`);
-        }
-        else if (this._attachState !== AttachState.Attached) {
+        } else if (this._attachState !== AttachState.Attached) {
             throw new UsageError(`The Container is not attached and cannot be connected`);
-        }
-        else if (!this.connected) {
+        } else if (!this.connected) {
             // Note: no need to fetch ops as we do it preemptively as part of DeltaManager.attachOpHandler().
             // If there is gap, we will learn about it once connected, but the gap should be small (if any),
             // assuming that connect() is called quickly after initial container boot.
@@ -984,8 +995,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
     public disconnect() {
         if (this.closed) {
             throw new UsageError(`The Container is closed and cannot be disconnected`);
-        }
-        else {
+        } else {
             this.disconnectInternal();
         }
     }
@@ -1053,8 +1063,8 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         }
 
         return this.protocolHandler.quorum.propose("code", codeDetails)
-            .then(()=>true)
-            .catch(()=>false);
+            .then(() => true)
+            .catch(() => false);
     }
 
     private async processCodeProposal(): Promise<void> {
@@ -1166,7 +1176,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         // ...load in the existing quorum
         // Initialize the protocol handler
         this._protocolHandler =
-            await this.loadAndInitializeProtocolState(attributes, this.storageService, snapshot);
+            await this.initializeProtocolStateFromSnapshot(attributes, this.storageService, snapshot);
 
         const codeDetails = this.getCodeDetailsFromQuorum();
         await this.instantiateContext(
@@ -1233,27 +1243,16 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
             minimumSequenceNumber: 0,
         };
 
-        // Seed the base quorum to be an empty list with a code quorum set
-        const committedCodeProposal: ICommittedProposal = {
-            key: "code",
-            value: source,
-            approvalSequenceNumber: 0,
-            commitSequenceNumber: 0,
-            sequenceNumber: 0,
-        };
-
-        const members: [string, ISequencedClient][] = [];
-        const proposals: [number, ISequencedProposal, string[]][] = [];
-        const values: [string, ICommittedProposal][] = [["code", committedCodeProposal]];
-
         await this.attachDeltaManagerOpHandler(attributes);
 
         // Need to just seed the source data in the code quorum. Quorum itself is empty
+        const qValues = initQuorumValuesFromCodeDetails(source);
         this._protocolHandler = await this.initializeProtocolState(
             attributes,
-            members,
-            proposals,
-            values);
+            [], // members
+            [], // proposals
+            qValues,
+        );
 
         // The load context - given we seeded the quorum - will be great
         await this.instantiateContextDetached(
@@ -1275,13 +1274,22 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         const snapshotTree = getSnapshotTreeFromSerializedContainer(detachedContainerSnapshot);
         this._storage.loadSnapshotForRehydratingContainer(snapshotTree);
         const attributes = await this.getDocumentAttributes(this._storage, snapshotTree);
-        assert(attributes.sequenceNumber === 0, 0x0db /* "Seq number in detached container should be 0!!" */);
+
         await this.attachDeltaManagerOpHandler(attributes);
 
-        // ...load in the existing quorum
         // Initialize the protocol handler
+        const baseTree = getProtocolSnapshotTree(snapshotTree);
+        const qValues = await readAndParse<[string, ICommittedProposal][]>(
+            this._storage,
+            baseTree.blobs.quorumValues,
+        );
+        const codeDetails = getCodeDetailsFromQuorumValues(qValues);
         this._protocolHandler =
-            await this.loadAndInitializeProtocolState(attributes, this._storage, snapshotTree);
+            await this.initializeProtocolState(
+                attributes,
+                [], // members
+                [], // proposals
+                codeDetails !== undefined ? initQuorumValuesFromCodeDetails(codeDetails) : []);
 
         await this.instantiateContextDetached(
             true, // existing
@@ -1304,10 +1312,10 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         this._storageService =
             new RetriableDocumentStorageService(storageService, this.mc.logger);
 
-        if(this.options.summarizeProtocolTree === true) {
-            this.mc.logger.sendTelemetryEvent({eventName:"summarizeProtocolTreeEnabled"});
+        if (this.options.summarizeProtocolTree === true) {
+            this.mc.logger.sendTelemetryEvent({ eventName: "summarizeProtocolTreeEnabled" });
             this._storageService =
-                new ProtocolTreeStorageService(this._storageService, ()=>this.captureProtocolSummary());
+                new ProtocolTreeStorageService(this._storageService, () => this.captureProtocolSummary());
         }
 
         // ensure we did not lose that policy in the process of wrapping
@@ -1342,7 +1350,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         return attributes;
     }
 
-    private async loadAndInitializeProtocolState(
+    private async initializeProtocolStateFromSnapshot(
         attributes: IDocumentAttributes,
         storage: IDocumentStorageService,
         snapshot: ISnapshotTree | undefined,
@@ -1352,7 +1360,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         let values: [string, any][] = [];
 
         if (snapshot !== undefined) {
-            const baseTree = ".protocol" in snapshot.trees ? snapshot.trees[".protocol"] : snapshot;
+            const baseTree = getProtocolSnapshotTree(snapshot);
             [members, proposals, values] = await Promise.all([
                 readAndParse<[string, ISequencedClient][]>(storage, baseTree.blobs.quorumMembers),
                 readAndParse<[number, ISequencedProposal, string[]][]>(storage, baseTree.blobs.quorumProposals),
@@ -1561,8 +1569,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
 
     private async attachDeltaManagerOpHandler(
         attributes: IDocumentAttributes,
-        prefetchType?: "cached" | "all" | "none")
-    {
+        prefetchType?: "cached" | "all" | "none") {
         return this._deltaManager.attachOpHandler(
             attributes.minimumSequenceNumber,
             attributes.sequenceNumber,
@@ -1668,7 +1675,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                 // this can be removed once all clients send
                 // protocol tree by default
                 const summary = contents as ISummaryContent;
-                if(summary.details === undefined) {
+                if (summary.details === undefined) {
                     summary.details = {};
                 }
                 summary.details.includesProtocolTree =
@@ -1740,7 +1747,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
     private processSignal(message: ISignalMessage) {
         // No clientId indicates a system signal message.
         if (message.clientId === null) {
-            const innerContent = message.content as { content: any; type: string };
+            const innerContent = message.content as { content: any; type: string; };
             if (innerContent.type === MessageType.ClientJoin) {
                 const newClient = innerContent.content as ISignalClient;
                 this._audience.addMember(newClient.clientId, newClient.client);
@@ -1760,8 +1767,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
      * @returns The snapshot requested, or the latest snapshot if no version was specified, plus version ID
      */
     private async fetchSnapshotTree(specifiedVersion: string | undefined):
-        Promise<{snapshot?: ISnapshotTree; versionId?: string}>
-    {
+        Promise<{ snapshot?: ISnapshotTree; versionId?: string; }> {
         const version = await this.getVersion(specifiedVersion ?? null);
 
         if (version === undefined && specifiedVersion !== undefined) {

package/src/containerStorageAdapter.ts

@@ -25,7 +25,7 @@ import { ISnapshotTreeWithBlobContents } from "./utils";
  * container attach state.
  */
 export class ContainerStorageAdapter implements IDocumentStorageService {
-    private readonly blobContents: {[id: string]: ArrayBufferLike} = {};
+    private readonly blobContents: { [id: string]: ArrayBufferLike; } = {};
     constructor(private readonly storageGetter: () => IDocumentStorageService) {}
 
     public loadSnapshotForRehydratingContainer(snapshotTree: ISnapshotTreeWithBlobContents) {
@@ -33,10 +33,10 @@ export class ContainerStorageAdapter implements IDocumentStorageService {
     }
 
     private getBlobContents(snapshotTree: ISnapshotTreeWithBlobContents) {
-        for(const [id, value] of Object.entries(snapshotTree.blobsContents)) {
+        for (const [id, value] of Object.entries(snapshotTree.blobsContents)) {
             this.blobContents[id] = value;
         }
-        for(const [_, tree] of Object.entries(snapshotTree.trees)) {
+        for (const [_, tree] of Object.entries(snapshotTree.trees)) {
             this.getBlobContents(tree);
         }
     }
@@ -46,7 +46,7 @@ export class ContainerStorageAdapter implements IDocumentStorageService {
         // and storage is always present in >=0.41.
         try {
             return this.storageGetter().policies;
-        } catch(e) {}
+        } catch (e) {}
         return undefined;
     }
 

package/src/contracts.ts

@@ -112,13 +112,13 @@ export interface IConnectionManagerFactoryArgs {
      * Called by connection manager for each incomming op. Some ops maybe delivered before
      * connectHandler is called (initial ops on socket connection)
      */
-    readonly incomingOpHandler: (messages: ISequencedDocumentMessage[], reason: string) => void,
+    readonly incomingOpHandler: (messages: ISequencedDocumentMessage[], reason: string) => void;
 
     /**
      * Called by connection manager for each incoming signals.
      * Maybe called before connectHandler is called (initial signals on socket connection)
      */
-    readonly signalHandler: (message: ISignalMessage) => void,
+    readonly signalHandler: (message: ISignalMessage) => void;
 
     /**
      * Called when connection manager experiences delay in connecting to relay service.
@@ -126,28 +126,28 @@ export interface IConnectionManagerFactoryArgs {
      * Can be called many times while not connected.
      * Situation is considered resolved when connection is established and connectHandler is called.
      */
-    readonly reconnectionDelayHandler: (delayMs: number, error: unknown) => void,
+    readonly reconnectionDelayHandler: (delayMs: number, error: unknown) => void;
 
     /**
      * Called by connection manager whwnever critical error happens and container should be closed.
      * Expects dispose() call in respose to this call.
      */
-    readonly closeHandler: (error?: any) => void,
+    readonly closeHandler: (error?: any) => void;
 
     /**
      * Called whenever connection to relay service is lost.
      */
-    readonly disconnectHandler: (reason: string) => void,
+    readonly disconnectHandler: (reason: string) => void;
 
     /**
      * Called whenever new connection to rely service is established
      */
-    readonly connectHandler: (connection: IConnectionDetails) => void,
+    readonly connectHandler: (connection: IConnectionDetails) => void;
 
     /**
      * Called whenever ping/pong messages are roundtripped on connection.
      */
-    readonly pongHandler: (latency: number) => void,
+    readonly pongHandler: (latency: number) => void;
 
     /**
      * Called whenever connection type changes from writable to read-only or vice versa.
@@ -156,7 +156,7 @@ export interface IConnectionManagerFactoryArgs {
      * This should not be confused with "read" / "write"connection mode which is internal
      * optimization.
      */
-    readonly readonlyChangeHandler: (readonly?: boolean) => void,
+    readonly readonlyChangeHandler: (readonly?: boolean) => void;
 }
 
 /**

package/src/deltaManager.ts

@@ -77,8 +77,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
     extends TypedEventEmitter<IDeltaManagerInternalEvents>
     implements
     IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
-    IEventProvider<IDeltaManagerInternalEvents>
-{
+    IEventProvider<IDeltaManagerInternalEvents> {
     public readonly connectionManager: TConnectionManager;
 
     public get active(): boolean { return this._active(); }
@@ -268,7 +267,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
     ) {
         super();
         const props: IConnectionManagerFactoryArgs = {
-            incomingOpHandler:(messages: ISequencedDocumentMessage[], reason: string) =>
+            incomingOpHandler: (messages: ISequencedDocumentMessage[], reason: string) =>
                 this.enqueueMessages(messages, reason),
             signalHandler: (message: ISignalMessage) => this._inboundSignal.push(message),
             reconnectionDelayHandler: (delayMs: number, error: unknown) =>
@@ -440,8 +439,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
         from: number, // inclusive
         to: number | undefined, // exclusive
         callback: (messages: ISequencedDocumentMessage[]) => void,
-        cacheOnly: boolean)
-    {
+        cacheOnly: boolean) {
         const docService = this.serviceProvider();
         if (docService === undefined) {
             throw new Error("Delta manager is not attached");
@@ -820,8 +818,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
     private async fetchMissingDeltasCore(
         reason: string,
         cacheOnly: boolean,
-        to?: number)
-    {
+        to?: number) {
         // Exit out early if we're already fetching deltas
         if (this.fetchReason !== undefined) {
             return;
@@ -865,7 +862,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
                 },
                 cacheOnly);
         } catch (error) {
-            this.logger.sendErrorEvent({eventName: "GetDeltas_Exception"}, error);
+            this.logger.sendErrorEvent({ eventName: "GetDeltas_Exception" }, error);
             this.close(normalizeError(error));
         } finally {
             this.refreshDelayInfo(this.deltaStorageDelayId);

package/src/deltaQueue.ts

@@ -7,16 +7,14 @@ import { IDeltaQueue, IDeltaQueueEvents } from "@fluidframework/container-defini
 import { assert, performance, Deferred, TypedEventEmitter } from "@fluidframework/common-utils";
 import Deque from "double-ended-queue";
 
-export interface IDeltaQueueWriter<T>
-{
+export interface IDeltaQueueWriter<T> {
     push(task: T): void;
     clear(): void;
 }
 
 export class DeltaQueue<T>
     extends TypedEventEmitter<IDeltaQueueEvents<T>>
-    implements IDeltaQueue<T>, IDeltaQueueWriter<T>
-{
+    implements IDeltaQueue<T>, IDeltaQueueWriter<T> {
     private isDisposed: boolean = false;
     private readonly q = new Deque<T>();
 

package/src/loader.ts

@@ -80,7 +80,7 @@ export class RelativeLoader implements ILoader {
                     {
                         canReconnect: request.headers?.[LoaderHeader.reconnect],
                         clientDetailsOverride: request.headers?.[LoaderHeader.clientDetails],
-                        resolvedUrl: {...resolvedUrl},
+                        resolvedUrl: { ...resolvedUrl },
                         version: request.headers?.[LoaderHeader.version] ?? undefined,
                         loadMode: request.headers?.[LoaderHeader.loadMode],
                     },
@@ -129,7 +129,7 @@ function createCachedResolver(resolver: IUrlResolver) {
 }
 
 export interface ILoaderOptions extends ILoaderOptions1{
-    summarizeProtocolTree?: boolean,
+    summarizeProtocolTree?: boolean;
 }
 
 /**
@@ -203,6 +203,7 @@ export interface ILoaderProps {
     /**
      * Proxy loader factories for loading containers via proxy in other contexts,
      * like web workers, or worker threads.
+     * @deprecated Not recommended for general use and will be removed in an upcoming release.
      */
     readonly proxyLoaderFactories?: Map<string, IProxyLoaderFactory>;
 
@@ -259,6 +260,7 @@ export interface ILoaderServices {
     /**
      * Proxy loader factories for loading containers via proxy in other contexts,
      * like web workers, or worker threads.
+     * @deprecated Not recommended for general use and will be removed in an upcoming release.
      */
     readonly proxyLoaderFactories: Map<string, IProxyLoaderFactory>;
 
@@ -393,7 +395,7 @@ export class Loader implements IHostLoader {
     private async resolveCore(
         request: IRequest,
         pendingLocalState?: IPendingLocalState,
-    ): Promise<{ container: Container; parsed: IParsedUrl }> {
+    ): Promise<{ container: Container; parsed: IParsedUrl; }> {
         const resolvedAsFluid = await this.services.urlResolver.resolve(request);
         ensureFluidResolvedUrl(resolvedAsFluid);
 

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-loader";
-export const pkgVersion = "0.59.2000-63294";
+export const pkgVersion = "0.59.3000-66610";

package/src/quorum.ts

@@ -2,8 +2,10 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { EventForwarder, doIfNotDisposed } from "@fluidframework/common-utils";
+import { assert, EventForwarder, doIfNotDisposed } from "@fluidframework/common-utils";
+import { IFluidCodeDetails } from "@fluidframework/core-interfaces";
 import {
+    ICommittedProposal,
     IQuorum,
     IQuorumEvents,
     ISequencedClient,
@@ -32,3 +34,26 @@ export class QuorumProxy extends EventForwarder<IQuorumEvents> implements IQuoru
         this.getMember = doIfNotDisposed(this, quorum.getMember.bind(quorum));
     }
 }
+
+export function getCodeDetailsFromQuorumValues(
+    quorumValues: [string, ICommittedProposal][],
+): IFluidCodeDetails {
+    const qValuesMap = new Map(quorumValues);
+    const proposal = qValuesMap.get("code");
+    assert(proposal !== undefined, 0x2dc /* "Cannot find code proposal" */);
+    return proposal?.value as IFluidCodeDetails;
+}
+
+export function initQuorumValuesFromCodeDetails(
+    source: IFluidCodeDetails,
+): [string, ICommittedProposal][] {
+    // Seed the base quorum to be an empty list with a code quorum set
+    const committedCodeProposal: ICommittedProposal = {
+        key: "code",
+        value: source,
+        approvalSequenceNumber: 0,
+        commitSequenceNumber: 0,
+        sequenceNumber: 0,
+    };
+    return [["code", committedCodeProposal]];
+}

package/src/utils.ts

@@ -16,8 +16,8 @@ import { ISummaryTree, ISnapshotTree, SummaryType } from "@fluidframework/protoc
 // This is used when we rehydrate a container from the snapshot. Here we put the blob contents
 // in separate property: blobContents.
 export interface ISnapshotTreeWithBlobContents extends ISnapshotTree {
-    blobsContents: {[path: string]: ArrayBufferLike},
-    trees: {[path: string]: ISnapshotTreeWithBlobContents},
+    blobsContents: { [path: string]: ArrayBufferLike; };
+    trees: { [path: string]: ISnapshotTreeWithBlobContents; };
 }
 
 export interface IParsedUrl {
@@ -130,3 +130,7 @@ export const getSnapshotTreeFromSerializedContainer = (detachedContainerSnapshot
     );
     return snapshotTreeWithBlobContents;
 };
+
+export function getProtocolSnapshotTree(snapshot: ISnapshotTree): ISnapshotTree {
+    return ".protocol" in snapshot.trees ? snapshot.trees[".protocol"] : snapshot;
+}