@fluidframework/container-loader 2.0.0-dev-rc.1.0.0.232845 → 2.0.0-dev-rc.2.0.0.245554

package/lib/{container.mjs → container.js}

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 import { v4 as uuid } from "uuid";
-import { assert, unreachableCase } from "@fluidframework/core-utils";
+import { assert, unreachableCase, isPromiseLike } from "@fluidframework/core-utils";
 import { TypedEventEmitter, performance } from "@fluid-internal/client-utils";
 import { LogLevel, } from "@fluidframework/core-interfaces";
 import { AttachState, isFluidCodeDetails, } from "@fluidframework/container-definitions";
@@ -11,21 +11,22 @@ import { readAndParse, OnlineStatus, isOnline, isCombinedAppAndProtocolSummary,
 import { MessageType, SummaryType, } from "@fluidframework/protocol-definitions";
 import { createChildLogger, EventEmitterWithErrorHandling, PerformanceEvent, raiseConnectedEvent, connectedEventName, normalizeError, createChildMonitoringContext, wrapError, formatTick, GenericError, UsageError, } from "@fluidframework/telemetry-utils";
 import structuredClone from "@ungap/structured-clone";
-import { Audience } from "./audience.mjs";
-import { ContainerContext } from "./containerContext.mjs";
-import { ReconnectMode, getPackageName, } from "./contracts.mjs";
-import { DeltaManager } from "./deltaManager.mjs";
-import { RelativeLoader } from "./loader.mjs";
-import { pkgVersion } from "./packageVersion.mjs";
-import { ContainerStorageAdapter, getBlobContentsFromTree, } from "./containerStorageAdapter.mjs";
-import { createConnectionStateHandler } from "./connectionStateHandler.mjs";
-import { combineAppAndProtocolSummary, getProtocolSnapshotTree, getSnapshotTreeAndBlobsFromSerializedContainer, combineSnapshotTreeAndSnapshotBlobs, getDetachedContainerStateFromSerializedContainer, runSingle, } from "./utils.mjs";
-import { initQuorumValuesFromCodeDetails } from "./quorum.mjs";
-import { NoopHeuristic } from "./noopHeuristic.mjs";
-import { ConnectionManager } from "./connectionManager.mjs";
-import { ConnectionState } from "./connectionState.mjs";
-import { ProtocolHandler, protocolHandlerShouldProcessSignal, } from "./protocol.mjs";
-import { runRetriableAttachProcess } from "./attachment.mjs";
+import { Audience } from "./audience.js";
+import { ContainerContext } from "./containerContext.js";
+import { ReconnectMode, getPackageName, } from "./contracts.js";
+import { DeltaManager } from "./deltaManager.js";
+import { RelativeLoader } from "./loader.js";
+import { pkgVersion } from "./packageVersion.js";
+import { ContainerStorageAdapter } from "./containerStorageAdapter.js";
+import { createConnectionStateHandler } from "./connectionStateHandler.js";
+import { combineAppAndProtocolSummary, getProtocolSnapshotTree, getSnapshotTreeAndBlobsFromSerializedContainer, combineSnapshotTreeAndSnapshotBlobs, getDetachedContainerStateFromSerializedContainer, runSingle, } from "./utils.js";
+import { initQuorumValuesFromCodeDetails } from "./quorum.js";
+import { NoopHeuristic } from "./noopHeuristic.js";
+import { ConnectionManager } from "./connectionManager.js";
+import { ConnectionState } from "./connectionState.js";
+import { ProtocolHandler, protocolHandlerShouldProcessSignal, } from "./protocol.js";
+import { runRetriableAttachProcess } from "./attachment.js";
+import { SerializedStateManager } from "./serializedStateManager.js";
 const detachedContainerRefSeqNumber = 0;
 const dirtyContainerEvent = "dirty";
 const savedContainerEvent = "saved";
@@ -104,9 +105,7 @@ export async function waitContainerToCatchUp(container) {
         }
     });
 }
