@fluidframework/container-loader 2.118.1 → 3.0.1

package/lib/container.js

@@ -15,15 +15,14 @@ import { EventEmitterWithErrorHandling, GenericError, PerformanceEvent, UsageErr
 import { v4 as uuid } from "uuid";
 import { runRetriableAttachProcess, } from "./attachment.js";
 import { Audience } from "./audience.js";
-import { ConnectionManager } from "./connectionManager.js";
 import { ConnectionState } from "./connectionState.js";
 import { createConnectionStateHandler, } from "./connectionStateHandler.js";
 import { ContainerContext } from "./containerContext.js";
 import { ContainerStorageAdapter } from "./containerStorageAdapter.js";
 import { ReconnectMode, getPackageName, } from "./contracts.js";
-import { DeltaManager } from "./deltaManager.js";
+import { createDeltaManager } from "./deltaManagerFactory.js";
 import { RelativeLoader } from "./loader.js";
-import { validateDriverCompatibility, validateRuntimeCompatibility, } from "./loaderLayerCompatState.js";
+import { validateDriverCompatibility, validateLoaderCompatibilityWithDriver, validateRuntimeCompatibility, } from "./loaderLayerCompatState.js";
 import { createMemoryDetachedBlobStorage, tryInitializeMemoryDetachedBlobStorage, } from "./memoryBlobStorage.js";
 import { NoopHeuristic } from "./noopHeuristic.js";
 import { pkgVersion } from "./packageVersion.js";
@@ -177,6 +176,41 @@ export class Container extends EventEmitterWithErrorHandling {
             return container;
         }, { start: true, end: true, cancel: "generic" });
     }
