@fluidframework/container-loader 2.0.0-dev.6.4.0.192049 → 2.0.0-dev.7.2.0.204906

package/dist/connectionManager.js

@@ -5,8 +5,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectionManager = void 0;
+const core_interfaces_1 = require("@fluidframework/core-interfaces");
 const core_utils_1 = require("@fluidframework/core-utils");
 const client_utils_1 = require("@fluid-internal/client-utils");
+const driver_definitions_1 = require("@fluidframework/driver-definitions");
 const driver_utils_1 = require("@fluidframework/driver-utils");
 const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
@@ -36,9 +38,15 @@ const clientNoDeltaStream = {
 };
 const clientIdNoDeltaStream = "storage-only client";
 class NoDeltaStream extends client_utils_1.TypedEventEmitter {
-    constructor(storageOnlyReason) {
+    /**
+     * Connection which is not connected to socket.
+     * @param storageOnlyReason - Reason on why the connection to delta stream is not allowed.
+     * @param readonlyConnectionReason - reason/error if any which lead to using NoDeltaStream.
+     */
+    constructor(storageOnlyReason, readonlyConnectionReason) {
         super();
         this.storageOnlyReason = storageOnlyReason;
+        this.readonlyConnectionReason = readonlyConnectionReason;
         this.clientId = clientIdNoDeltaStream;
         this.claims = {
             scopes: [protocol_definitions_1.ScopeType.DocRead],
@@ -101,67 +109,6 @@ const waitForOnline = async () => {
  * Exposes various controls to influence this process, including manual reconnects, forced read-only mode, etc.
  */
 class ConnectionManager {
-    constructor(serviceProvider, containerDirty, client, reconnectAllowed, logger, props) {
-        this.serviceProvider = serviceProvider;
-        this.containerDirty = containerDirty;
-        this.client = client;
-        this.logger = logger;
-        this.props = props;
-        /** tracks host requiring read-only mode. */
-        this._forceReadonly = false;
-        /** True if there is pending (async) reconnection from "read" to "write" */
-        this.pendingReconnect = false;
-        this.clientSequenceNumber = 0;
-        this.clientSequenceNumberObserved = 0;
-        /** Counts the number of non-runtime ops sent by the client which may not be acked. */
-        this.localOpsToIgnore = 0;
-        this.connectFirstConnection = true;
-        this._connectionVerboseProps = {};
-        this._connectionProps = {};
-        this._disposed = false;
-        this.opHandler = (documentId, messagesArg) => {
-            const messages = Array.isArray(messagesArg) ? messagesArg : [messagesArg];
-            this.props.incomingOpHandler(messages, "opHandler");
-        };
-        // Always connect in write mode after getting nacked.
-        this.nackHandler = (documentId, messages) => {
-            const message = messages[0];
-            if (this._readonlyPermissions === true) {
-                this.props.closeHandler((0, driver_utils_1.createWriteError)("writeOnReadOnlyDocument", { driverVersion: undefined }));
-                return;
-            }
-            const reconnectInfo = getNackReconnectInfo(message.content);
-            // If the nack indicates we cannot retry, then close the container outright
-            if (!reconnectInfo.canRetry) {
-                this.props.closeHandler(reconnectInfo);
-                return;
-            }
-            this.reconnectOnError("write", reconnectInfo);
-        };
-        // Connection mode is always read on disconnect/error unless the system mode was write.
-        this.disconnectHandlerInternal = (disconnectReason) => {
-            // Note: we might get multiple disconnect calls on same socket, as early disconnect notification
-            // ("server_disconnect", ODSP-specific) is mapped to "disconnect"
-            this.reconnectOnError(this.defaultReconnectionMode, disconnectReason);
-        };
-        this.errorHandler = (error) => {
-            this.reconnectOnError(this.defaultReconnectionMode, error);
-        };
-        this.clientDetails = this.client.details;
-        this.defaultReconnectionMode = this.client.mode;
-        this._reconnectMode = reconnectAllowed ? contracts_1.ReconnectMode.Enabled : contracts_1.ReconnectMode.Never;
-        // Outbound message queue. The outbound queue is represented as a queue of an array of ops. Ops contained
-        // within an array *must* fit within the maxMessageSize and are guaranteed to be ordered sequentially.
-        this._outbound = new deltaQueue_1.DeltaQueue((messages) => {
-            if (this.connection === undefined) {
-                throw new Error("Attempted to submit an outbound message without connection");
-            }
-            this.connection.submit(messages);
-        });
-        this._outbound.on("error", (error) => {
-            this.props.closeHandler((0, telemetry_utils_1.normalizeError)(error));
-        });
-    }
     get connectionVerboseProps() {
         return this._connectionVerboseProps;
     }
@@ -275,6 +222,71 @@ class ConnectionManager {
             reason,
         };
     }
+    constructor(serviceProvider, containerDirty, client, reconnectAllowed, logger, props) {
+        this.serviceProvider = serviceProvider;
+        this.containerDirty = containerDirty;
+        this.client = client;
+        this.logger = logger;
+        this.props = props;
+        /** tracks host requiring read-only mode. */
+        this._forceReadonly = false;
+        /** True if there is pending (async) reconnection from "read" to "write" */
+        this.pendingReconnect = false;
+        this.clientSequenceNumber = 0;
+        this.clientSequenceNumberObserved = 0;
+        /** Counts the number of non-runtime ops sent by the client which may not be acked. */
+        this.localOpsToIgnore = 0;
+        this.connectFirstConnection = true;
+        this._connectionVerboseProps = {};
+        this._connectionProps = {};
+        this._disposed = false;
+        this.opHandler = (documentId, messagesArg) => {
+            const messages = Array.isArray(messagesArg) ? messagesArg : [messagesArg];
+            this.props.incomingOpHandler(messages, "opHandler");
+        };
+        this.signalHandler = (signalsArg) => {
+            const signals = Array.isArray(signalsArg) ? signalsArg : [signalsArg];
+            this.props.signalHandler(signals);
+        };
+        // Always connect in write mode after getting nacked.
+        this.nackHandler = (documentId, messages) => {
+            const message = messages[0];
+            if (this._readonlyPermissions === true) {
+                this.props.closeHandler((0, driver_utils_1.createWriteError)("writeOnReadOnlyDocument", { driverVersion: undefined }));
+                return;
+            }
+            const reconnectInfo = getNackReconnectInfo(message.content);
+            // If the nack indicates we cannot retry, then close the container outright
+            if (!reconnectInfo.canRetry) {
+                this.props.closeHandler(reconnectInfo);
+                return;
+            }
+            this.reconnectOnError("write", reconnectInfo);
+        };
+        // Connection mode is always read on disconnect/error unless the system mode was write.
+        this.disconnectHandlerInternal = (disconnectReason) => {
+            // Note: we might get multiple disconnect calls on same socket, as early disconnect notification
+            // ("server_disconnect", ODSP-specific) is mapped to "disconnect"
+            this.reconnectOnError(this.defaultReconnectionMode, disconnectReason);
+        };
+        this.errorHandler = (error) => {
+            this.reconnectOnError(this.defaultReconnectionMode, error);
+        };
+        this.clientDetails = this.client.details;
+        this.defaultReconnectionMode = this.client.mode;
+        this._reconnectMode = reconnectAllowed ? contracts_1.ReconnectMode.Enabled : contracts_1.ReconnectMode.Never;
+        // Outbound message queue. The outbound queue is represented as a queue of an array of ops. Ops contained
+        // within an array *must* fit within the maxMessageSize and are guaranteed to be ordered sequentially.
+        this._outbound = new deltaQueue_1.DeltaQueue((messages) => {
+            if (this.connection === undefined) {
+                throw new Error("Attempted to submit an outbound message without connection");
+            }
+            this.connection.submit(messages);
+        });
+        this._outbound.on("error", (error) => {
+            this.props.closeHandler((0, telemetry_utils_1.normalizeError)(error));
+        });
+    }
     dispose(error, switchToReadonly = true) {
         if (this._disposed) {
             return;
@@ -294,7 +306,7 @@ class ConnectionManager {
             // Notify everyone we are in read-only state.
             // Useful for data stores in case we hit some critical error,
             // to switch to a mode where user edits are not accepted
-            this.set_readonlyPermissions(true, oldReadonlyValue);
+            this.set_readonlyPermissions(true, oldReadonlyValue, disconnectReason);
         }
     }
     /**
@@ -310,21 +322,7 @@ class ConnectionManager {
         }
     }
     /**
-     * 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.
+     * {@inheritDoc Container.forceReadonly}
      */
     forceReadonly(readonly) {
         if (readonly !== this._forceReadonly) {
@@ -358,10 +356,10 @@ class ConnectionManager {
             }
         }
     }
-    set_readonlyPermissions(newReadonlyValue, oldReadonlyValue) {
+    set_readonlyPermissions(newReadonlyValue, oldReadonlyValue, readonlyConnectionReason) {
         this._readonlyPermissions = newReadonlyValue;
         if (oldReadonlyValue !== this.readonly) {
-            this.props.readonlyChangeHandler(this.readonly);
+            this.props.readonlyChangeHandler(this.readonly, readonlyConnectionReason);
         }
     }
     connect(reason, connectionMode) {
@@ -439,10 +437,29 @@ class ConnectionManager {
                     this.logger.sendTelemetryEvent({ eventName: "ReceivedClosedConnection" });
                     connection = undefined;
                 }
+                this.logger.sendTelemetryEvent({
+                    eventName: "ConnectionReceived",
+                    connected: connection !== undefined && connection.disposed === false,
+                }, undefined, core_interfaces_1.LogLevel.verbose);
             }
             catch (origError) {
                 if ((0, utils_1.isDeltaStreamConnectionForbiddenError)(origError)) {
-                    connection = new NoDeltaStream(origError.storageOnlyReason);
+                    connection = new NoDeltaStream(origError.storageOnlyReason, {
+                        text: origError.message,
+                        error: origError,
+                    });
+                    requestedMode = "read";
+                    break;
+                }
+                else if ((0, telemetry_utils_1.isFluidError)(origError) &&
+                    // eslint-disable-next-line import/no-deprecated
+                    origError.errorType === driver_definitions_1.DriverErrorType.outOfStorageError) {
+                    // If we get out of storage error from calling joinsession, then use the NoDeltaStream object so
+                    // that user can at least load the container.
+                    connection = new NoDeltaStream(undefined, {
+                        text: origError.message,
+                        error: origError,
+                    });
                     requestedMode = "read";
                     break;
                 }
@@ -499,8 +516,8 @@ class ConnectionManager {
                 duration: (0, telemetry_utils_1.formatTick)(client_utils_1.performance.now() - connectStartTime),
             }, lastError);
         }
-        // Check for abort signal after while loop as well
-        if (abortSignal.aborted === true) {
+        // Check for abort signal after while loop as well or we've been disposed
+        if (abortSignal.aborted === true || this._disposed) {
             connection.dispose();
             this.logger.sendTelemetryEvent({
                 eventName: "ConnectionAttemptCancelled",
@@ -550,7 +567,7 @@ class ConnectionManager {
         this.connection = undefined;
         // Remove listeners first so we don't try to retrigger this flow accidentally through reconnectOnError
         connection.off("op", this.opHandler);
-        connection.off("signal", this.props.signalHandler);
+        connection.off("signal", this.signalHandler);
         connection.off("nack", this.nackHandler);
         connection.off("disconnect", this.disconnectHandlerInternal);
         connection.off("error", this.errorHandler);
@@ -603,7 +620,7 @@ class ConnectionManager {
         // removed after those packages have released and become ubiquitous.
         (0, core_utils_1.assert)(requestedMode === "read" || readonly === (this.connectionMode === "read"), 0x0e7 /* "claims/connectionMode mismatch" */);
         (0, core_utils_1.assert)(!readonly || this.connectionMode === "read", 0x0e8 /* "readonly perf with write connection" */);
-        this.set_readonlyPermissions(readonly, oldReadonlyValue);
+        this.set_readonlyPermissions(readonly, oldReadonlyValue, isNoDeltaStreamConnection(connection) ? connection.readonlyConnectionReason : undefined);
         if (this._disposed) {
             // Raise proper events, Log telemetry event and close connection.
             this.disconnectFromDeltaStream({ text: "ConnectionManager already closed" });
@@ -611,7 +628,7 @@ class ConnectionManager {
         }
         this._outbound.resume();
         connection.on("op", this.opHandler);
-        connection.on("signal", this.props.signalHandler);
+        connection.on("signal", this.signalHandler);
         connection.on("nack", this.nackHandler);
         connection.on("disconnect", this.disconnectHandlerInternal);
         connection.on("error", this.errorHandler);
@@ -662,26 +679,26 @@ class ConnectionManager {
                 type: protocol_1.SignalType.Clear,
             }),
         };
-        this.props.signalHandler(clearSignal);
-        for (const priorClient of connection.initialClients ?? []) {
-            const joinSignal = {
-                clientId: null,
-                content: JSON.stringify({
-                    type: protocol_1.SignalType.ClientJoin,
-                    content: priorClient, // ISignalClient
-                }),
-            };
-            this.props.signalHandler(joinSignal);
+        // list of signals to process due to this new connection
+        let signalsToProcess = [clearSignal];
+        const clientJoinSignals = (connection.initialClients ?? []).map((priorClient) => ({
+            clientId: null,
+            content: JSON.stringify({
+                type: protocol_1.SignalType.ClientJoin,
+                content: priorClient, // ISignalClient
+            }),
+        }));
+        if (clientJoinSignals.length > 0) {
+            signalsToProcess = signalsToProcess.concat(clientJoinSignals);
         }
         // Unfortunately, there is no defined order between initialSignals (including join & leave signals)
         // and connection.initialClients. In practice, connection.initialSignals quite often contains join signal
         // for "self" and connection.initialClients does not contain "self", so we have to process them after
         // "clear" signal above.
-        if (connection.initialSignals !== undefined) {
-            for (const signal of connection.initialSignals) {
-                this.props.signalHandler(signal);
-            }
+        if (connection.initialSignals !== undefined && connection.initialSignals.length > 0) {
+            signalsToProcess = signalsToProcess.concat(connection.initialSignals);
         }
+        this.props.signalHandler(signalsToProcess);
     }
     /**
      * Disconnect the current connection and reconnect. Closes the container if it fails.