@fluidframework/container-loader 0.58.2001 → 0.59.2000-61729

package/lib/container.js

@@ -6,8 +6,7 @@
 import merge from "lodash/merge";
 import { v4 as uuid } from "uuid";
 import { assert, performance, unreachableCase } from "@fluidframework/common-utils";
-import { isFluidCodeDetails, } from "@fluidframework/core-interfaces";
-import { AttachState, } from "@fluidframework/container-definitions";
+import { AttachState, isFluidCodeDetails, } from "@fluidframework/container-definitions";
 import { DataCorruptionError, extractSafePropertiesFromMessage, GenericError, UsageError, } from "@fluidframework/container-utils";
 import { readAndParse, OnlineStatus, isOnline, ensureFluidResolvedUrl, combineAppAndProtocolSummary, runWithRetry, isFluidResolvedUrl, } from "@fluidframework/driver-utils";
 import { isSystemMessage, ProtocolOpHandler, } from "@fluidframework/protocol-base";
@@ -15,7 +14,7 @@ import { MessageType, SummaryType, } from "@fluidframework/protocol-definitions"
 import { ChildLogger, EventEmitterWithErrorHandling, PerformanceEvent, raiseConnectedEvent, TelemetryLogger, connectedEventName, disconnectedEventName, normalizeError, loggerToMonitoringContext, } from "@fluidframework/telemetry-utils";
 import { Audience } from "./audience";
 import { ContainerContext } from "./containerContext";
-import { ReconnectMode } from "./contracts";
+import { ReconnectMode, getPackageName } from "./contracts";
 import { DeltaManager } from "./deltaManager";
 import { DeltaManagerProxy } from "./deltaManagerProxy";
 import { RelativeLoader } from "./loader";
