@fluidframework/container-loader 2.0.0-rc.2.0.1 → 2.0.0-rc.3.0.0

package/dist/connectionManager.js

@@ -5,13 +5,13 @@
  */
 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 core_interfaces_1 = require("@fluidframework/core-interfaces");
+const internal_1 = require("@fluidframework/core-utils/internal");
 const driver_definitions_1 = require("@fluidframework/driver-definitions");
-const driver_utils_1 = require("@fluidframework/driver-utils");
+const internal_2 = require("@fluidframework/driver-utils/internal");
 const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
-const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
+const internal_3 = require("@fluidframework/telemetry-utils/internal");
 const contracts_js_1 = require("./contracts.js");
 const deltaQueue_js_1 = require("./deltaQueue.js");
 const protocol_js_1 = require("./protocol.js");
@@ -24,7 +24,7 @@ function getNackReconnectInfo(nackContent) {
     const message = `Nack (${nackContent.type}): ${nackContent.message}`;
     const canRetry = nackContent.code !== 403;
     const retryAfterMs = nackContent.retryAfter !== undefined ? nackContent.retryAfter * 1000 : undefined;
-    return (0, driver_utils_1.createGenericNetworkError)(message, { canRetry, retryAfterMs }, { statusCode: nackContent.code, driverVersion: undefined });
+    return (0, internal_2.createGenericNetworkError)(message, { canRetry, retryAfterMs }, { statusCode: nackContent.code, driverVersion: undefined });
 }
 /**
  * Implementation of IDocumentDeltaConnection that does not support submitting
@@ -253,7 +253,7 @@ class ConnectionManager {
         this.nackHandler = (documentId, messages) => {
             const message = messages[0];
             if (this._readonlyPermissions === true) {
-                this.props.closeHandler((0, driver_utils_1.createWriteError)("writeOnReadOnlyDocument", { driverVersion: undefined }));
+                this.props.closeHandler((0, internal_2.createWriteError)("writeOnReadOnlyDocument", { driverVersion: undefined }));
                 return;
             }
             const reconnectInfo = getNackReconnectInfo(message.content);
@@ -285,7 +285,7 @@ class ConnectionManager {
             this.connection.submit(messages);
         });
         this._outbound.on("error", (error) => {
-            this.props.closeHandler((0, telemetry_utils_1.normalizeError)(error));
+            this.props.closeHandler((0, internal_3.normalizeError)(error));
         });
     }
     dispose(error, switchToReadonly = true) {
@@ -315,7 +315,7 @@ class ConnectionManager {
      * Will throw an error if reconnectMode set to Never.
      */
     setAutoReconnect(mode, reason) {
-        (0, core_utils_1.assert)(mode !== contracts_js_1.ReconnectMode.Never && this._reconnectMode !== contracts_js_1.ReconnectMode.Never, 0x278 /* "API is not supported for non-connecting or closed container" */);
+        (0, internal_1.assert)(mode !== contracts_js_1.ReconnectMode.Never && this._reconnectMode !== contracts_js_1.ReconnectMode.Never, 0x278 /* "API is not supported for non-connecting or closed container" */);
         this._reconnectMode = mode;
         if (mode !== contracts_js_1.ReconnectMode.Enabled) {
             // immediately disconnect - do not rely on service eventually dropping connection.
@@ -336,7 +336,7 @@ class ConnectionManager {
         this._forceReadonly = readonly;
         if (oldValue !== this.readonly) {
             if (this._reconnectMode === contracts_js_1.ReconnectMode.Never) {
-                throw new telemetry_utils_1.UsageError("API is not supported for non-connecting or closed container");
+                throw new internal_3.UsageError("API is not supported for non-connecting or closed container");
             }
             let reconnect = false;
             if (this.readonly === true) {
@@ -365,12 +365,12 @@ class ConnectionManager {
     }
     connect(reason, connectionMode) {
         this.connectCore(reason, connectionMode).catch((e) => {
-            const normalizedError = (0, telemetry_utils_1.normalizeError)(e, { props: fatalConnectErrorProp });
+            const normalizedError = (0, internal_3.normalizeError)(e, { props: fatalConnectErrorProp });
             this.props.closeHandler(normalizedError);
         });
     }
     async connectCore(reason, connectionMode) {
-        (0, core_utils_1.assert)(!this._disposed, 0x26a /* "not closed" */);
+        (0, internal_1.assert)(!this._disposed, 0x26a /* "not closed" */);
         if (this.connection !== undefined) {
             return; // Connection attempt already completed successfully
         }
@@ -378,7 +378,7 @@ class ConnectionManager {
         if (this.pendingConnection !== undefined) {
             pendingConnectionMode = this.pendingConnection.connectionMode;
             this.cancelConnection(reason); // Throw out in-progress connection attempt in favor of new attempt
-            (0, core_utils_1.assert)(this.pendingConnection === undefined, 0x344 /* this.pendingConnection should be undefined */);
+            (0, internal_1.assert)(this.pendingConnection === undefined, 0x344 /* this.pendingConnection should be undefined */);
         }
         // If there is no specified ConnectionMode, try the previous mode, if there is no previous mode use default
         let requestedMode = connectionMode ?? pendingConnectionMode ?? this.defaultReconnectionMode;
@@ -391,12 +391,13 @@ class ConnectionManager {
             requestedMode = "write";
         }
         const docService = this.serviceProvider();
-        (0, core_utils_1.assert)(docService !== undefined, 0x2a7 /* "Container is not attached" */);
+        (0, internal_1.assert)(docService !== undefined, 0x2a7 /* "Container is not attached" */);
+        this.props.establishConnectionHandler(reason);
         let connection;
         if (docService.policies?.storageOnly === true) {
             connection = new NoDeltaStream();
             this.setupNewSuccessfulConnection(connection, "read", reason);
-            (0, core_utils_1.assert)(this.pendingConnection === undefined, 0x2b3 /* "logic error" */);
+            (0, internal_1.assert)(this.pendingConnection === undefined, 0x2b3 /* "logic error" */);
             return;
         }
         let delayMs = InitialReconnectDelayInMs;
@@ -411,7 +412,6 @@ class ConnectionManager {
             },
             connectionMode: requestedMode,
         };
-        this.props.establishConnectionHandler(reason);
         // This loop will keep trying to connect until successful, with a delay between each iteration.
         while (connection === undefined) {
             if (this._disposed) {
@@ -421,7 +421,7 @@ class ConnectionManager {
                 this.logger.sendTelemetryEvent({
                     eventName: "ConnectionAttemptCancelled",
                     attempts: connectRepeatCount,
-                    duration: (0, telemetry_utils_1.formatTick)(client_utils_1.performance.now() - connectStartTime),
+                    duration: (0, internal_3.formatTick)(client_utils_1.performance.now() - connectStartTime),
                     connectionEstablished: false,
                 });
                 return;
@@ -456,7 +456,7 @@ class ConnectionManager {
                     requestedMode = "read";
                     break;
                 }
-                else if ((0, telemetry_utils_1.isFluidError)(origError) &&
+                else if ((0, internal_3.isFluidError)(origError) &&
                     origError.errorType === driver_definitions_1.DriverErrorTypes.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.
@@ -468,28 +468,33 @@ class ConnectionManager {
                     break;
                 }
                 // Socket.io error when we connect to wrong socket, or hit some multiplexing bug
-                if (!(0, driver_utils_1.canRetryOnError)(origError)) {
-                    const error = (0, telemetry_utils_1.normalizeError)(origError, { props: fatalConnectErrorProp });
+                if (!(0, internal_2.canRetryOnError)(origError)) {
+                    const error = (0, internal_3.normalizeError)(origError, { props: fatalConnectErrorProp });
                     this.props.closeHandler(error);
                     throw error;
                 }
                 // Since the error is retryable this will not log to the error table
-                (0, driver_utils_1.logNetworkFailure)(this.logger, {
+                (0, internal_2.logNetworkFailure)(this.logger, {
                     attempts: connectRepeatCount,
                     delay: delayMs,
                     eventName: "DeltaConnectionFailureToConnect",
-                    duration: (0, telemetry_utils_1.formatTick)(client_utils_1.performance.now() - connectStartTime),
+                    duration: (0, internal_3.formatTick)(client_utils_1.performance.now() - connectStartTime),
                 }, origError);
                 lastError = origError;
+                // We will not perform retries if the container disconnected and the ReconnectMode is set to Disabled or Never
+                // so break out of the re-connecting while-loop after first attempt
+                if (this.reconnectMode !== contracts_js_1.ReconnectMode.Enabled) {
+                    return;
+                }
                 const waitStartTime = client_utils_1.performance.now();
-                const retryDelayFromError = (0, driver_utils_1.getRetryDelayFromError)(origError);
+                const retryDelayFromError = (0, internal_2.getRetryDelayFromError)(origError);
                 // If the error told us to wait or browser signals us that we are offline, then calculate the time we
                 // want to wait for before retrying. then we wait for that time. If the error didn't tell us to wait,
                 // let's still wait a little bit before retrying. We can skip this delay if we're confident we're offline,
                 // because we probably just need to wait to come back online. But we never have strong signal of being
                 // offline, so we at least wait for sometime.
                 if (retryDelayFromError !== undefined || globalThis.navigator?.onLine !== false) {
-                    delayMs = (0, driver_utils_1.calculateMaxWaitTime)(delayMs, origError);
+                    delayMs = (0, internal_2.calculateMaxWaitTime)(delayMs, origError);
                 }
                 // Raise event in case the delay was there from the error.
                 if (retryDelayFromError !== undefined) {
@@ -514,10 +519,10 @@ class ConnectionManager {
         }
         // If we retried more than once, log an event about how long it took (this will not log to error table)
         if (connectRepeatCount > 1) {
-            (0, driver_utils_1.logNetworkFailure)(this.logger, {
+            (0, internal_2.logNetworkFailure)(this.logger, {
                 eventName: "MultipleDeltaConnectionFailures",
                 attempts: connectRepeatCount,
-                duration: (0, telemetry_utils_1.formatTick)(client_utils_1.performance.now() - connectStartTime),
+                duration: (0, internal_3.formatTick)(client_utils_1.performance.now() - connectStartTime),
             }, lastError);
         }
         // Check for abort signal after while loop as well or we've been disposed
@@ -526,7 +531,7 @@ class ConnectionManager {
             this.logger.sendTelemetryEvent({
                 eventName: "ConnectionAttemptCancelled",
                 attempts: connectRepeatCount,
-                duration: (0, telemetry_utils_1.formatTick)(client_utils_1.performance.now() - connectStartTime),
+                duration: (0, internal_3.formatTick)(client_utils_1.performance.now() - connectStartTime),
                 connectionEstablished: true,
             });
             return;
@@ -565,7 +570,7 @@ class ConnectionManager {
             }
             return false;
         }
-        (0, core_utils_1.assert)(this.pendingConnection === undefined, 0x27b /* "reentrancy may result in incorrect behavior" */);
+        (0, internal_1.assert)(this.pendingConnection === undefined, 0x27b /* "reentrancy may result in incorrect behavior" */);
         const connection = this.connection;
         // Avoid any re-entrancy - clear object reference
         this.connection = undefined;
@@ -588,7 +593,7 @@ class ConnectionManager {
      * Cancel in-progress connection attempt.
      */
     cancelConnection(reason) {
-        (0, core_utils_1.assert)(this.pendingConnection !== undefined, 0x345 /* this.pendingConnection is undefined when trying to cancel */);
+        (0, internal_1.assert)(this.pendingConnection !== undefined, 0x345 /* this.pendingConnection is undefined when trying to cancel */);
         this.pendingConnection.abort();
         this.pendingConnection = undefined;
         this.logger.sendTelemetryEvent({ eventName: "ConnectionCancelReceived" });
@@ -604,8 +609,8 @@ class ConnectionManager {
      */
     setupNewSuccessfulConnection(connection, requestedMode, reason) {
         // Old connection should have been cleaned up before establishing a new one
-        (0, core_utils_1.assert)(this.connection === undefined, 0x0e6 /* "old connection exists on new connection setup" */);
-        (0, core_utils_1.assert)(!connection.disposed, 0x28a /* "can't be disposed - Callers need to ensure that!" */);
+        (0, internal_1.assert)(this.connection === undefined, 0x0e6 /* "old connection exists on new connection setup" */);
+        (0, internal_1.assert)(!connection.disposed, 0x28a /* "can't be disposed - Callers need to ensure that!" */);
         this.pendingConnection = undefined;
         const oldReadonlyValue = this.readonly;
         this.connection = connection;
@@ -622,8 +627,8 @@ class ConnectionManager {
         }
         // 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.
-        (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" */);
+        (0, internal_1.assert)(requestedMode === "read" || readonly === (this.connectionMode === "read"), 0x0e7 /* "claims/connectionMode mismatch" */);
+        (0, internal_1.assert)(!readonly || this.connectionMode === "read", 0x0e8 /* "readonly perf with write connection" */);
         this.set_readonlyPermissions(readonly, oldReadonlyValue, isNoDeltaStreamConnection(connection) ? connection.readonlyConnectionReason : undefined);
         if (this._disposed) {
             // Raise proper events, Log telemetry event and close connection.
@@ -725,7 +730,7 @@ class ConnectionManager {
         // We quite often get protocol errors before / after observing nack/disconnect
         // we do not want to run through same sequence twice.
         // If we're already disconnected/disconnecting it's not appropriate to call this again.
-        (0, core_utils_1.assert)(this.connection !== undefined, 0x0eb /* "Missing connection for reconnect" */);
+        (0, internal_1.assert)(this.connection !== undefined, 0x0eb /* "Missing connection for reconnect" */);
         this.disconnectFromDeltaStream(reason);
         // We will always trigger reconnect, even if canRetry is false.
         // Any truly fatal error state will result in container close upon attempted reconnect,
@@ -747,7 +752,7 @@ class ConnectionManager {
             return;
         }
         // If the error tells us to wait before retrying, then do so.
-        const delayMs = (0, driver_utils_1.getRetryDelayFromError)(reason.error);
+        const delayMs = (0, internal_2.getRetryDelayFromError)(reason.error);
         if (reason.error !== undefined && delayMs !== undefined) {
             this.props.reconnectionDelayHandler(delayMs, reason.error);
             await new Promise((resolve) => {
@@ -767,8 +772,8 @@ class ConnectionManager {
     }
     prepareMessageToSend(message) {
         if (this.readonly === true) {
-            (0, core_utils_1.assert)(this.readOnlyInfo.readonly === true, 0x1f0 /* "Unexpected mismatch in readonly" */);
-            const error = new telemetry_utils_1.GenericError("deltaManagerReadonlySubmit", undefined /* error */, {
+            (0, internal_1.assert)(this.readOnlyInfo.readonly === true, 0x1f0 /* "Unexpected mismatch in readonly" */);
+            const error = new internal_3.GenericError("deltaManagerReadonlySubmit", undefined /* error */, {
                 readonly: this.readOnlyInfo.readonly,
                 forcedReadonly: this.readOnlyInfo.forced,
                 readonlyPermissions: this.readOnlyInfo.permissions,
@@ -781,13 +786,13 @@ class ConnectionManager {
         // reset clientSequenceNumber if we are using new clientId.
         // we keep info about old connection as long as possible to be able to account for all non-acked ops
         // that we pick up on next connection.
-        (0, core_utils_1.assert)(!!this.connection, 0x0e4 /* "Lost old connection!" */);
+        (0, internal_1.assert)(!!this.connection, 0x0e4 /* "Lost old connection!" */);
         if (this.lastSubmittedClientId !== this.connection?.clientId) {
             this.lastSubmittedClientId = this.connection?.clientId;
             this.clientSequenceNumber = 0;
             this.clientSequenceNumberObserved = 0;
         }
-        if (!(0, driver_utils_1.isRuntimeMessage)(message)) {
+        if (!(0, internal_2.isRuntimeMessage)(message)) {
             this.localOpsToIgnore++;
         }
         else {
@@ -807,7 +812,7 @@ class ConnectionManager {
         }
     }
     sendMessages(messages) {
-        (0, core_utils_1.assert)(this.connected, 0x2b4 /* "not connected on sending ops!" */);
+        (0, internal_1.assert)(this.connected, 0x2b4 /* "not connected on sending ops!" */);
         // If connection is "read" or implicit "read" (got leave op for "write" connection),
         // then op can't make it through - we will get a nack if op is sent.
         // We can short-circuit this process.
@@ -829,17 +834,17 @@ class ConnectionManager {
             }
             return;
         }
-        (0, core_utils_1.assert)(!this.pendingReconnect, 0x2b5 /* "logic error" */);
+        (0, internal_1.assert)(!this.pendingReconnect, 0x2b5 /* "logic error" */);
         this._outbound.push(messages);
     }
     beforeProcessingIncomingOp(message) {
         // if we have connection, and message is local, then we better treat is as local!
-        (0, core_utils_1.assert)(this.clientId !== message.clientId || this.lastSubmittedClientId === message.clientId, 0x0ee /* "Not accounting local messages correctly" */);
+        (0, internal_1.assert)(this.clientId !== message.clientId || this.lastSubmittedClientId === message.clientId, 0x0ee /* "Not accounting local messages correctly" */);
         if (this.lastSubmittedClientId !== undefined &&
             this.lastSubmittedClientId === message.clientId) {
             const clientSequenceNumber = message.clientSequenceNumber;
-            (0, core_utils_1.assert)(this.clientSequenceNumberObserved < clientSequenceNumber, 0x0ef /* "client seq# not growing" */);
-            (0, core_utils_1.assert)(clientSequenceNumber <= this.clientSequenceNumber, 0x0f0 /* "Incoming local client seq# > generated by this client" */);
+            (0, internal_1.assert)(this.clientSequenceNumberObserved < clientSequenceNumber, 0x0ef /* "client seq# not growing" */);
+            (0, internal_1.assert)(clientSequenceNumber <= this.clientSequenceNumber, 0x0f0 /* "Incoming local client seq# > generated by this client" */);
             this.clientSequenceNumberObserved = clientSequenceNumber;
         }
         if (message.type === protocol_definitions_1.MessageType.ClientLeave) {