-const getCodeProposal = 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-(quorum) => quorum.get("code") ?? quorum.get("code2");
+const getCodeProposal = (quorum) => quorum.get("code") ?? quorum.get("code2");
 /**
  * Helper function to report to telemetry cases where operation takes longer than expected (200ms)
  * @param logger - logger to use
@@ -124,7 +123,6 @@ const summarizerClientType = "summarizer";
 export class Container extends EventEmitterWithErrorHandling {
     /**
      * Load an existing container.
-     * @internal
      */
     static async load(loadProps, createProps) {
         const { version, pendingLocalState, loadMode, resolvedUrl, loadToSequenceNumber } = loadProps;
@@ -272,11 +270,8 @@ export class Container extends EventEmitterWithErrorHandling {
     get clientId() {
         return this._clientId;
     }
-    get offlineLoadEnabled() {
-        const enabled = this.mc.config.getBoolean("Fluid.Container.enableOfflineLoad") ??
-            this.options?.enableOfflineLoad === true;
-        // summarizer will not have any pending state we want to save
-        return enabled && this.deltaManager.clientDetails.capabilities.interactive;
+    get isInteractiveClient() {
+        return this.deltaManager.clientDetails.capabilities.interactive;
     }
     /**
      * Get the code details that are currently specified for the container.
@@ -331,9 +326,6 @@ export class Container extends EventEmitterWithErrorHandling {
             this._lifecycleEvents.once("disposed", disposedHandler);
         });
     }
-    /**
-     * @internal
-     */
     constructor(createProps, loadProps) {
         super((name, error) => {
             this.mc.logger.sendErrorEvent({
@@ -362,7 +354,6 @@ export class Container extends EventEmitterWithErrorHandling {
         this.firstConnection = true;
         this.connectionTransitionTimes = [];
         this._dirtyContainer = false;
-        this.savedOps = [];
         this.attachmentData = { state: AttachState.Detached };
         this.clientsWhoShouldHaveLeft = new Set();
         this._containerMetadata = {};
@@ -423,7 +414,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 };
                 let attachP = runRetriableAttachProcess({
                     initialAttachmentData: this.attachmentData,
-                    offlineLoadEnabled: this.offlineLoadEnabled,
+                    offlineLoadEnabled: this.serializedStateManager.offlineLoadEnabled,
                     detachedBlobStorage: this.detachedBlobStorage,
                     setAttachmentData,
                     createAttachmentSummary,
@@ -435,7 +426,7 @@ export class Container extends EventEmitterWithErrorHandling {
                         throw normalizeErrorAndClose(error);
                     });
                 }
-                await attachP;
+                this.serializedStateManager.setSnapshot(await attachP);
                 if (!this.closed) {
                     this.handleDeltaConnectionArg({
                         fetchOpsFromStorage: false,
@@ -487,7 +478,7 @@ export class Container extends EventEmitterWithErrorHandling {
             });
         };
         this._containerId = uuid();
-        this.client = Container.setupClient(this._containerId, this.options, this.clientDetailsOverride);
+        this.client = Container.setupClient(this._containerId, options.client, this.clientDetailsOverride);
         // Create logger for data stores to use
         const type = this.client.details.type;
         const interactive = this.client.details.capabilities.interactive;
@@ -593,6 +584,10 @@ export class Container extends EventEmitterWithErrorHandling {
         const forceEnableSummarizeProtocolTree = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2") ??
             options.summarizeProtocolTree;
         this.storageAdapter = new ContainerStorageAdapter(detachedBlobStorage, this.mc.logger, pendingLocalState?.snapshotBlobs, addProtocolSummaryIfMissing, forceEnableSummarizeProtocolTree);
+        const offlineLoadEnabled = (this.isInteractiveClient &&
+            this.mc.config.getBoolean("Fluid.Container.enableOfflineLoad")) ??
+            options.enableOfflineLoad === true;
+        this.serializedStateManager = new SerializedStateManager(pendingLocalState, this.subLogger, this.storageAdapter, offlineLoadEnabled);
         const isDomAvailable = typeof document === "object" &&
             document !== null &&
             typeof document.addEventListener === "function" &&
@@ -731,47 +726,32 @@ export class Container extends EventEmitterWithErrorHandling {
         return this.getPendingLocalStateCore({ notifyImminentClosure: false });
     }
     async getPendingLocalStateCore(props) {
-        return PerformanceEvent.timedExecAsync(this.mc.logger, {
-            eventName: "getPendingLocalState",
-            notifyImminentClosure: props.notifyImminentClosure,
-            savedOpsSize: this.savedOps.length,
-            clientId: this.clientId,
-        }, async () => {
-            if (!this.offlineLoadEnabled) {
-                throw new UsageError("Can't get pending local state unless offline load is enabled");
-            }
-            if (this.closed || this._disposed) {
-                throw new UsageError("Pending state cannot be retried if the container is closed or disposed");
-            }
-            assert(this.attachmentData.state === AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
-            assert(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
-            assert(this.attachmentData.snapshot !== undefined, 0x5d5 /* no base data */);
-            const pendingRuntimeState = await this.runtime.getPendingLocalState(props);
-            const pendingState = {
-                pendingRuntimeState,
-                baseSnapshot: this.attachmentData.snapshot.tree,
-                snapshotBlobs: this.attachmentData.snapshot.blobs,
-                savedOps: this.savedOps,
-                url: this.resolvedUrl.url,
-                // no need to save this if there is no pending runtime state
-                clientId: pendingRuntimeState !== undefined ? this.clientId : undefined,
-            };
-            return JSON.stringify(pendingState);
-        });
+        if (this.closed || this._disposed) {
+            throw new UsageError("Pending state cannot be retried if the container is closed or disposed");
+        }
+        assert(this.attachmentData.state === AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
+        assert(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
+        const pendingState = await this.serializedStateManager.getPendingLocalStateCore(props, this.clientId, this.runtime, this.resolvedUrl);
+        return pendingState;
     }
     get attachState() {
         return this.attachmentData.state;
     }
     serialize() {
-        assert(this.attachState === AttachState.Detached, 0x0d3 /* "Should only be called in detached container" */);
-        const appSummary = this.runtime.createSummary();
-        const protocolSummary = this.captureProtocolSummary();
-        const combinedSummary = combineAppAndProtocolSummary(appSummary, protocolSummary);
+        if (this.attachmentData.state === AttachState.Attached || this.closed) {
+            throw new UsageError("Container must not be attached or closed.");
+        }
+        const attachingData = this.attachmentData.state === AttachState.Attaching ? this.attachmentData : undefined;
+        const combinedSummary = attachingData?.summary ??
+            combineAppAndProtocolSummary(this.runtime.createSummary(), this.captureProtocolSummary());
         const { tree: snapshot, blobs } = getSnapshotTreeAndBlobsFromSerializedContainer(combinedSummary);
+        const pendingRuntimeState = attachingData !== undefined ? this.runtime.getPendingLocalState() : undefined;
+        assert(!isPromiseLike(pendingRuntimeState), 0x8e3 /* should not be a promise */);
         const detachedContainerState = {
             attached: false,
             baseSnapshot: snapshot,
             snapshotBlobs: blobs,
+            pendingRuntimeState,
             hasAttachmentBlobs: !!this.detachedBlobStorage && this.detachedBlobStorage.size > 0,
         };
         return JSON.stringify(detachedContainerState);
@@ -904,10 +884,6 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         return true;
     }
-    async getVersion(version) {
-        const versions = await this.storageAdapter.getVersions(version, 1);
-        return versions[0];
-    }
     connectToDeltaStream(args) {
         // All agents need "write" access, including summarizer.
         if (!this._canReconnect || !this.client.details.capabilities.interactive) {
@@ -952,31 +928,8 @@ export class Container extends EventEmitterWithErrorHandling {
         };
         timings.phase2 = performance.now();
         // Fetch specified snapshot.
-        const { snapshot, versionId } = pendingLocalState === undefined
-            ? await this.fetchSnapshot(specifiedVersion)
-            : { snapshot: pendingLocalState.baseSnapshot, versionId: undefined };
-        const snapshotTree = isInstanceOfISnapshot(snapshot)
-            ? snapshot.snapshotTree
-            : snapshot;
-        if (pendingLocalState) {
-            this.attachmentData = {
-                state: AttachState.Attached,
-                snapshot: {
-                    tree: pendingLocalState.baseSnapshot,
-                    blobs: pendingLocalState.snapshotBlobs,
-                },
-            };
-        }
-        else {
-            assert(snapshotTree !== undefined, 0x237 /* "Snapshot should exist" */);
-            if (this.offlineLoadEnabled) {
-                const blobs = await getBlobContentsFromTree(snapshotTree, this.storageAdapter);
-                this.attachmentData = {
-                    state: AttachState.Attached,
-                    snapshot: { tree: snapshotTree, blobs },
-                };
-            }
-        }
+        const { snapshotTree, version } = await this.serializedStateManager.fetchSnapshot(specifiedVersion, this.service?.policies?.supportGetSnapshotApi);
+        this._loadedFromVersion = version;
         const attributes = await this.getDocumentAttributes(this.storageAdapter, snapshotTree);
         // If we saved ops, we will replay them and don't need DeltaManager to fetch them
         const sequenceNumber = pendingLocalState?.savedOps[pendingLocalState.savedOps.length - 1]?.sequenceNumber;
@@ -1047,7 +1000,7 @@ export class Container extends EventEmitterWithErrorHandling {
         const codeDetails = this.getCodeDetailsFromQuorum();
         await this.instantiateRuntime(codeDetails, snapshotTree, 
         // give runtime a dummy value so it knows we're loading from a stash blob
-        pendingLocalState ? pendingLocalState?.pendingRuntimeState ?? {} : undefined, isInstanceOfISnapshot(snapshot) ? snapshot : undefined);
+        pendingLocalState ? pendingLocalState?.pendingRuntimeState ?? {} : undefined, isInstanceOfISnapshot(snapshotTree) ? snapshotTree : undefined);
         // replay saved ops
         if (pendingLocalState) {
             for (const message of pendingLocalState.savedOps) {
@@ -1102,7 +1055,7 @@ export class Container extends EventEmitterWithErrorHandling {
         }, undefined, LogLevel.verbose);
         return {
             sequenceNumber: attributes.sequenceNumber,
-            version: versionId,
+            version: version?.id,
             dmLastProcessedSeqNumber: this._deltaManager.lastSequenceNumber,
             dmLastKnownSeqNumber: this._deltaManager.lastKnownSeqNumber,
         };
@@ -1123,7 +1076,7 @@ export class Container extends EventEmitterWithErrorHandling {
         await this.instantiateRuntime(codeDetails, undefined);
         this.setLoaded();
     }
-    async rehydrateDetachedFromSnapshot({ attached, baseSnapshot, snapshotBlobs, hasAttachmentBlobs, }) {
+    async rehydrateDetachedFromSnapshot({ baseSnapshot, snapshotBlobs, hasAttachmentBlobs, pendingRuntimeState, }) {
         if (hasAttachmentBlobs) {
             assert(!!this.detachedBlobStorage && this.detachedBlobStorage.size > 0, 0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */);
         }
@@ -1140,7 +1093,7 @@ export class Container extends EventEmitterWithErrorHandling {
             values: qValues,
         });
         const codeDetails = this.getCodeDetailsFromQuorum();
-        await this.instantiateRuntime(codeDetails, snapshotTreeWithBlobContents);
+        await this.instantiateRuntime(codeDetails, snapshotTreeWithBlobContents, pendingRuntimeState);
         this.setLoaded();
     }
     async getDocumentAttributes(storage, tree) {
@@ -1240,10 +1193,9 @@ export class Container extends EventEmitterWithErrorHandling {
         const pkg = getCodeProposal(quorum);
         return pkg;
     }
-    static setupClient(containerId, options, clientDetailsOverride) {
-        const loaderOptionsClient = structuredClone(options?.client);
+    static setupClient(containerId, loaderOptionsClient, clientDetailsOverride) {
         const client = loaderOptionsClient !== undefined
-            ? loaderOptionsClient
+            ? structuredClone(loaderOptionsClient)
             : {
                 details: {
                     capabilities: { interactive: true },
@@ -1297,10 +1249,10 @@ export class Container extends EventEmitterWithErrorHandling {
         deltaManager.on("cancelEstablishingConnection", (reason) => {
             this.connectionStateHandler.cancelEstablishingConnection(reason);
         });
-        deltaManager.on("disconnect", (reason) => {
+        deltaManager.on("disconnect", (text, error) => {
             this.noopHeuristic?.notifyDisconnect();
             if (!this.closed) {
-                this.connectionStateHandler.receivedDisconnectEvent(reason);
+                this.connectionStateHandler.receivedDisconnectEvent({ text, error });
             }
         });
         deltaManager.on("throttled", (warning) => {
@@ -1445,14 +1397,12 @@ export class Container extends EventEmitterWithErrorHandling {
         return this._deltaManager.submit(type, contents, batch, metadata, compression, referenceSequenceNumber);
     }
     processRemoteMessage(message) {
-        if (this.offlineLoadEnabled) {
-            this.savedOps.push(message);
-        }
         const local = this.clientId === message.clientId;
         // Allow the protocol handler to process the message
         const result = this.protocolHandler.processMessage(message, local);
         // Forward messages to the loaded runtime for processing
         this.runtime.process(message, local);
+        this.serializedStateManager.addProcessedOp(message);
         // Inactive (not in quorum or not writers) clients don't take part in the minimum sequence number calculation.
         if (this.activeConnection()) {
             if (this.noopHeuristic === undefined) {
@@ -1493,49 +1443,6 @@ export class Container extends EventEmitterWithErrorHandling {
             this.runtime.processSignal(message, local);
         }
     }
-    /**
-     * Get the most recent snapshot, or a specific version.
-     * @param specifiedVersion - The specific version of the snapshot to retrieve
-     * @returns The snapshot requested, or the latest snapshot if no version was specified, plus version ID
-     */
-    async fetchSnapshotTree(specifiedVersion) {
-        const version = await this.getVersion(specifiedVersion ?? null);
-        if (version === undefined && specifiedVersion !== undefined) {
-            // We should have a defined version to load from if specified version requested
-            this.mc.logger.sendErrorEvent({
-                eventName: "NoVersionFoundWhenSpecified",
-                id: specifiedVersion,
-            });
-        }
-        this._loadedFromVersion = version;
-        const snapshot = (await this.storageAdapter.getSnapshotTree(version)) ?? undefined;
-        if (snapshot === undefined && version !== undefined) {
-            this.mc.logger.sendErrorEvent({ eventName: "getSnapshotTreeFailed", id: version.id });
-        }
-        return { snapshot, versionId: version?.id };
-    }
-    async fetchSnapshot(specifiedVersion) {
-        if (this.mc.config.getBoolean("Fluid.Container.FetchSnapshotUsingGetSnapshotApi") ===
-            true &&
-            this.service?.policies?.supportGetSnapshotApi === true) {
-            const snapshot = await this.storageAdapter.getSnapshot({
-                versionId: specifiedVersion,
-            });
-            const version = {
-                id: snapshot.snapshotTree.id ?? "",
-                treeId: snapshot.snapshotTree.id ?? "",
-            };
-            this._loadedFromVersion = version;
-            if (snapshot === undefined && specifiedVersion !== undefined) {
-                this.mc.logger.sendErrorEvent({
-                    eventName: "getSnapshotTreeFailed",
-                    id: version.id,
-                });
-            }
-            return { snapshot, versionId: version.id };
-        }
-        return this.fetchSnapshotTree(specifiedVersion);
-    }
     async instantiateRuntime(codeDetails, snapshotTree, pendingLocalState, snapshot) {
         assert(this._runtime?.disposed !== false, 0x0dd /* "Existing runtime not disposed" */);
         // The relative loader will proxy requests to '/' to the loader itself assuming no non-cache flags
@@ -1601,4 +1508,4 @@ export class Container extends EventEmitterWithErrorHandling {
         }
     }
 }
-//# sourceMappingURL=container.mjs.map
+//# sourceMappingURL=container.js.map