@@ -102,6 +101,7 @@ export async function waitContainerToCatchUp(container) {
 const getCodeProposal = 
 // eslint-disable-next-line @typescript-eslint/no-unsafe-return
 (quorum) => { var _a; return (_a = quorum.get("code")) !== null && _a !== void 0 ? _a : quorum.get("code2"); };
+const summarizerClientType = "summarizer";
 export class Container extends EventEmitterWithErrorHandling {
     constructor(loader, config) {
         var _a, _b, _c;
@@ -119,7 +119,6 @@ export class Container extends EventEmitterWithErrorHandling {
         this._attachState = AttachState.Detached;
         this.resumedOpProcessingAfterLoad = false;
         this.firstConnection = true;
-        this.manualReconnectInProgress = false;
         this.connectionTransitionTimes = [];
         this.messageCountAfterDisconnection = 0;
         this.attachStarted = false;
@@ -346,7 +345,7 @@ export class Container extends EventEmitterWithErrorHandling {
     }
     get context() {
         if (this._context === undefined) {
-            throw new Error("Attempted to access context before it was defined");
+            throw new GenericError("Attempted to access context before it was defined");
         }
         return this._context;
     }
@@ -367,6 +366,9 @@ export class Container extends EventEmitterWithErrorHandling {
     get readOnlyInfo() {
         return this._deltaManager.readOnlyInfo;
     }
+    get closeSignal() {
+        return this._deltaManager.closeAbortController.signal;
+    }
     /**
      * Tracks host requiring read-only mode.
      */
@@ -541,7 +543,10 @@ export class Container extends EventEmitterWithErrorHandling {
                 const createNewResolvedUrl = await this.urlResolver.resolve(request);
                 ensureFluidResolvedUrl(createNewResolvedUrl);
                 if (this.service === undefined) {
-                    this.service = await runWithRetry(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger), "containerAttach", this.mc.logger, {});
+                    assert(this.client.details.type !== summarizerClientType, 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.closeSignal,
+                    });
                 }
                 const resolvedUrl = this.service.resolvedUrl;
                 ensureFluidResolvedUrl(resolvedUrl);
@@ -597,11 +602,28 @@ export class Container extends EventEmitterWithErrorHandling {
     async request(path) {
         return PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Request" }, async () => this.context.request(path), { end: true, cancel: "error" });
     }
+    /**
+     * Dictates whether or not the current container will automatically attempt to reconnect to the delta stream
+     * after receiving a disconnect event
+     * @param reconnect - Boolean indicating if reconnect should automatically occur
+     * @deprecated - 0.58, This API will be removed in 1.0
+     * Use `connect()` and `disconnect()` instead of `setAutoReconnect(true)` and `setAutoReconnect(false)` respectively
+     * See https://github.com/microsoft/FluidFramework/issues/9167 for context
+     */
     setAutoReconnect(reconnect) {
         if (this.closed) {
             throw new Error("Attempting to setAutoReconnect() a closed Container");
         }
         const mode = reconnect ? ReconnectMode.Enabled : ReconnectMode.Disabled;
+        this.setAutoReconnectInternal(mode);
+        // If container state is not attached and resumed, then don't connect to delta stream. Also don't set the
+        // manual reconnection flag to true as we haven't made the initial connection yet.
+        if (reconnect && this._attachState === AttachState.Attached && this.resumedOpProcessingAfterLoad) {
+            // Ensure connection to web socket
+            this.connectToDeltaStream({ reason: "autoReconnect" });
+        }
+    }
+    setAutoReconnectInternal(mode) {
         const currentMode = this._deltaManager.connectionManager.reconnectMode;
         if (currentMode === mode) {
             return;
@@ -610,23 +632,56 @@ export class Container extends EventEmitterWithErrorHandling {
         const duration = now - this.setAutoReconnectTime;
         this.setAutoReconnectTime = now;
         this.mc.logger.sendTelemetryEvent({
-            eventName: reconnect ? "AutoReconnectEnabled" : "AutoReconnectDisabled",
+            eventName: mode === ReconnectMode.Enabled ? "AutoReconnectEnabled" : "AutoReconnectDisabled",
             connectionMode: this.connectionMode,
             connectionState: ConnectionState[this.connectionState],
             duration,
         });
         this._deltaManager.connectionManager.setAutoReconnect(mode);
-        // If container state is not attached and resumed, then don't connect to delta stream. Also don't set the
-        // manual reconnection flag to true as we haven't made the initial connection yet.
-        if (reconnect && this._attachState === AttachState.Attached && this.resumedOpProcessingAfterLoad) {
-            if (this.connectionState === ConnectionState.Disconnected) {
-                // Only track this as a manual reconnection if we are truly the ones kicking it off.
-                this.manualReconnectInProgress = true;
-            }
-            // Ensure connection to web socket
-            this.connectToDeltaStream({ reason: "autoReconnect" });
+    }
+    connect() {
+        if (this.closed) {
+            throw new UsageError(`The Container is closed and cannot be connected`);
+        }
+        else if (this._attachState !== AttachState.Attached) {
+            throw new UsageError(`The Container is not attached and cannot be 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.
+            this.connectInternal({ reason: "DocumentConnect", fetchOpsFromStorage: false });
+        }
+    }
+    connectInternal(args) {
+        assert(!this.closed, 0x2c5 /* "Attempting to connect() a closed Container" */);
+        assert(this._attachState === AttachState.Attached, 0x2c6 /* "Attempting to connect() a container that is not attached" */);
+        // Resume processing ops and connect to delta stream
+        this.resumeInternal(args);
+        // Set Auto Reconnect Mode
+        const mode = ReconnectMode.Enabled;
+        this.setAutoReconnectInternal(mode);
+    }
+    disconnect() {
+        if (this.closed) {
+            throw new UsageError(`The Container is closed and cannot be disconnected`);
+        }
+        else {
+            this.disconnectInternal();
         }
     }
+    disconnectInternal() {
+        assert(!this.closed, 0x2c7 /* "Attempting to disconnect() a closed Container" */);
+        // Set Auto Reconnect Mode
+        const mode = ReconnectMode.Disabled;
+        this.setAutoReconnectInternal(mode);
+    }
+    /**
+     * Have the container attempt to resume processing ops
+     * @deprecated - 0.58, This API will be removed in 1.0
+     * Use `connect()` instead
+     * See https://github.com/microsoft/FluidFramework/issues/9167 for context
+     */
     resume() {
         if (!this.closed) {
             // Note: no need to fetch ops as we do it preemptively as part of DeltaManager.attachOpHandler().
@@ -646,26 +701,12 @@ export class Container extends EventEmitterWithErrorHandling {
         // Ensure connection to web socket
         this.connectToDeltaStream(args);
     }
-    /**
-     * @deprecated 0.56, will be removed in next release from IContainerContext
-     * Raise non-critical error to host. Calling this API will not close container.
-     * For critical errors, please call Container.close(error).
-     * @param error - an error to raise
-     */
-    raiseContainerWarning(warning) {
-        // Some "warning" events come from outside the container and are logged
-        // elsewhere (e.g. summarizing container). We shouldn't log these here.
-        if (warning.logged !== true) {
-            this.logContainerError(warning);
-        }
-        this.emit("warning", warning);
-    }
     async getAbsoluteUrl(relativeUrl) {
         var _a;
         if (this.resolvedUrl === undefined) {
             return undefined;
         }
-        return this.urlResolver.getAbsoluteUrl(this.resolvedUrl, relativeUrl, (_a = this._context) === null || _a === void 0 ? void 0 : _a.codeDetails);
+        return this.urlResolver.getAbsoluteUrl(this.resolvedUrl, relativeUrl, getPackageName((_a = this._context) === null || _a === void 0 ? void 0 : _a.codeDetails));
     }
     async proposeCodeDetails(codeDetails) {
         if (!isFluidCodeDetails(codeDetails)) {
@@ -723,7 +764,7 @@ export class Container extends EventEmitterWithErrorHandling {
         if (this._resolvedUrl === undefined) {
             throw new Error("Attempting to load without a resolved url");
         }
-        this.service = await this.serviceFactory.createDocumentService(this._resolvedUrl, this.subLogger);
+        this.service = await this.serviceFactory.createDocumentService(this._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)
@@ -1023,12 +1064,17 @@ export class Container extends EventEmitterWithErrorHandling {
             this.connectionStateHandler.receivedConnectEvent(this.connectionMode, details);
         });
         deltaManager.on("disconnect", (reason) => {
-            this.manualReconnectInProgress = false;
             this.collabWindowTracker.stopSequenceNumberUpdate();
             this.connectionStateHandler.receivedDisconnectEvent(reason);
         });
         deltaManager.on("throttled", (warning) => {
-            this.raiseContainerWarning(warning);
+            const warn = warning;
+            // Some "warning" events come from outside the container and are logged
+            // elsewhere (e.g. summarizing container). We shouldn't log these here.
+            if (warn.logged !== true) {
+                this.logContainerError(warn);
+            }
+            this.emit("warning", warn);
         });
         deltaManager.on("readonly", (readonly) => {
             this.emit("readonly", readonly);
@@ -1075,9 +1121,6 @@ export class Container extends EventEmitterWithErrorHandling {
             if (this.firstConnection) {
                 connectionInitiationReason = "InitialConnect";
             }
-            else if (this.manualReconnectInProgress) {
-                connectionInitiationReason = "ManualReconnect";
-            }
             else {
                 connectionInitiationReason = "AutoReconnect";
             }
@@ -1089,7 +1132,6 @@ export class Container extends EventEmitterWithErrorHandling {
             opsBehind, online: OnlineStatus[isOnline()], lastVisible: this.lastVisible !== undefined ? performance.now() - this.lastVisible : undefined, checkpointSequenceNumber }, this._deltaManager.connectionProps));
         if (value === ConnectionState.Connected) {
             this.firstConnection = false;
-            this.manualReconnectInProgress = false;
         }
     }
     propagateConnectionState() {
@@ -1227,7 +1269,7 @@ export class Container extends EventEmitterWithErrorHandling {
         // The relative loader will proxy requests to '/' to the loader itself assuming no non-cache flags
         // are set. Global requests will still go directly to the loader
         const loader = new RelativeLoader(this, this.loader);
-        this._context = await ContainerContext.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new DeltaManagerProxy(this._deltaManager), new QuorumProxy(this.protocolHandler.quorum), loader, (warning) => this.raiseContainerWarning(warning), (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (message) => this.submitSignal(message), (error) => this.close(error), Container.version, (dirty) => this.updateDirtyContainerState(dirty), existing, pendingLocalState);
+        this._context = await ContainerContext.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new DeltaManagerProxy(this._deltaManager), new QuorumProxy(this.protocolHandler.quorum), loader, (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (message) => this.submitSignal(message), (error) => this.close(error), Container.version, (dirty) => this.updateDirtyContainerState(dirty), existing, pendingLocalState);
         this.emit("contextChanged", codeDetails);
     }
     updateDirtyContainerState(dirty) {