+    // Tells if container can reconnect on losing fist connection
+    // If false, container gets closed on loss of connection.
+    _canReconnect;
+    clientDetailsOverride;
+    urlResolver;
+    serviceFactory;
+    codeLoader;
+    options;
+    scope;
+    subLogger;
+    detachedBlobStorage;
+    protocolHandlerBuilder;
+    signalAudience = new Audience();
+    client;
+    mc;
+    /**
+     * Used by the RelativeLoader to spawn a new Container for the same document.  Used to create the summarizing client.
+     */
+    clone;
+    /**
+     * Lifecycle state of the container, used mainly to prevent re-entrancy and telemetry
+     *
+     * States are allowed to progress to further states:
+     * "loading" - "loaded" - "closing" - "disposing" - "closed" - "disposed"
+     *
+     * For example, moving from "closed" to "disposing" is not allowed since it is an earlier state.
+     *
+     * loading: Container has been created, but is not yet in normal/loaded state
+     * loaded: Container is in normal/loaded state
+     * closing: Container has started closing process (for re-entrancy prevention)
+     * disposing: Container has started disposing process (for re-entrancy prevention)
+     * closed: Container has closed
+     * disposed: Container has been disposed
+     */
+    _lifecycleState = "loading";
     setLoaded() {
         // It's conceivable the container could be closed when this is called
         // Only transition states if currently loading
@@ -223,18 +257,48 @@ export class Container extends EventEmitterWithErrorHandling {
     get disposed() {
         return this._lifecycleState === "disposing" || this._lifecycleState === "disposed";
     }
+    storageAdapter;
+    _deltaManager;
+    service;
+    fetchOps = async (from, to, abortSignal) => {
+        const deltaStorage = await this.service?.connectToDeltaStorage();
+        if (deltaStorage === undefined) {
+            throw new Error("Cannot fetch ops: delta storage is unavailable");
+        }
+        return deltaStorage.fetchMessages(from, to, abortSignal);
+    };
+    _runtime;
     get runtime() {
         if (this._runtime === undefined) {
             throw new Error("Attempted to access runtime before it was defined");
         }
         return this._runtime;
     }
+    _protocolHandler;
     get protocolHandler() {
         if (this._protocolHandler === undefined) {
             throw new Error("Attempted to access protocolHandler before it was defined");
         }
         return this._protocolHandler;
     }
+    /**
+     * During initialization we pause the inbound queues. We track this state to ensure we only call resume once
+     */
+    inboundQueuePausedFromInit = true;
+    connectionCount = 0;
+    connectionTransitionTimes = [];
+    _loadedFromVersion;
+    _dirtyContainer = false;
+    attachmentData = { state: AttachState.Detached };
+    serializedStateManager;
+    _containerId;
+    lastVisible;
+    visibilityEventHandler;
+    connectionStateHandler;
+    clientsWhoShouldHaveLeft = new Set();
+    _containerMetadata = {};
+    setAutoReconnectTime = performanceNow();
+    noopHeuristic;
     get connectionMode() {
         return this._deltaManager.connectionManager.connectionMode;
     }
@@ -310,6 +374,7 @@ export class Container extends EventEmitterWithErrorHandling {
     getSpecifiedCodeDetails() {
         return this.getCodeDetailsFromQuorum();
     }
+    _loadedCodeDetails;
     /**
      * Get the code details that were used to load the container.
      * @returns The code details that were used to load the container if it is loaded, undefined if it is not yet
@@ -318,6 +383,7 @@ export class Container extends EventEmitterWithErrorHandling {
     getLoadedCodeDetails() {
         return this._loadedCodeDetails;
     }
+    _loadedModule;
     /**
      * Retrieves the audience associated with the document
      */
@@ -356,6 +422,7 @@ export class Container extends EventEmitterWithErrorHandling {
             this._lifecycleEvents.once("disposed", disposedHandler);
         });
     }
+    _lifecycleEvents = new TypedEventEmitter();
     constructor(createProps, loadProps) {
         super((name, error) => {
             this.mc.logger.sendErrorEvent({
@@ -364,144 +431,22 @@ export class Container extends EventEmitterWithErrorHandling {
             }, error);
             this.close(normalizeError(error));
         });
-        this.signalAudience = new Audience();
-        /**
-         * Lifecycle state of the container, used mainly to prevent re-entrancy and telemetry
-         *
-         * States are allowed to progress to further states:
-         * "loading" - "loaded" - "closing" - "disposing" - "closed" - "disposed"
-         *
-         * For example, moving from "closed" to "disposing" is not allowed since it is an earlier state.
-         *
-         * loading: Container has been created, but is not yet in normal/loaded state
-         * loaded: Container is in normal/loaded state
-         * closing: Container has started closing process (for re-entrancy prevention)
-         * disposing: Container has started disposing process (for re-entrancy prevention)
-         * closed: Container has closed
-         * disposed: Container has been disposed
-         */
-        this._lifecycleState = "loading";
-        this.fetchOps = async (from, to, abortSignal) => {
-            const deltaStorage = await this.service?.connectToDeltaStorage();
-            if (deltaStorage === undefined) {
-                throw new Error("Cannot fetch ops: delta storage is unavailable");
-            }
-            return deltaStorage.fetchMessages(from, to, abortSignal);
-        };
-        /**
-         * During initialization we pause the inbound queues. We track this state to ensure we only call resume once
-         */
-        this.inboundQueuePausedFromInit = true;
-        this.connectionCount = 0;
-        this.connectionTransitionTimes = [];
-        this._dirtyContainer = false;
-        this.attachmentData = { state: AttachState.Detached };
-        this.clientsWhoShouldHaveLeft = new Set();
-        this._containerMetadata = {};
-        this.setAutoReconnectTime = performanceNow();
-        this._lifecycleEvents = new TypedEventEmitter();
-        this.verifyClosedAfterCalls = 0;
-        this._disposed = false;
-        this.attach = runSingle(async (request, attachProps) => {
-            await PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
-                if (this._lifecycleState !== "loaded" ||
-                    this.attachmentData.state === AttachState.Attached) {
-                    // pre-0.58 error message: containerNotValidForAttach
-                    throw new UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}] and [${this.attachState}]`);
-                }
-                const normalizeErrorAndClose = (error) => {
-                    const newError = normalizeError(error);
-                    this.close(newError);
-                    // add resolved URL on error object so that host has the ability to find this document and delete it
-                    newError.addTelemetryProperties({
-                        resolvedUrl: this.service?.resolvedUrl?.url,
-                    });
-                    return newError;
-                };
-                const setAttachmentData = (attachmentData) => {
-                    const previousState = this.attachmentData.state;
-                    this.attachmentData = attachmentData;
-                    const state = this.attachmentData.state;
-                    if (state !== previousState && state !== AttachState.Detached) {
-                        try {
-                            this.runtime.setAttachState(state);
-                            this.emit(state.toLocaleLowerCase());
-                        }
-                        catch (error) {
-                            throw normalizeErrorAndClose(error);
-                        }
-                    }
-                };
-                const createAttachmentSummary = (redirectTable) => {
-                    try {
-                        assert(this._deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
-                        return combineAppAndProtocolSummary(this.runtime.createSummary(redirectTable), this.captureProtocolSummary());
-                    }
-                    catch (error) {
-                        throw normalizeErrorAndClose(error);
-                    }
-                };
-                const createOrGetStorageService = async (summary) => {
-                    // Actually go and create the resolved document
-                    if (this.service === undefined) {
-                        const createNewResolvedUrl = await this.urlResolver.resolve(request);
-                        assert(this.client.details.type !== summarizerClientType &&
-                            createNewResolvedUrl !== undefined, 0x2c4 /* "client should not be summarizer before container is created" */);
-                        this.service = await this.createDocumentService(createNewResolvedUrl, {
-                            mode: "attach",
-                            summary,
-                        });
-                    }
-                    this.storageAdapter.connectToService(this.service);
-                    return this.storageAdapter;
-                };
-                let attachP = runRetriableAttachProcess({
-                    initialAttachmentData: this.attachmentData,
-                    detachedBlobStorage: this.detachedBlobStorage,
-                    setAttachmentData,
-                    createAttachmentSummary,
-                    createOrGetStorageService,
-                });
-                // only enable the new behavior if the config is set
-                if (this.mc.config.getBoolean("Fluid.Container.DisableCloseOnAttachFailure") !== true) {
-                    attachP = attachP.catch((error) => {
-                        throw normalizeErrorAndClose(error);
-                    });
-                }
-                // If offline load is enabled, attachP will return the attach summary (in Snapshot format) so we can initialize SerializedStateManager
-                const snapshotWithBlobs = await attachP;
-                this.serializedStateManager.setInitialSnapshot(snapshotWithBlobs);
-                if (!this.closed) {
-                    this.detachedBlobStorage?.dispose?.();
-                    this.handleDeltaConnectionArg(attachProps?.deltaConnection, {
-                        fetchOpsFromStorage: false,
-                        reason: { text: "createDetached" },
-                    });
-                }
-            }, { start: true, end: true, cancel: "generic" });
-        });
-        this.getAbsoluteUrl = async (relativeUrl) => {
-            if (this.resolvedUrl === undefined) {
-                return undefined;
-            }
-            return this.urlResolver.getAbsoluteUrl(this.resolvedUrl, relativeUrl, getPackageName(this._loadedCodeDetails));
-        };
-        this.metadataUpdateHandler = (metadata) => {
-            this._containerMetadata = { ...this._containerMetadata, ...metadata };
-            this.emit("metadataUpdate", metadata);
-        };
-        this.updateDirtyContainerState = (dirty) => {
-            if (this._dirtyContainer === dirty) {
-                return;
-            }
-            this._dirtyContainer = dirty;
-            this.emit(dirty ? dirtyContainerEvent : savedContainerEvent);
-        };
         const { canReconnect, clientDetailsOverride, urlResolver, documentServiceFactory, codeLoader, options, scope, subLogger, protocolHandlerBuilder, } = createProps;
-        // Validate that the Driver is compatible with this Loader.
-        const maybeDriverCompatDetails = documentServiceFactory;
-        validateDriverCompatibility(maybeDriverCompatDetails.ILayerCompatDetails, (error) => { } /* disposeFn */, // There is nothing to dispose here, so just ignore the error.
-        createChildMonitoringContext({ logger: subLogger, namespace: "Container" }));
+        const maybeDriverCompat = documentServiceFactory;
+        const driverCompatMonitoringContext = createChildMonitoringContext({
+            logger: subLogger,
+            namespace: "Container",
+        });
+        // Validate that the Driver is compatible with this Loader. This is the standard direction: the Loader holds
+        // a reference to the Driver and validates it.
+        validateDriverCompatibility(maybeDriverCompat.ILayerCompatDetails, (error) => { } /* disposeFn */, // There is nothing to dispose here, so just ignore the error.
+        driverCompatMonitoringContext);
+        // Validate that this Loader is compatible with the Driver. This is the reverse, non-standard direction: a
+        // layer normally validates the layer it holds a reference to, but the Driver has no reference to the Loader
+        // and so cannot validate it itself. The Driver instead publishes the requirements it has for the Loader (via
+        // ILayerCompatSupportRequirements), and the Loader validates itself against them here, on the Driver's behalf.
+        validateLoaderCompatibilityWithDriver(maybeDriverCompat.ILayerCompatDetails, maybeDriverCompat.ILayerCompatSupportRequirements, (error) => { } /* disposeFn */, // There is nothing to dispose here, so just ignore the error.
+        driverCompatMonitoringContext);
         this.connectionTransitionTimes[ConnectionState.Disconnected] = performanceNow();
         const pendingLocalState = loadProps?.pendingLocalState;
         this._canReconnect = canReconnect ?? true;
@@ -682,6 +627,7 @@ export class Container extends EventEmitterWithErrorHandling {
         //    "closing" will lose that info (can also solve by tracking extra state).
         this.verifyClosedAfter(() => this._deltaManager.close(error));
     }
+    verifyClosedAfterCalls = 0;
     verifyClosedAfter(callback) {
         this.verifyClosedAfterCalls++;
         try {
@@ -736,6 +682,7 @@ export class Container extends EventEmitterWithErrorHandling {
             }
         }
     }
+    _disposed = false;
     disposeCore(error) {
         assert(!this._disposed, 0x54c /* Container already disposed */);
         this._disposed = true;
@@ -822,6 +769,84 @@ export class Container extends EventEmitterWithErrorHandling {
         };
         return JSON.stringify(detachedContainerState);
     }
+    attach = runSingle(async (request, attachProps) => {
+        await PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
+            if (this._lifecycleState !== "loaded" ||
+                this.attachmentData.state === AttachState.Attached) {
+                // pre-0.58 error message: containerNotValidForAttach
+                throw new UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}] and [${this.attachState}]`);
+            }
+            const normalizeErrorAndClose = (error) => {
+                const newError = normalizeError(error);
+                this.close(newError);
+                // add resolved URL on error object so that host has the ability to find this document and delete it
+                newError.addTelemetryProperties({
+                    resolvedUrl: this.service?.resolvedUrl?.url,
+                });
+                return newError;
+            };
+            const setAttachmentData = (attachmentData) => {
+                const previousState = this.attachmentData.state;
+                this.attachmentData = attachmentData;
+                const state = this.attachmentData.state;
+                if (state !== previousState && state !== AttachState.Detached) {
+                    try {
+                        this.runtime.setAttachState(state);
+                        this.emit(state.toLocaleLowerCase());
+                    }
+                    catch (error) {
+                        throw normalizeErrorAndClose(error);
+                    }
+                }
+            };
+            const createAttachmentSummary = (redirectTable) => {
+                try {
+                    assert(this._deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
+                    return combineAppAndProtocolSummary(this.runtime.createSummary(redirectTable), this.captureProtocolSummary());
+                }
+                catch (error) {
+                    throw normalizeErrorAndClose(error);
+                }
+            };
+            const createOrGetStorageService = async (summary) => {
+                // Actually go and create the resolved document
+                if (this.service === undefined) {
+                    const createNewResolvedUrl = await this.urlResolver.resolve(request);
+                    assert(this.client.details.type !== summarizerClientType &&
+                        createNewResolvedUrl !== undefined, 0x2c4 /* "client should not be summarizer before container is created" */);
+                    this.service = await this.createDocumentService(createNewResolvedUrl, {
+                        mode: "attach",
+                        summary,
+                    });
+                }
+                this.storageAdapter.connectToService(this.service);
+                return this.storageAdapter;
+            };
+            let attachP = runRetriableAttachProcess({
+                initialAttachmentData: this.attachmentData,
+                detachedBlobStorage: this.detachedBlobStorage,
+                setAttachmentData,
+                createAttachmentSummary,
+                createOrGetStorageService,
+            });
+            // only enable the new behavior if the config is set
+            if (this.mc.config.getBoolean("Fluid.Container.DisableCloseOnAttachFailure") !== true) {
+                attachP = attachP.catch((error) => {
+                    throw normalizeErrorAndClose(error);
+                });
+            }
+            // If offline load is enabled, attachP will return the attach summary (in Snapshot format) so we can initialize SerializedStateManager
+            const snapshotWithBlobs = await attachP;
+            this.serializedStateManager.setInitialSnapshot(snapshotWithBlobs);
+            if (!this.closed) {
+                this.detachedBlobStorage?.dispose?.();
+                this.handleDeltaConnectionArg(attachProps?.deltaConnection, {
+                    fetchOpsFromStorage: false,
+                    reason: { text: "createDetached" },
+                });
+            }
+        }, { start: true, end: true, cancel: "generic" });
+    });
     setAutoReconnectInternal(mode, reason) {
         const currentMode = this._deltaManager.connectionManager.reconnectMode;
         if (currentMode === mode) {
@@ -894,6 +919,12 @@ export class Container extends EventEmitterWithErrorHandling {
         // Ensure connection to web socket
         this.connectToDeltaStream(args);
     }
+    getAbsoluteUrl = async (relativeUrl) => {
+        if (this.resolvedUrl === undefined) {
+            return undefined;
+        }
+        return this.urlResolver.getAbsoluteUrl(this.resolvedUrl, relativeUrl, getPackageName(this._loadedCodeDetails));
+    };
     async proposeCodeDetails(codeDetails) {
         if (!isFluidCodeDetails(codeDetails)) {
             throw new Error("Provided codeDetails are not IFluidCodeDetails");
@@ -962,6 +993,10 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         this._deltaManager.connect(args);
     }
+    metadataUpdateHandler = (metadata) => {
+        this._containerMetadata = { ...this._containerMetadata, ...metadata };
+        this.emit("metadataUpdate", metadata);
+    };
     /**
      * Creates a document service during container attachment or loading.
      * @param resolvedUrl - The resolved URL of the container.
@@ -1283,7 +1318,15 @@ export class Container extends EventEmitterWithErrorHandling {
     createDeltaManager() {
         const serviceProvider = () => this.service;
         const disableLoadConnectionRetries = this.mc.config.getBoolean("Fluid.Container.DisableLoadConnectionRetries") === true;
-        const deltaManager = new DeltaManager(serviceProvider, createChildLogger({ logger: this.subLogger, namespace: "DeltaManager" }), () => this.activeConnection(), (props) => new ConnectionManager(serviceProvider, () => this.isDirty, this.client, this._canReconnect, createChildLogger({ logger: this.subLogger, namespace: "ConnectionManager" }), props, disableLoadConnectionRetries ? 1 : undefined /* maxInitialConnectionAttempts */));
+        const deltaManager = createDeltaManager({
+            serviceProvider,
+            logger: this.subLogger,
+            active: () => this.activeConnection(),
+            containerDirty: () => this.isDirty,
+            client: this.client,
+            reconnectAllowed: this._canReconnect,
+            maxInitialConnectionAttempts: disableLoadConnectionRetries ? 1 : undefined,
+        });
         // Disable inbound queues as Container is not ready to accept any ops until we are fully loaded!
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         deltaManager.inbound.pause();
@@ -1607,6 +1650,13 @@ export class Container extends EventEmitterWithErrorHandling {
             throw error;
         }
     }
+    updateDirtyContainerState = (dirty) => {
+        if (this._dirtyContainer === dirty) {
+            return;
+        }
+        this._dirtyContainer = dirty;
+        this.emit(dirty ? dirtyContainerEvent : savedContainerEvent);
+    };
     /**
      * Send the connected status to the runtime.
      * @param readonly - Is the container in readonly mode?