@fluidframework/container-loader 2.0.0-internal.6.3.3 → 2.0.0-internal.7.0.0

package/lib/container.js

@@ -25,7 +25,7 @@ import { initQuorumValuesFromCodeDetails } from "./quorum";
 import { NoopHeuristic } from "./noopHeuristic";
 import { ConnectionManager } from "./connectionManager";
 import { ConnectionState } from "./connectionState";
-import { OnlyValidTermValue, ProtocolHandler, protocolHandlerShouldProcessSignal, } from "./protocol";
+import { ProtocolHandler, protocolHandlerShouldProcessSignal, } from "./protocol";
 const detachedContainerRefSeqNumber = 0;
 const dirtyContainerEvent = "dirty";
 const savedContainerEvent = "saved";
@@ -121,6 +121,219 @@ export async function ReportIfTooLong(logger, eventName, action) {
 }
 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;
+        const container = new Container(createProps, loadProps);
+        const disableRecordHeapSize = container.mc.config.getBoolean("Fluid.Loader.DisableRecordHeapSize");
+        return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "Load" }, async (event) => new Promise((resolve, reject) => {
+            const defaultMode = { opsBeforeReturn: "cached" };
+            // if we have pendingLocalState, anything we cached is not useful and we shouldn't wait for connection
+            // to return container, so ignore this value and use undefined for opsBeforeReturn
+            const mode = pendingLocalState
+                ? { ...(loadMode ?? defaultMode), opsBeforeReturn: undefined }
+                : loadMode ?? defaultMode;
+            const onClosed = (err) => {
+                // pre-0.58 error message: containerClosedWithoutErrorDuringLoad
+                reject(err ?? new GenericError("Container closed without error during load"));
+            };
+            container.on("closed", onClosed);
+            container
+                .load(version, mode, resolvedUrl, pendingLocalState, loadToSequenceNumber)
+                .finally(() => {
+                container.removeListener("closed", onClosed);
+            })
+                .then((props) => {
+                event.end({ ...props, ...loadMode });
+                resolve(container);
+            }, (error) => {
+                const err = normalizeError(error);
+                // Depending where error happens, we can be attempting to connect to web socket
+                // and continuously retrying (consider offline mode)
+                // Host has no container to close, so it's prudent to do it here
+                // Note: We could only dispose the container instead of just close but that would
+                // the telemetry where users sometimes search for ContainerClose event to look
+                // for load failures. So not removing this at this time.
+                container.close(err);
+                container.dispose(err);
+                onClosed(err);
+            });
+        }), { start: true, end: true, cancel: "generic" }, disableRecordHeapSize !== true /* recordHeapSize */);
+    }
+    /**
+     * Create a new container in a detached state.
+     */
+    static async createDetached(createProps, codeDetails) {
+        const container = new Container(createProps);
+        return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "CreateDetached" }, async (_event) => {
+            await container.createDetached(codeDetails);
+            return container;
+        }, { start: true, end: true, cancel: "generic" });
+    }
+    /**
+     * Create a new container in a detached state that is initialized with a
+     * snapshot from a previous detached container.
+     */
+    static async rehydrateDetachedFromSnapshot(createProps, snapshot) {
+        const container = new Container(createProps);
+        return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
+            const deserializedSummary = JSON.parse(snapshot);
+            await container.rehydrateDetachedFromSnapshot(deserializedSummary);
+            return container;
+        }, { start: true, end: true, cancel: "generic" });
+    }
+    setLoaded() {
+        // It's conceivable the container could be closed when this is called
+        // Only transition states if currently loading
+        if (this._lifecycleState === "loading") {
+            // Propagate current connection state through the system.
+            this.propagateConnectionState(true /* initial transition */);
+            this._lifecycleState = "loaded";
+        }
+    }
+    get closed() {
+        return (this._lifecycleState === "closing" || this._lifecycleState === "closed" || this.disposed);
+    }
+    get disposed() {
+        return this._lifecycleState === "disposing" || this._lifecycleState === "disposed";
+    }
+    get runtime() {
+        if (this._runtime === undefined) {
+            throw new Error("Attempted to access runtime before it was defined");
+        }
+        return this._runtime;
+    }
+    get protocolHandler() {
+        if (this._protocolHandler === undefined) {
+            throw new Error("Attempted to access protocolHandler before it was defined");
+        }
+        return this._protocolHandler;
+    }
+    get connectionMode() {
+        return this._deltaManager.connectionManager.connectionMode;
+    }
+    /**
+     * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+     */
+    // eslint-disable-next-line import/no-deprecated
+    get IFluidRouter() {
+        return this;
+    }
+    get resolvedUrl() {
+        /**
+         * All attached containers will have a document service,
+         * this is required, as attached containers are attached to
+         * a service. Detached containers will neither have a document
+         * service or a resolved url as they only exist locally.
+         * in order to create a document service a resolved url must
+         * first be obtained, this is how the container is identified.
+         * Because of this, the document service's resolved url
+         * is always the same as the containers, as we had to
+         * obtain the resolved url, and then create the service from it.
+         */
+        return this.service?.resolvedUrl;
+    }
+    get readOnlyInfo() {
+        return this._deltaManager.readOnlyInfo;
+    }
+    /**
+     * Sends signal to runtime (and data stores) to be read-only.
+     * Hosts may have read only views, indicating to data stores that no edits are allowed.
+     * This is independent from this._readonlyPermissions (permissions) and this.connectionMode
+     * (server can return "write" mode even when asked for "read")
+     * Leveraging same "readonly" event as runtime & data stores should behave the same in such case
+     * as in read-only permissions.
+     * But this.active can be used by some DDSes to figure out if ops can be sent
+     * (for example, read-only view still participates in code proposals / upgrades decisions)
+     *
+     * Forcing Readonly does not prevent DDS from generating ops. It is up to user code to honour
+     * the readonly flag. If ops are generated, they will accumulate locally and not be sent. If
+     * there are pending in the outbound queue, it will stop sending until force readonly is
+     * cleared.
+     *
+     * @param readonly - set or clear force readonly.
+     */
+    forceReadonly(readonly) {
+        this._deltaManager.connectionManager.forceReadonly(readonly);
+    }
+    get deltaManager() {
+        return this._deltaManager;
+    }
+    get connectionState() {
+        return this.connectionStateHandler.connectionState;
+    }
+    get connected() {
+        return this.connectionStateHandler.connectionState === ConnectionState.Connected;
+    }
+    /**
+     * The server provided id of the client.
+     * Set once this.connected is true, otherwise undefined
+     */
+    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 the code details that are currently specified for the container.
+     * @returns The current code details if any are specified, undefined if none are specified.
+     */
+    getSpecifiedCodeDetails() {
+        return this.getCodeDetailsFromQuorum();
+    }
+    /**
+     * 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
+     * loaded.
+     */
+    getLoadedCodeDetails() {
+        return this._loadedCodeDetails;
+    }
+    /**
+     * Retrieves the audience associated with the document
+     */
+    get audience() {
+        return this.protocolHandler.audience;
+    }
+    /**
+     * Returns true if container is dirty.
+     * Which means data loss if container is closed at that same moment
+     * Most likely that happens when there is no network connection to Relay Service
+     */
+    get isDirty() {
+        return this._dirtyContainer;
+    }
+    /**
+     * {@inheritDoc @fluidframework/container-definitions#IContainer.entryPoint}
+     */
+    async getEntryPoint() {
+        if (this._disposed) {
+            throw new UsageError("The context is already disposed");
+        }
+        if (this._runtime !== undefined) {
+            return this._runtime.getEntryPoint?.();
+        }
+        return new Promise((resolve, reject) => {
+            const runtimeInstantiatedHandler = () => {
+                assert(this._runtime !== undefined, 0x5a3 /* runtimeInstantiated fired but runtime is still undefined */);
+                resolve(this._runtime.getEntryPoint?.());
+                this._lifecycleEvents.off("disposed", disposedHandler);
+            };
+            const disposedHandler = () => {
+                reject(new Error("ContainerContext was disposed"));
+                this._lifecycleEvents.off("runtimeInstantiated", runtimeInstantiatedHandler);
+            };
+            this._lifecycleEvents.once("runtimeInstantiated", runtimeInstantiatedHandler);
+            this._lifecycleEvents.once("disposed", disposedHandler);
+        });
+    }
     /**
      * @internal
      */
