@fluidframework/container-loader 2.0.0-dev.2.3.0.115467 → 2.0.0-dev.4.1.0.148229

package/lib/connectionManager.js

@@ -5,10 +5,11 @@
 import { default as AbortController } from "abort-controller";
 import { assert, performance, TypedEventEmitter } from "@fluidframework/common-utils";
 import { GenericError, UsageError } from "@fluidframework/container-utils";
-import { canRetryOnError, createWriteError, createGenericNetworkError, getRetryDelayFromError, waitForConnectedState, DeltaStreamConnectionForbiddenError, logNetworkFailure, isRuntimeMessage, } from "@fluidframework/driver-utils";
+import { DriverErrorType, } from "@fluidframework/driver-definitions";
+import { canRetryOnError, createWriteError, createGenericNetworkError, getRetryDelayFromError, logNetworkFailure, isRuntimeMessage, } from "@fluidframework/driver-utils";
 import { MessageType, ScopeType, } from "@fluidframework/protocol-definitions";
-import { TelemetryLogger, normalizeError, } from "@fluidframework/telemetry-utils";
-import { ReconnectMode, } from "./contracts";
+import { TelemetryLogger, normalizeError } from "@fluidframework/telemetry-utils";
+import { ReconnectMode } from "./contracts";
 import { DeltaQueue } from "./deltaQueue";
 import { SignalType } from "./protocol";
 const MaxReconnectDelayInMs = 8000;
@@ -46,7 +47,9 @@ class NoDeltaStream extends TypedEventEmitter {
         this.version = "";
         this.initialMessages = [];
         this.initialSignals = [];
-        this.initialClients = [{ client: clientNoDeltaStream, clientId: clientIdNoDeltaStream }];
+        this.initialClients = [
+            { client: clientNoDeltaStream, clientId: clientIdNoDeltaStream },
+        ];
         this.serviceConfiguration = {
             maxMessageSize: 0,
             blockSize: 0,
@@ -68,9 +71,26 @@ class NoDeltaStream extends TypedEventEmitter {
             content: { message: "Cannot submit signal with storage-only connection", code: 403 },
         });
     }
-    get disposed() { return this._disposed; }
-    dispose() { this._disposed = true; }
+    get disposed() {
+        return this._disposed;
+    }
+    dispose() {
+        this._disposed = true;
+    }
 }
+const waitForOnline = async () => {
+    var _a;
+    // Only wait if we have a strong signal that we're offline - otherwise assume we're online.
+    if (((_a = globalThis.navigator) === null || _a === void 0 ? void 0 : _a.onLine) === false && globalThis.addEventListener !== undefined) {
+        return new Promise((resolve) => {
+            const resolveAndRemoveListener = () => {
+                resolve();
+                globalThis.removeEventListener("online", resolveAndRemoveListener);
+            };
+            globalThis.addEventListener("online", resolveAndRemoveListener);
+        });
+    }
+};
 /**
  * Implementation of IConnectionManager, used by Container class
  * Implements constant connectivity to relay service, by reconnecting in case of lost connection or error.
@@ -88,12 +108,12 @@ export class ConnectionManager {
         this.pendingReconnect = false;
         this.clientSequenceNumber = 0;
         this.clientSequenceNumberObserved = 0;
-        /** Counts the number of noops sent by the client which may not be acked. */
+        /** 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.closed = false;
+        this._disposed = false;
         this.opHandler = (documentId, messagesArg) => {
             const messages = Array.isArray(messagesArg) ? messagesArg : [messagesArg];
             this.props.incomingOpHandler(messages, "opHandler");
@@ -137,7 +157,9 @@ export class ConnectionManager {
             this.props.closeHandler(normalizeError(error));
         });
     }
-    get connectionVerboseProps() { return this._connectionVerboseProps; }
+    get connectionVerboseProps() {
+        return this._connectionVerboseProps;
+    }
     /**
      * The current connection mode, initially read.
      */
