@fluidframework/container-loader 2.0.0-dev-rc.5.0.0.268409 → 2.0.0-dev-rc.5.0.0.270401

package/lib/container.js

@@ -189,6 +189,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;
+    // eslint-disable-next-line import/no-deprecated
+    detachedBlobStorage;
+    protocolHandlerBuilder;
+    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
@@ -231,18 +266,39 @@ export class Container extends EventEmitterWithErrorHandling {
     get disposed() {
         return this._lifecycleState === "disposing" || this._lifecycleState === "disposed";
     }
+    storageAdapter;
+    _deltaManager;
+    service;
+    _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;
+    firstConnection = true;
+    connectionTransitionTimes = [];
+    _loadedFromVersion;
+    _dirtyContainer = false;
+    attachmentData = { state: AttachState.Detached };
+    serializedStateManager;
+    _containerId;
+    lastVisible;
+    visibilityEventHandler;
+    connectionStateHandler;
+    clientsWhoShouldHaveLeft = new Set();
+    _containerMetadata = {};
+    setAutoReconnectTime = performance.now();
+    noopHeuristic;
     get connectionMode() {
         return this._deltaManager.connectionManager.connectionMode;
     }
@@ -313,6 +369,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
@@ -321,6 +378,7 @@ export class Container extends EventEmitterWithErrorHandling {
     getLoadedCodeDetails() {
         return this._loadedCodeDetails;
     }
+    _loadedModule;
     /**
      * Retrieves the audience associated with the document
      */
@@ -359,6 +417,7 @@ export class Container extends EventEmitterWithErrorHandling {
             this._lifecycleEvents.once("disposed", disposedHandler);
         });
     }
+    _lifecycleEvents = new TypedEventEmitter();
     constructor(createProps, loadProps) {
         super((name, error) => {
             this.mc.logger.sendErrorEvent({
@@ -367,128 +426,6 @@ export class Container extends EventEmitterWithErrorHandling {
             }, error);
             this.close(normalizeError(error));
         });
-        /**
-         * 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";
-        /** During initialization we pause the inbound queues. We track this state to ensure we only call resume once */
-        this.inboundQueuePausedFromInit = true;
-        this.firstConnection = true;
-        this.connectionTransitionTimes = [];
-        this._dirtyContainer = false;
-        this.attachmentData = { state: AttachState.Detached };
-        this.clientsWhoShouldHaveLeft = new Set();
-        this._containerMetadata = {};
-        this.setAutoReconnectTime = performance.now();
-        this._lifecycleEvents = new TypedEventEmitter();
-        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 runWithRetry(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger, false), "containerAttach", this.mc.logger, {
-                            cancel: this._deltaManager.closeAbortController.signal,
-                        });
-                    }
-                    this.storageAdapter.connectToService(this.service);
-                    return this.storageAdapter;
-                };
-                let attachP = runRetriableAttachProcess({
-                    initialAttachmentData: this.attachmentData,
-                    offlineLoadEnabled: this.serializedStateManager.offlineLoadEnabled,
-                    detachedBlobStorage: this.detachedBlobStorage,
-                    setAttachmentData,
-                    createAttachmentSummary,
-                    createOrGetStorageService,
-                });
-                // only enable the new behavior if the config is set
-                if (this.mc.config.getBoolean("Fluid.Container.RetryOnAttachFailure") !== 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, detachedBlobStorage, protocolHandlerBuilder, } = createProps;
         this.connectionTransitionTimes[ConnectionState.Disconnected] = performance.now();
         const pendingLocalState = loadProps?.pendingLocalState;
@@ -633,7 +570,7 @@ export class Container extends EventEmitterWithErrorHandling {
         const offlineLoadEnabled = (this.isInteractiveClient &&
             this.mc.config.getBoolean("Fluid.Container.enableOfflineLoad")) ??
             options.enableOfflineLoad === true;
-        this.serializedStateManager = new SerializedStateManager(pendingLocalState, this.subLogger, this.storageAdapter, offlineLoadEnabled, this, () => this.isDirty);
+        this.serializedStateManager = new SerializedStateManager(pendingLocalState, this.subLogger, this.storageAdapter, offlineLoadEnabled, this, () => this._deltaManager.connectionManager.shouldJoinWrite());
         const isDomAvailable = typeof document === "object" &&
             document !== null &&
             typeof document.addEventListener === "function" &&
@@ -716,6 +653,7 @@ export class Container extends EventEmitterWithErrorHandling {
             }
         }
     }
+    _disposed = false;
     disposeCore(error) {
         assert(!this._disposed, 0x54c /* Container already disposed */);
         this._disposed = true;
@@ -814,6 +752,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 runWithRetry(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger, false), "containerAttach", this.mc.logger, {
+                        cancel: this._deltaManager.closeAbortController.signal,
+                    });
+                }
+                this.storageAdapter.connectToService(this.service);
+                return this.storageAdapter;
+            };
+            let attachP = runRetriableAttachProcess({
+                initialAttachmentData: this.attachmentData,
+                offlineLoadEnabled: this.serializedStateManager.offlineLoadEnabled,
+                detachedBlobStorage: this.detachedBlobStorage,
+                setAttachmentData,
+                createAttachmentSummary,
+                createOrGetStorageService,
+            });
+            // only enable the new behavior if the config is set
+            if (this.mc.config.getBoolean("Fluid.Container.RetryOnAttachFailure") !== 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) {
@@ -886,6 +902,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");
@@ -954,6 +976,10 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         this._deltaManager.connect(args);
     }
+    metadataUpdateHandler = (metadata) => {
+        this._containerMetadata = { ...this._containerMetadata, ...metadata };
+        this.emit("metadataUpdate", metadata);
+    };
     async createDocumentService(serviceProvider) {
         const service = await serviceProvider();
         // Back-compat for Old driver
@@ -1499,6 +1525,13 @@ export class Container extends EventEmitterWithErrorHandling {
         this._lifecycleEvents.emit("runtimeInstantiated");
         this._loadedCodeDetails = codeDetails;
     }
+    updateDirtyContainerState = (dirty) => {
+        if (this._dirtyContainer === dirty) {
+            return;
+        }
+        this._dirtyContainer = dirty;
+        this.emit(dirty ? dirtyContainerEvent : savedContainerEvent);
+    };
     /**
      * Set the connected state of the ContainerContext
      * This controls the "connected" state of the ContainerRuntime as well