@fluidframework/container-loader 1.1.0-75972 → 1.2.0-77818

package/src/connectionManager.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import { default as AbortController } from "abort-controller";
 import {
     IDisposable,
     ITelemetryLogger,
@@ -30,6 +31,7 @@ import {
     waitForConnectedState,
     DeltaStreamConnectionForbiddenError,
     logNetworkFailure,
+    // isRuntimeMessage,
 } from "@fluidframework/driver-utils";
 import {
     ConnectionMode,
@@ -118,6 +120,21 @@ class NoDeltaStream
     public dispose() { this._disposed = true; }
 }
 
+/**
+ * Interface to track the current in-progress connection attempt.
+ */
+interface IPendingConnection {
+    /**
+     * Used to cancel an in-progress connection attempt.
+     */
+    abort(): void;
+
+    /**
+     * Desired ConnectionMode of this in-progress connection attempt.
+     */
+    connectionMode: ConnectionMode;
+}
+
 /**
  * Implementation of IConnectionManager, used by Container class
  * Implements constant connectivity to relay service, by reconnecting in case of loast connection or error.
@@ -127,7 +144,12 @@ export class ConnectionManager implements IConnectionManager {
     /** Connection mode used when reconnecting on error or disconnect. */
     private readonly defaultReconnectionMode: ConnectionMode;
 
-    private pendingConnection = false;
+    /**
+     * Tracks the current in-progress connection attempt. Undefined if there is none.
+     * Note: Once the connection attempt fires and the code becomes asynchronous, its possible that a new connection
+     * attempt was fired and this.pendingConnection was overwritten to reflect the new attempt.
+     */
+    private pendingConnection: IPendingConnection | undefined;
     private connection: IDocumentDeltaConnection | undefined;
 
     /** file ACL - whether user has only read-only access to a file */
@@ -304,7 +326,7 @@ export class ConnectionManager implements IConnectionManager {
         }
         this.closed = true;
 
-        this.pendingConnection = false;
+        this.pendingConnection = undefined;
 
         // Ensure that things like triggerConnect() will short circuit
         this._reconnectMode = ReconnectMode.Never;
@@ -411,11 +433,18 @@ export class ConnectionManager implements IConnectionManager {
     private async connectCore(connectionMode?: ConnectionMode): Promise<void> {
         assert(!this.closed, 0x26a /* "not closed" */);
 
-        if (this.connection !== undefined || this.pendingConnection) {
-            return;
+        if (this.connection !== undefined) {
+            return;  // Connection attempt already completed successfully
         }
 
-        let requestedMode = connectionMode ?? this.defaultReconnectionMode;
+        let pendingConnectionMode;
+        if (this.pendingConnection !== undefined) {
+            pendingConnectionMode = this.pendingConnection.connectionMode;
+            this.cancelConnection();  // Throw out in-progress connection attempt in favor of new attempt
+            assert(this.pendingConnection === undefined, "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;
 
         // if we have any non-acked ops from last connection, reconnect as "write".
         // without that we would connect in view-only mode, which will result in immediate
@@ -433,31 +462,39 @@ export class ConnectionManager implements IConnectionManager {
 
         if (docService.policies?.storageOnly === true) {
             connection = new NoDeltaStream();
-            // to keep setupNewSuccessfulConnection happy
-            this.pendingConnection = true;
             this.setupNewSuccessfulConnection(connection, "read");
-            assert(!this.pendingConnection, 0x2b3 /* "logic error" */);
+            assert(this.pendingConnection === undefined, 0x2b3 /* "logic error" */);
             return;
         }
 
-        // this.pendingConnection resets to false as soon as we know the outcome of the connection attempt
-        this.pendingConnection = true;
-
         let delayMs = InitialReconnectDelayInMs;
         let connectRepeatCount = 0;
         const connectStartTime = performance.now();
         let lastError: any;
 
+        const abortController = new AbortController();
+        const abortSignal = abortController.signal;
+        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) {
                 throw new Error("Attempting to connect a closed DeltaManager");
             }
+            if (abortSignal.aborted === true) {
+                this.logger.sendTelemetryEvent({
+                    eventName: "ConnectionAttemptCancelled",
+                    attempts: connectRepeatCount,
+                    duration: TelemetryLogger.formatTick(performance.now() - connectStartTime),
+                    connectionEstablished: false,
+                });
+                return;
+            }
             connectRepeatCount++;
 
             try {
                 this.client.mode = requestedMode;
-                connection = await docService.connectToDeltaStream(this.client);
+                connection = await docService.connectToDeltaStream({ ...this.client, mode: requestedMode });
 
                 if (connection.disposed) {
                     // Nobody observed this connection, so drop it on the floor and retry.
@@ -515,6 +552,18 @@ export class ConnectionManager implements IConnectionManager {
             );
         }
 
+        // Check for abort signal after while loop as well
+        if (abortSignal.aborted === true) {
+            connection.dispose();
+            this.logger.sendTelemetryEvent({
+                eventName: "ConnectionAttemptCancelled",
+                attempts: connectRepeatCount,
+                duration: TelemetryLogger.formatTick(performance.now() - connectStartTime),
+                connectionEstablished: true,
+            });
+            return;
+        }
+
         this.setupNewSuccessfulConnection(connection, requestedMode);
     }
 
@@ -534,15 +583,20 @@ export class ConnectionManager implements IConnectionManager {
     /**
      * Disconnect the current connection.
      * @param reason - Text description of disconnect reason to emit with disconnect event
+     * @returns A boolean that indicates if there was an existing connection (or pending connection) to disconnect
      */
      private disconnectFromDeltaStream(reason: string): boolean {
         this.pendingReconnect = false;
 
         if (this.connection === undefined) {
+            if (this.pendingConnection !== undefined) {
+                this.cancelConnection();
+                return true;
+            }
             return false;
         }
 
-        assert(!this.pendingConnection, 0x27b /* "reentrancy may result in incorrect behavior" */);
+        assert(this.pendingConnection === undefined, 0x27b /* "reentrancy may result in incorrect behavior" */);
 
         const connection = this.connection;
         // Avoid any re-entrancy - clear object reference
@@ -568,6 +622,16 @@ export class ConnectionManager implements IConnectionManager {
         return true;
     }
 
+    /**
+     * Cancel in-progress connection attempt.
+     */
+    private cancelConnection() {
+        assert(this.pendingConnection !== undefined, "this.pendingConnection is undefined when trying to cancel");
+        this.pendingConnection.abort();
+        this.pendingConnection = undefined;
+        this.logger.sendTelemetryEvent({ eventName: "ConnectionCancelReceived" });
+    }
+
     /**
      * Once we've successfully gotten a connection, we need to set up state, attach event listeners, and process
      * initial messages.
@@ -578,11 +642,8 @@ export class ConnectionManager implements IConnectionManager {
         assert(this.connection === undefined, 0x0e6 /* "old connection exists on new connection setup" */);
         assert(!connection.disposed, 0x28a /* "can't be disposed - Callers need to ensure that!" */);
 
-        if (this.pendingConnection) {
-            this.pendingConnection = false;
-        } else {
-            assert(this.closed, 0x27f /* "reentrancy may result in incorrect behavior" */);
-        }
+        this.pendingConnection = undefined;
+
         this.connection = connection;
 
         // Does information in scopes & mode matches?
@@ -780,7 +841,6 @@ export class ConnectionManager implements IConnectionManager {
 
     public sendMessages(messages: IDocumentMessage[]) {
         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.
@@ -832,7 +892,7 @@ export class ConnectionManager implements IConnectionManager {
                 this.logger.sendPerformanceEvent({ eventName: "ReadConnectionTransition" });
 
                 // Please see #8483 for more details on why maintaining connection further as is would not work.
-                // Short story - connection properties are immutable, and many processes (consensus DDSs, summarizer)
+                // Short story - connection properties are immutable, and many processes (consensus DDSes, summarizer)
                 // assume that connection stays "write" connection until disconnect, and act accordingly, which may
                 // not work well with de-facto "read" connection we are in after receiving own leave op on timeout.
                 // Clients need to be able to transition to "read" state after some time of inactivity!

package/src/connectionState.ts

@@ -18,8 +18,8 @@ export enum ConnectionState {
     EstablishingConnection = 3,
 
     /**
-     * @see ConnectionState.CatchingUp, which is the new name for this state.
-     * @deprecated - This state itself is not gone, just being renamed. Please use ConnectionState.CatchingUp.
+     * See {@link ConnectionState.CatchingUp}, which is the new name for this state.
+     * @deprecated - This state itself is not gone, just being renamed. Please use {@link ConnectionState.CatchingUp}.
      */
     Connecting = 1,
 

package/src/container.ts

@@ -35,7 +35,7 @@ import {
     extractSafePropertiesFromMessage,
     GenericError,
     UsageError,
- } from "@fluidframework/container-utils";
+} from "@fluidframework/container-utils";
 import {
     IDocumentService,
     IDocumentStorageService,
@@ -50,9 +50,10 @@ import {
     combineAppAndProtocolSummary,
     runWithRetry,
     isFluidResolvedUrl,
+    isRuntimeMessage,
+    isUnpackedRuntimeMessage,
 } from "@fluidframework/driver-utils";
 import {
-    isSystemMessage,
     IProtocolHandler,
     ProtocolOpHandlerWithClientValidation,
 } from "@fluidframework/protocol-base";
@@ -217,7 +218,9 @@ export async function waitContainerToCatchUp(container: IContainer) {
         };
         container.on(connectedEventName, callback);
 
-        container.connect();
+        if (container.connectionState === ConnectionState.Disconnected) {
+            container.connect();
+        }
     });
 }
 
@@ -286,14 +289,14 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                         event.end({ ...props, ...loadOptions.loadMode });
                         resolve(container);
                     },
-                    (error) => {
-                        const err = normalizeError(error);
-                        // Depending where error happens, we can be attempting to connect to web socket
-                        // and continuously retrying (consider offline mode)
-                        // Host has no container to close, so it's prudent to do it here
-                        container.close(err);
-                        onClosed(err);
-                    });
+                        (error) => {
+                            const err = normalizeError(error);
+                            // Depending where error happens, we can be attempting to connect to web socket
+                            // and continuously retrying (consider offline mode)
+                            // Host has no container to close, so it's prudent to do it here
+                            container.close(err);
+                            onClosed(err);
+                        });
             }),
             { start: true, end: true, cancel: "generic" },
         );
@@ -401,7 +404,8 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         return this._protocolHandler;
     }
 
-    private resumedOpProcessingAfterLoad = false;
+    /** During initialization we pause the inbound queues. We track this state to ensure we only call resume once */
+    private inboundQueuePausedFromInit = true;
     private firstConnection = true;
     private readonly connectionTransitionTimes: number[] = [];
     private messageCountAfterDisconnection: number = 0;
@@ -535,7 +539,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                     name: typeof name === "string" ? name : undefined,
                 },
                 error);