@@ -323,201 +536,6 @@ export class Container extends EventEmitterWithErrorHandling {
             document.addEventListener("visibilitychange", this.visibilityEventHandler);
         }
     }
-    /**
-     * Load an existing container.
-     * @internal
-     */
-    static async load(loadProps, createProps) {
-        const { version, pendingLocalState, loadMode, resolvedUrl, loadToSequenceNumber } = loadProps;
-        const container = new Container(createProps, loadProps);
-        const disableRecordHeapSize = container.mc.config.getBoolean("Fluid.Loader.DisableRecordHeapSize");
-        return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "Load" }, async (event) => new Promise((resolve, reject) => {
-            const defaultMode = { opsBeforeReturn: "cached" };
-            // if we have pendingLocalState, anything we cached is not useful and we shouldn't wait for connection
-            // to return container, so ignore this value and use undefined for opsBeforeReturn
-            const mode = pendingLocalState
-                ? { ...(loadMode ?? defaultMode), opsBeforeReturn: undefined }
-                : loadMode ?? defaultMode;
-            const onClosed = (err) => {
-                // pre-0.58 error message: containerClosedWithoutErrorDuringLoad
-                reject(err ?? new GenericError("Container closed without error during load"));
-            };
-            container.on("closed", onClosed);
-            container
-                .load(version, mode, resolvedUrl, pendingLocalState, loadToSequenceNumber)
-                .finally(() => {
-                container.removeListener("closed", onClosed);
-            })
-                .then((props) => {
-                event.end({ ...props, ...loadMode });
-                resolve(container);
-            }, (error) => {
-                const err = normalizeError(error);
-                // Depending where error happens, we can be attempting to connect to web socket
-                // and continuously retrying (consider offline mode)
-                // Host has no container to close, so it's prudent to do it here
-                // Note: We could only dispose the container instead of just close but that would
-                // the telemetry where users sometimes search for ContainerClose event to look
-                // for load failures. So not removing this at this time.
-                container.close(err);
-                container.dispose(err);
-                onClosed(err);
-            });
-        }), { start: true, end: true, cancel: "generic" }, disableRecordHeapSize !== true /* recordHeapSize */);
-    }
-    /**
-     * Create a new container in a detached state.
-     */
-    static async createDetached(createProps, codeDetails) {
-        const container = new Container(createProps);
-        return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "CreateDetached" }, async (_event) => {
-            await container.createDetached(codeDetails);
-            return container;
-        }, { start: true, end: true, cancel: "generic" });
-    }
-    /**
-     * Create a new container in a detached state that is initialized with a
-     * snapshot from a previous detached container.
-     */
-    static async rehydrateDetachedFromSnapshot(createProps, snapshot) {
-        const container = new Container(createProps);
-        return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
-            const deserializedSummary = JSON.parse(snapshot);
-            await container.rehydrateDetachedFromSnapshot(deserializedSummary);
-            return container;
-        }, { start: true, end: true, cancel: "generic" });
-    }
-    setLoaded() {
-        // It's conceivable the container could be closed when this is called
-        // Only transition states if currently loading
-        if (this._lifecycleState === "loading") {
-            // Propagate current connection state through the system.
-            this.propagateConnectionState(true /* initial transition */);
-            this._lifecycleState = "loaded";
-        }
-    }
-    get closed() {
-        return (this._lifecycleState === "closing" || this._lifecycleState === "closed" || this.disposed);
-    }
-    get disposed() {
-        return this._lifecycleState === "disposing" || this._lifecycleState === "disposed";
-    }
-    get runtime() {
-        if (this._runtime === undefined) {
-            throw new Error("Attempted to access runtime before it was defined");
-        }
-        return this._runtime;
-    }
-    get protocolHandler() {
-        if (this._protocolHandler === undefined) {
-            throw new Error("Attempted to access protocolHandler before it was defined");
-        }
-        return this._protocolHandler;
-    }
-    get connectionMode() {
-        return this._deltaManager.connectionManager.connectionMode;
-    }
-    get IFluidRouter() {
-        return this;
-    }
-    get resolvedUrl() {
-        /**
-         * All attached containers will have a document service,
-         * this is required, as attached containers are attached to
-         * a service. Detached containers will neither have a document
-         * service or a resolved url as they only exist locally.
-         * in order to create a document service a resolved url must
-         * first be obtained, this is how the container is identified.
-         * Because of this, the document service's resolved url
-         * is always the same as the containers, as we had to
-         * obtain the resolved url, and then create the service from it.
-         */
-        return this.service?.resolvedUrl;
-    }
-    get readOnlyInfo() {
-        return this._deltaManager.readOnlyInfo;
-    }
-    /**
-     * Tracks host requiring read-only mode.
-     */
-    forceReadonly(readonly) {
-        this._deltaManager.connectionManager.forceReadonly(readonly);
-    }
-    get deltaManager() {
-        return this._deltaManager;
-    }
-    get connectionState() {
-        return this.connectionStateHandler.connectionState;
-    }
-    get connected() {
-        return this.connectionStateHandler.connectionState === ConnectionState.Connected;
-    }
-    /**
-     * The server provided id of the client.
-     * Set once this.connected is true, otherwise undefined
-     */
-    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 the code details that are currently specified for the container.
-     * @returns The current code details if any are specified, undefined if none are specified.
-     */
-    getSpecifiedCodeDetails() {
-        return this.getCodeDetailsFromQuorum();
-    }
-    /**
-     * 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
-     * loaded.
-     */
-    getLoadedCodeDetails() {
-        return this._loadedCodeDetails;
-    }
-    /**
-     * Retrieves the audience associated with the document
-     */
-    get audience() {
-        return this.protocolHandler.audience;
-    }
-    /**
-     * Returns true if container is dirty.
-     * Which means data loss if container is closed at that same moment
-     * Most likely that happens when there is no network connection to Relay Service
-     */
-    get isDirty() {
-        return this._dirtyContainer;
-    }
-    /**
-     * {@inheritDoc @fluidframework/container-definitions#IContainer.entryPoint}
-     */
-    async getEntryPoint() {
-        if (this._disposed) {
-            throw new UsageError("The context is already disposed");
-        }
-        if (this._runtime !== undefined) {
-            return this._runtime.getEntryPoint?.();
-        }
-        return new Promise((resolve, reject) => {
-            const runtimeInstantiatedHandler = () => {
-                assert(this._runtime !== undefined, 0x5a3 /* runtimeInstantiated fired but runtime is still undefined */);
-                resolve(this._runtime.getEntryPoint?.());
-                this._lifecycleEvents.off("disposed", disposedHandler);
-            };
-            const disposedHandler = () => {
-                reject(new Error("ContainerContext was disposed"));
-                this._lifecycleEvents.off("runtimeInstantiated", runtimeInstantiatedHandler);
-            };
-            this._lifecycleEvents.once("runtimeInstantiated", runtimeInstantiatedHandler);
-            this._lifecycleEvents.once("disposed", disposedHandler);
-        });
-    }
     /**
      * Retrieves the quorum associated with the document
      */