@@ -145,8 +167,13 @@ export class ConnectionManager {
         var _a, _b;
         return (_b = (_a = this.connection) === null || _a === void 0 ? void 0 : _a.mode) !== null && _b !== void 0 ? _b : "read";
     }
-    get connected() { return this.connection !== undefined; }
-    get clientId() { var _a; return (_a = this.connection) === null || _a === void 0 ? void 0 : _a.clientId; }
+    get connected() {
+        return this.connection !== undefined;
+    }
+    get clientId() {
+        var _a;
+        return (_a = this.connection) === null || _a === void 0 ? void 0 : _a.clientId;
+    }
     /**
      * Automatic reconnecting enabled or disabled.
      * If set to Never, then reconnecting will never be allowed.
@@ -178,7 +205,7 @@ export class ConnectionManager {
     /**
      * Returns set of props that can be logged in telemetry that provide some insights / statistics
      * about current or last connection (if there is no connection at the moment)
-    */
+     */
     get connectionProps() {
         return this.connection !== undefined
             ? this._connectionProps
@@ -188,7 +215,7 @@ export class ConnectionManager {
     }
     shouldJoinWrite() {
         // We don't have to wait for ack for topmost NoOps. So subtract those.
-        return this.clientSequenceNumberObserved < (this.clientSequenceNumber - this.localOpsToIgnore);
+        return (this.clientSequenceNumberObserved < this.clientSequenceNumber - this.localOpsToIgnore);
     }
     /**
      * Tells if container is in read-only mode.
@@ -221,37 +248,38 @@ export class ConnectionManager {
         return {
             claims: connection.claims,
             clientId: connection.clientId,
-            existing: connection.existing,
             checkpointSequenceNumber: connection.checkpointSequenceNumber,
-            get initialClients() { return connection.initialClients; },
+            get initialClients() {
+                return connection.initialClients;
+            },
             mode: connection.mode,
             serviceConfiguration: connection.serviceConfiguration,
             version: connection.version,
         };
     }
-    dispose(error) {
-        if (this.closed) {
+    dispose(error, switchToReadonly = true) {
+        if (this._disposed) {
             return;
         }
-        this.closed = true;
+        this._disposed = true;
         this.pendingConnection = undefined;
         // Ensure that things like triggerConnect() will short circuit
         this._reconnectMode = ReconnectMode.Never;
         this._outbound.clear();
-        const disconnectReason = error !== undefined
-            ? `Closing DeltaManager (${error.message})`
-            : "Closing DeltaManager";
+        const disconnectReason = "Closing DeltaManager";
         // This raises "disconnect" event if we have active connection.
         this.disconnectFromDeltaStream(disconnectReason);
-        // 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);
+        if (switchToReadonly) {
+            // 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);
+        }
     }
     /**
      * Enables or disables automatic reconnecting.
      * Will throw an error if reconnectMode set to Never.
-    */
+     */
     setAutoReconnect(mode) {
         assert(mode !== ReconnectMode.Never && this._reconnectMode !== ReconnectMode.Never, 0x278 /* "API is not supported for non-connecting or closed container" */);
         this._reconnectMode = mode;
@@ -323,8 +351,8 @@ export class ConnectionManager {
         });
     }
     async connectCore(connectionMode) {
-        var _a, _b;
-        assert(!this.closed, 0x26a /* "not closed" */);
+        var _a, _b, _c;
+        assert(!this._disposed, 0x26a /* "not closed" */);
         if (this.connection !== undefined) {
             return; // Connection attempt already completed successfully
         }
@@ -359,10 +387,15 @@ export class ConnectionManager {
         let lastError;
         const abortController = new AbortController();
         const abortSignal = abortController.signal;
-        this.pendingConnection = { abort: () => { abortController.abort(); }, connectionMode: requestedMode };
+        this.pendingConnection = {
+            abort: () => {
+                abortController.abort();
+            },
+            connectionMode: requestedMode,
+        };
         // This loop will keep trying to connect until successful, with a delay between each iteration.
         while (connection === undefined) {
-            if (this.closed) {
+            if (this._disposed) {
                 throw new Error("Attempting to connect a closed DeltaManager");
             }
             if (abortSignal.aborted === true) {
@@ -385,8 +418,9 @@ export class ConnectionManager {
                 }
             }
             catch (origError) {
-                if (typeof origError === "object" && origError !== null &&
-                    (origError === null || origError === void 0 ? void 0 : origError.errorType) === DeltaStreamConnectionForbiddenError.errorType) {
+                if (typeof origError === "object" &&
+                    origError !== null &&
+                    (origError === null || origError === void 0 ? void 0 : origError.errorType) === DriverErrorType.deltaStreamConnectionForbidden) {
                     connection = new NoDeltaStream();
                     requestedMode = "read";
                     break;
@@ -406,11 +440,25 @@ export class ConnectionManager {
                 }, origError);
                 lastError = origError;
                 const retryDelayFromError = getRetryDelayFromError(origError);
-                delayMs = retryDelayFromError !== null && retryDelayFromError !== void 0 ? retryDelayFromError : Math.min(delayMs * 2, MaxReconnectDelayInMs);
                 if (retryDelayFromError !== undefined) {
+                    // If the error told us to wait, then we wait.
                     this.props.reconnectionDelayHandler(retryDelayFromError, origError);
+                    await new Promise((resolve) => {
+                        setTimeout(resolve, retryDelayFromError);
+                    });
+                }
+                else if (((_c = globalThis.navigator) === null || _c === void 0 ? void 0 : _c.onLine) !== false) {
+                    // If the error didn't tell us to wait, let's still wait a little bit before retrying.
+                    // We skip this delay if we're confident we're offline, because we probably just need to wait to come back online.
+                    await new Promise((resolve) => {
+                        setTimeout(resolve, delayMs);
+                        delayMs = Math.min(delayMs * 2, MaxReconnectDelayInMs);
+                    });
                 }
-                await waitForConnectedState(delayMs);
+                // If we believe we're offline, we assume there's no point in trying until we at least think we're online.
+                // NOTE: This isn't strictly true for drivers that don't require network (e.g. local driver).  Really this logic
+                // should probably live in the driver.
+                await waitForOnline();
             }
         }
         // If we retried more than once, log an event about how long it took (this will not log to error table)
@@ -440,7 +488,7 @@ export class ConnectionManager {
      * @param args - The connection arguments
      */
     triggerConnect(connectionMode) {
-        // reconnect() has async await of waitForConnectedState(), and that causes potential race conditions
+        // reconnect() includes async awaits, and that causes potential race conditions
         // where we might already have a connection. If it were to happen, it's possible that we will connect
         // with different mode to `connectionMode`. Glancing through the caller chains, it looks like code should be
         // fine (if needed, reconnect flow will get triggered again). Places where new mode matters should encode it
@@ -479,8 +527,8 @@ export class ConnectionManager {
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         this._outbound.pause();
         this._outbound.clear();
-        this.props.disconnectHandler(reason);
         connection.dispose();
+        this.props.disconnectHandler(reason);
         this._connectionVerboseProps = {};
         return true;
     }
@@ -510,14 +558,18 @@ export class ConnectionManager {
         // But if we ask read, server can still give us write.
         const readonly = !connection.claims.scopes.includes(ScopeType.DocWrite);
         if (connection.mode !== requestedMode) {
-            this.logger.sendTelemetryEvent({ eventName: "ConnectionModeMismatch", requestedMode, mode: connection.mode });
+            this.logger.sendTelemetryEvent({
+                eventName: "ConnectionModeMismatch",
+                requestedMode,
+                mode: connection.mode,
+            });
         }
         // This connection mode validation logic is moving to the driver layer in 0.44.  These two asserts can be
         // removed after those packages have released and become ubiquitous.
         assert(requestedMode === "read" || readonly === (this.connectionMode === "read"), 0x0e7 /* "claims/connectionMode mismatch" */);
         assert(!readonly || this.connectionMode === "read", 0x0e8 /* "readonly perf with write connection" */);
         this.set_readonlyPermissions(readonly);
-        if (this.closed) {
+        if (this._disposed) {
             // Raise proper events, Log telemetry event and close connection.
             this.disconnectFromDeltaStream("ConnectionManager already closed");
             return;
@@ -550,7 +602,8 @@ export class ConnectionManager {
         this._connectionProps.connectionMode = connection.mode;
         let last = -1;
         if (initialMessages.length !== 0) {
-            this._connectionVerboseProps.connectionInitialOpsFrom = initialMessages[0].sequenceNumber;
+            this._connectionVerboseProps.connectionInitialOpsFrom =
+                initialMessages[0].sequenceNumber;
             last = initialMessages[initialMessages.length - 1].sequenceNumber;
             this._connectionVerboseProps.connectionInitialOpsTo = last + 1;
             // Update knowledge of how far we are behind, before raising "connect" event
@@ -603,8 +656,7 @@ export class ConnectionManager {
      * @returns A promise that resolves when the connection is reestablished or we stop trying
      */
     reconnectOnError(requestedMode, error) {
-        this.reconnect(requestedMode, error.message, error)
-            .catch(this.props.closeHandler);
+        this.reconnect(requestedMode, error.message, error).catch(this.props.closeHandler);
     }
     /**
      * Disconnect the current connection and reconnect.
@@ -635,14 +687,21 @@ export class ConnectionManager {
             this.props.closeHandler();
         }
         // If closed then we can't reconnect
-        if (this.closed || this.reconnectMode !== ReconnectMode.Enabled) {
+        if (this._disposed || this.reconnectMode !== ReconnectMode.Enabled) {
             return;
         }
+        // If the error tells us to wait before retrying, then do so.
         const delayMs = getRetryDelayFromError(error);
         if (error !== undefined && delayMs !== undefined) {
             this.props.reconnectionDelayHandler(delayMs, error);
-            await waitForConnectedState(delayMs);
+            await new Promise((resolve) => {
+                setTimeout(resolve, delayMs);
+            });
         }
+        // If we believe we're offline, we assume there's no point in trying again until we at least think we're online.
+        // NOTE: This isn't strictly true for drivers that don't require network (e.g. local driver).  Really this logic
+        // should probably live in the driver.
+        await waitForOnline();
         this.triggerConnect(requestedMode);
     }
     prepareMessageToSend(message) {
@@ -694,12 +753,15 @@ export class ConnectionManager {
         if (this.connectionMode === "read") {
             if (!this.pendingReconnect) {
                 this.pendingReconnect = true;
-                Promise.resolve().then(async () => {
-                    if (this.pendingReconnect) { // still valid?
+                Promise.resolve()
+                    .then(async () => {
+                    if (this.pendingReconnect) {
+                        // still valid?
                         await this.reconnect("write", // connectionMode
                         "Switch to write");
                     }
-                }).catch(() => { });
+                })
+                    .catch(() => { });
             }
             return;
         }
@@ -709,7 +771,8 @@ export class ConnectionManager {
     beforeProcessingIncomingOp(message) {
         // if we have connection, and message is local, then we better treat is as local!
         assert(this.clientId !== message.clientId || this.lastSubmittedClientId === message.clientId, 0x0ee /* "Not accounting local messages correctly" */);
-        if (this.lastSubmittedClientId !== undefined && this.lastSubmittedClientId === message.clientId) {
+        if (this.lastSubmittedClientId !== undefined &&
+            this.lastSubmittedClientId === message.clientId) {
             const clientSequenceNumber = message.clientSequenceNumber;
             assert(this.clientSequenceNumberObserved < clientSequenceNumber, 0x0ef /* "client seq# not growing" */);
             assert(clientSequenceNumber <= this.clientSequenceNumber, 0x0f0 /* "Incoming local client seq# > generated by this client" */);