@fluidframework/container-loader 0.58.2002 → 0.59.1000

package/dist/container.js

@@ -12,7 +12,6 @@ exports.Container = exports.waitContainerToCatchUp = exports.ConnectionState = v
 const merge_1 = __importDefault(require("lodash/merge"));
 const uuid_1 = require("uuid");
 const common_utils_1 = require("@fluidframework/common-utils");
-const core_interfaces_1 = require("@fluidframework/core-interfaces");
 const container_definitions_1 = require("@fluidframework/container-definitions");
 const container_utils_1 = require("@fluidframework/container-utils");
 const driver_utils_1 = require("@fluidframework/driver-utils");
@@ -109,6 +108,7 @@ exports.waitContainerToCatchUp = waitContainerToCatchUp;
 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";
 class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     constructor(loader, config) {
         var _a, _b, _c;
@@ -126,7 +126,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this._attachState = container_definitions_1.AttachState.Detached;
         this.resumedOpProcessingAfterLoad = false;
         this.firstConnection = true;
-        this.manualReconnectInProgress = false;
         this.connectionTransitionTimes = [];
         this.messageCountAfterDisconnection = 0;
         this.attachStarted = false;
@@ -353,7 +352,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     get context() {
         if (this._context === undefined) {
-            throw new Error("Attempted to access context before it was defined");
+            throw new container_utils_1.GenericError("Attempted to access context before it was defined");
         }
         return this._context;
     }
@@ -374,6 +373,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     get readOnlyInfo() {
         return this._deltaManager.readOnlyInfo;
     }
+    get closeSignal() {
+        return this._deltaManager.closeAbortController.signal;
+    }
     /**
      * Tracks host requiring read-only mode.
      */
@@ -548,7 +550,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 const createNewResolvedUrl = await this.urlResolver.resolve(request);
                 driver_utils_1.ensureFluidResolvedUrl(createNewResolvedUrl);
                 if (this.service === undefined) {
-                    this.service = await driver_utils_1.runWithRetry(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger), "containerAttach", this.mc.logger, {});
+                    common_utils_1.assert(this.client.details.type !== summarizerClientType, 0x2c4 /* "client should not be summarizer before container is created" */);
+                    this.service = await driver_utils_1.runWithRetry(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger, false), "containerAttach", this.mc.logger, {
+                        cancel: this.closeSignal,
+                    });
                 }
                 const resolvedUrl = this.service.resolvedUrl;
                 driver_utils_1.ensureFluidResolvedUrl(resolvedUrl);
@@ -604,11 +609,28 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     async request(path) {
         return telemetry_utils_1.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 ? contracts_1.ReconnectMode.Enabled : contracts_1.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 === container_definitions_1.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;
@@ -617,23 +639,56 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         const duration = now - this.setAutoReconnectTime;
         this.setAutoReconnectTime = now;
         this.mc.logger.sendTelemetryEvent({
-            eventName: reconnect ? "AutoReconnectEnabled" : "AutoReconnectDisabled",
+            eventName: mode === contracts_1.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 === container_definitions_1.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 container_utils_1.UsageError(`The Container is closed and cannot be connected`);
+        }
+        else if (this._attachState !== container_definitions_1.AttachState.Attached) {
+            throw new container_utils_1.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) {
+        common_utils_1.assert(!this.closed, 0x2c5 /* "Attempting to connect() a closed Container" */);
+        common_utils_1.assert(this._attachState === container_definitions_1.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 = contracts_1.ReconnectMode.Enabled;
+        this.setAutoReconnectInternal(mode);
+    }
+    disconnect() {
+        if (this.closed) {
+            throw new container_utils_1.UsageError(`The Container is closed and cannot be disconnected`);
+        }
+        else {
+            this.disconnectInternal();
         }
     }
+    disconnectInternal() {
+        common_utils_1.assert(!this.closed, 0x2c7 /* "Attempting to disconnect() a closed Container" */);
+        // Set Auto Reconnect Mode
+        const mode = contracts_1.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().
@@ -653,29 +708,15 @@ class Container extends telemetry_utils_1.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, contracts_1.getPackageName((_a = this._context) === null || _a === void 0 ? void 0 : _a.codeDetails));
     }
     async proposeCodeDetails(codeDetails) {
-        if (!core_interfaces_1.isFluidCodeDetails(codeDetails)) {
+        if (!container_definitions_1.isFluidCodeDetails(codeDetails)) {
             throw new Error("Provided codeDetails are not IFluidCodeDetails");
         }
         if (this.codeLoader.IFluidCodeDetailsComparer) {
@@ -730,7 +771,7 @@ class Container extends telemetry_utils_1.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)
@@ -934,7 +975,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         });
         protocol.quorum.on("approveProposal", (sequenceNumber, key, value) => {
             if (key === "code" || key === "code2") {
-                if (!core_interfaces_1.isFluidCodeDetails(value)) {
+                if (!container_definitions_1.isFluidCodeDetails(value)) {
                     this.mc.logger.sendErrorEvent({
                         eventName: "CodeProposalNotIFluidCodeDetails",
                     });
@@ -1030,12 +1071,17 @@ class Container extends telemetry_utils_1.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);
@@ -1082,9 +1128,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             if (this.firstConnection) {
                 connectionInitiationReason = "InitialConnect";
             }
-            else if (this.manualReconnectInProgress) {
-                connectionInitiationReason = "ManualReconnect";
-            }
             else {
                 connectionInitiationReason = "AutoReconnect";
             }
@@ -1096,7 +1139,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             opsBehind, online: driver_utils_1.OnlineStatus[driver_utils_1.isOnline()], lastVisible: this.lastVisible !== undefined ? common_utils_1.performance.now() - this.lastVisible : undefined, checkpointSequenceNumber }, this._deltaManager.connectionProps));
         if (value === ConnectionState.Connected) {
             this.firstConnection = false;
-            this.manualReconnectInProgress = false;
         }
     }
     propagateConnectionState() {
@@ -1234,7 +1276,7 @@ class Container extends telemetry_utils_1.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 loader_1.RelativeLoader(this, this.loader);
-        this._context = await containerContext_1.ContainerContext.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new deltaManagerProxy_1.DeltaManagerProxy(this._deltaManager), new quorum_1.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_1.ContainerContext.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new deltaManagerProxy_1.DeltaManagerProxy(this._deltaManager), new quorum_1.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) {