-            });
+        });
         this._audience = new Audience();
 
         this.clientDetailsOverride = config.clientDetailsOverride;
@@ -678,10 +682,10 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                         }
                         break;
                     case connectedEventName:
-                         if (this.connected) {
+                        if (this.connected) {
                             listener(this.clientId);
-                         }
-                         break;
+                        }
+                        break;
                     case disconnectedEventName:
                         if (!this.connected) {
                             listener();
@@ -913,7 +917,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                 throw newError;
             }
         },
-        { start: true, end: true, cancel: "generic" });
+            { start: true, end: true, cancel: "generic" });
     }
 
     public async request(path: IRequest): Promise<IResponse> {
@@ -992,8 +996,8 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         assert(!this.closed, 0x0d9 /* "Attempting to connect() a closed DeltaManager" */);
 
         // Resume processing ops
-        if (!this.resumedOpProcessingAfterLoad) {
-            this.resumedOpProcessingAfterLoad = true;
+        if (this.inboundQueuePausedFromInit) {
+            this.inboundQueuePausedFromInit = false;
             this._deltaManager.inbound.resume();
             this._deltaManager.inboundSignal.resume();
         }
@@ -1189,13 +1193,9 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
 
             switch (loadMode.deltaConnection) {
                 case undefined:
-                    // 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 resumeInternal() is called quickly after initial container boot.
-                    this.resumeInternal({ reason: "DocumentLoad", fetchOpsFromStorage: false });
-                    break;
                 case "delayed":
-                    this.resumedOpProcessingAfterLoad = true;
+                    assert(this.inboundQueuePausedFromInit, "inboundQueuePausedFromInit should be true");
+                    this.inboundQueuePausedFromInit = false;
                     this._deltaManager.inbound.resume();
                     this._deltaManager.inboundSignal.resume();
                     break;
@@ -1395,7 +1395,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                 if (key === "code" || key === "code2") {
                     if (!isFluidCodeDetails(value)) {
                         this.mc.logger.sendErrorEvent({
-                                eventName: "CodeProposalNotIFluidCodeDetails",
+                            eventName: "CodeProposalNotIFluidCodeDetails",
                         });
                     }
                     this.processCodeProposal().catch((error) => {
@@ -1684,8 +1684,14 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                 new DataCorruptionError(errorMessage, extractSafePropertiesFromMessage(message))));
         }
 
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        if (isUnpackedRuntimeMessage(message) && !isRuntimeMessage(message)) {
+            this.mc.logger.sendTelemetryEvent(
+                { eventName: "UnpackedRuntimeMessage", type: message.type });
+        }
         // Forward non system messages to the loaded runtime for processing
-        if (!isSystemMessage(message)) {
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        if (isRuntimeMessage(message) || isUnpackedRuntimeMessage(message)) {
             this.context.process(message, local, undefined);
         }
 

package/src/deltaManager.ts

@@ -31,7 +31,6 @@ import {
     IDocumentService,
     DriverErrorType,
 } from "@fluidframework/driver-definitions";
-import { isSystemMessage } from "@fluidframework/protocol-base";
 import {
     IDocumentMessage,
     ISequencedDocumentMessage,
@@ -41,6 +40,7 @@ import {
 } from "@fluidframework/protocol-definitions";
 import {
     NonRetryableError,
+    isClientMessage,
 } from "@fluidframework/driver-utils";
 import {
     ThrottlingWarning,
@@ -105,6 +105,10 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
     private lastProcessedMessage: ISequencedDocumentMessage | undefined;
     private baseTerm: number = 0;
 
+    /**
+     * Track down the ops size.
+    */
+    private opsSize: number = 0;
     private prevEnqueueMessagesReason: string | undefined;
     private previouslyProcessedMessage: ISequencedDocumentMessage | undefined;
 
@@ -198,6 +202,8 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
             return -1;
         }
 
+        this.opsSize += message.contents.length;
+
         this.messageBuffer.push(message);
 
         this.emit("submitOp", message);
@@ -226,6 +232,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
     public get connectionProps(): ITelemetryProperties {
         return {
             sequenceNumber: this.lastSequenceNumber,
+            opsSize: this.opsSize > 0 ? this.opsSize : undefined,
             ...this.connectionManager.connectionProps,
         };
     }
@@ -337,6 +344,8 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
         // state. As requirements change, so should these checks.
         assert(this.messageBuffer.length === 0, 0x0e9 /* "messageBuffer is not empty on new connection" */);
 
+        this.opsSize = 0;
+
         this.emit(
             "connect",
             connection,
@@ -753,7 +762,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
         // System messages may have no clientId (but some do, like propose, noop, summarize)
         assert(
             message.clientId !== undefined
-            || isSystemMessage(message),
+            || !(isClientMessage(message)),
             0x0ed /* "non-system message have to have clientId" */,
         );
 

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-loader";
-export const pkgVersion = "1.1.0-75972";
+export const pkgVersion = "1.2.0-77818";