@@ -652,7 +670,6 @@ export class Container extends EventEmitterWithErrorHandling {
                 snapshotBlobs: this.baseSnapshotBlobs,
                 savedOps: this.savedOps,
                 url: this.resolvedUrl.url,
-                term: OnlyValidTermValue,
                 // no need to save this if there is no pending runtime state
                 clientId: pendingRuntimeState !== undefined ? this.clientId : undefined,
             };
@@ -774,6 +791,9 @@ export class Container extends EventEmitterWithErrorHandling {
             }
         }, { start: true, end: true, cancel: "generic" });
     }
+    /**
+     * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+     */
     async request(path) {
         return PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Request" }, async () => this.runtime.request(path), { end: true, cancel: "error" });
     }
@@ -924,18 +944,14 @@ export class Container extends EventEmitterWithErrorHandling {
     async load(specifiedVersion, loadMode, resolvedUrl, pendingLocalState, loadToSequenceNumber) {
         const timings = { phase1: performance.now() };
         this.service = await this.serviceFactory.createDocumentService(resolvedUrl, this.subLogger, this.client.details.type === summarizerClientType);
-        // Ideally we always connect as "read" by default.
-        // Currently that works with SPO & r11s, because we get "write" connection when connecting to non-existing file.
-        // We should not rely on it by (one of them will address the issue, but we need to address both)
-        // 1) switching create new flow to one where we create file by posting snapshot
-        // 2) Fixing quorum workflows (have retry logic)
-        // That all said, "read" does not work with memorylicious workflows (that opens two simultaneous
-        // connections to same file) in two ways:
-        // A) creation flow breaks (as one of the clients "sees" file as existing, and hits #2 above)
-        // B) Once file is created, transition from view-only connection to write does not work - some bugs to be fixed.
+        // Except in cases where it has stashed ops or requested by feature gate, the container will connect in "read" mode
+        const mode = this.mc.config.getBoolean("Fluid.Container.ForceWriteConnection") === true ||
+            (pendingLocalState?.savedOps.length ?? 0) > 0
+            ? "write"
+            : "read";
         const connectionArgs = {
             reason: { text: "DocumentOpen" },
-            mode: "write",
+            mode,
             fetchOpsFromStorage: false,
         };
         // Start websocket connection as soon as possible. Note that there is no op handler attached yet, but the
@@ -1100,7 +1116,6 @@ export class Container extends EventEmitterWithErrorHandling {
     async createDetached(codeDetails) {
         const attributes = {
             sequenceNumber: detachedContainerRefSeqNumber,
-            term: OnlyValidTermValue,
             minimumSequenceNumber: 0,
         };
         await this.attachDeltaManagerOpHandler(attributes);
@@ -1140,7 +1155,6 @@ export class Container extends EventEmitterWithErrorHandling {
             return {
                 minimumSequenceNumber: 0,
                 sequenceNumber: 0,
-                term: OnlyValidTermValue,
             };
         }
         // Backward compatibility: old docs would have ".attributes" instead of "attributes"