@fluidframework/container-loader 2.70.0-361248 → 2.70.0

package/lib/container.js

@@ -28,7 +28,7 @@ import { validateDriverCompatibility, validateRuntimeCompatibility, } from "./lo
 import { createMemoryDetachedBlobStorage, tryInitializeMemoryDetachedBlobStorage, } from "./memoryBlobStorage.js";
 import { NoopHeuristic } from "./noopHeuristic.js";
 import { pkgVersion } from "./packageVersion.js";
-import { ProtocolHandler, protocolHandlerShouldProcessSignal, } from "./protocol.js";
+import { ProtocolHandler, protocolHandlerShouldProcessSignal, wrapProtocolHandlerBuilder, } from "./protocol.js";
 import { initQuorumValuesFromCodeDetails } from "./quorum.js";
 import { SerializedStateManager, } from "./serializedStateManager.js";
 import { combineAppAndProtocolSummary, combineSnapshotTreeAndSnapshotBlobs, getDetachedContainerStateFromSerializedContainer, getDocumentAttributes, getProtocolSnapshotTree, getISnapshotFromSerializedContainer, runSingle, convertISnapshotToSnapshotWithBlobs, convertSnapshotInfoToSnapshot, } from "./utils.js";
@@ -208,12 +208,16 @@ export class Container extends EventEmitterWithErrorHandling {
             // in the order that is not possible in real life, that it may not expect.
             // Ideally, we should supply pendingLocalState?.clientId here as well, not in constructor, but it does not matter (at least today)
             this.connectionStateHandler.initProtocol(this.protocolHandler);
-            // Propagate current connection state through the system.
-            const readonly = this.readOnlyInfo.readonly ?? false;
             // This call does not look like needed any more, with delaying all connection-related events past loaded phase.
             // Yet, there could be some customer code that would break if we do not deliver it.
             // Will be removed in further PRs with proper changeset.
-            this.setContextConnectedState(false /* connected */, readonly);
+            const runtime = this._runtime;
+            if (runtime !== undefined &&
+                // Check for older runtime that may need this call
+                !("setConnectionStatus" in runtime) &&
+                runtime.disposed === false) {
+                runtime.setConnectionState(false /* canSendOps */, this.clientId);
+            }
             // Deliver delayed calls to DeltaManager - we ignored "connect" events while loading.
             const cm = this._deltaManager.connectionManager;
             if (cm.connected) {
@@ -373,6 +377,7 @@ export class Container extends EventEmitterWithErrorHandling {
             }, error);
             this.close(normalizeError(error));
         });
+        this.signalAudience = new Audience();
         /**
          * Lifecycle state of the container, used mainly to prevent re-entrancy and telemetry
          *
@@ -501,7 +506,8 @@ export class Container extends EventEmitterWithErrorHandling {
         const { canReconnect, clientDetailsOverride, urlResolver, documentServiceFactory, codeLoader, options, scope, subLogger, protocolHandlerBuilder, retryConnectionTimeoutMs, } = createProps;
         // Validate that the Driver is compatible with this Loader.
         const maybeDriverCompatDetails = documentServiceFactory;
-        validateDriverCompatibility(maybeDriverCompatDetails.ILayerCompatDetails, (error) => { } /* disposeFn */);
+        validateDriverCompatibility(maybeDriverCompatDetails.ILayerCompatDetails, (error) => { } /* disposeFn */, // There is nothing to dispose here, so just ignore the error.
+        subLogger);
         this.connectionTransitionTimes[ConnectionState.Disconnected] = performanceNow();
         const pendingLocalState = loadProps?.pendingLocalState;
         this._canReconnect = canReconnect ?? true;
@@ -515,9 +521,8 @@ export class Container extends EventEmitterWithErrorHandling {
         // Tracking alternative ways to handle this in AB#4129.
         this.options = { ...options };
         this.scope = scope;
-        this.protocolHandlerBuilder =
-            protocolHandlerBuilder ??
-                ((attributes, quorumSnapshot, sendProposal) => new ProtocolHandler(attributes, quorumSnapshot, sendProposal, new Audience(), (clientId) => this.clientsWhoShouldHaveLeft.has(clientId)));
+        this.protocolHandlerBuilder = wrapProtocolHandlerBuilder(protocolHandlerBuilder ??
+            ((attributes, quorumSnapshot, sendProposal) => new ProtocolHandler(attributes, quorumSnapshot, sendProposal, new Audience(), (clientId) => this.clientsWhoShouldHaveLeft.has(clientId))), this.signalAudience);
         // Note that we capture the createProps here so we can replicate the creation call when we want to clone.
         this.clone = async (_loadProps, createParamOverrides) => {
             return Container.load(_loadProps, {
@@ -1321,7 +1326,7 @@ export class Container extends EventEmitterWithErrorHandling {
         });
         deltaManager.on("readonly", (readonly) => {
             if (this.loaded) {
-                this.setContextConnectedState(this.connectionState === ConnectionState.Connected, readonly);
+                this.setConnectionStatus(readonly);
             }
             this.emit("readonly", readonly);
         });
@@ -1397,7 +1402,18 @@ export class Container extends EventEmitterWithErrorHandling {
             const clientId = this.connectionStateHandler.clientId;
             assert(clientId !== undefined, 0x96e /* there has to be clientId */);
             this.protocolHandler.audience.setCurrentClientId(clientId);
+            this.signalAudience.setCurrentClientId(clientId);
+        }
+        else if (this.connectionState === ConnectionState.CatchingUp) {
+            // Signal-based Audience does not wait for ops. So provide clientId
+            // as soon as possible.
+            const clientId = this.connectionStateHandler.pendingClientId;
+            assert(clientId !== undefined, 0xc89 /* catching up without clientId */);
+            this.signalAudience.setCurrentClientId(clientId);
         }
+        this.setConnectionStatus(
+        /* readonly */ this.readOnlyInfo.readonly ?? false, 
+        /* onlyCallSetConnectionStateIfConnectedOrDisconnected */ true);
         // We communicate only transitions to Connected & Disconnected states, skipping all other states.
         // This can be changed in the future, for example we likely should add "CatchingUp" event on Container.
         if (this.connectionState !== ConnectionState.Connected &&
@@ -1405,7 +1421,6 @@ export class Container extends EventEmitterWithErrorHandling {
             return;
         }
         // Both protocol and context should not be undefined if we got so far.
-        this.setContextConnectedState(connected, this.readOnlyInfo.readonly ?? false);
         this.protocolHandler.setConnectionState(connected, this.clientId);
         raiseConnectedEvent(this.mc.logger, this, connected, this.clientId, disconnectedReason?.text);
     }
@@ -1537,6 +1552,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 storage: this.storageAdapter,
                 quorum: this.protocolHandler.quorum,
                 audience: this.protocolHandler.audience,
+                signalAudience: this.signalAudience,
                 loader,
                 submitFn: (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata),
                 submitSummaryFn: (summaryOp, referenceSequenceNumber) => this.submitSummaryMessage(summaryOp, referenceSequenceNumber),
@@ -1560,7 +1576,7 @@ export class Container extends EventEmitterWithErrorHandling {
             const runtime = await PerformanceEvent.timedExecAsync(this.subLogger, { eventName: "InstantiateRuntime" }, async () => runtimeFactory.instantiateRuntime(context, existing));
             // Validate that the Runtime is compatible with this Loader.
             const maybeRuntimeCompatDetails = runtime;
-            validateRuntimeCompatibility(maybeRuntimeCompatDetails.ILayerCompatDetails);
+            validateRuntimeCompatibility(maybeRuntimeCompatDetails.ILayerCompatDetails, this.mc.logger);
             this._runtime = runtime;
             this._lifecycleEvents.emit("runtimeInstantiated");
             this._loadedCodeDetails = codeDetails;
@@ -1571,15 +1587,75 @@ export class Container extends EventEmitterWithErrorHandling {
         }
     }
     /**
-     * Set the connected state of the ContainerContext
-     * This controls the "connected" state of the ContainerRuntime as well
-     * @param connected - Is the container currently connected?
+     * Send the connected status to the runtime.
      * @param readonly - Is the container in readonly mode?
+     * @param onlyCallSetConnectionStateIfConnectedOrDisconnected - If true, only
+     * call older `setConnectionState` on the runtime if the connection state is
+     * either Connected or Disconnected. This exists to preserve older behavior
+     * where the runtime was only notified of these two states.
      */
-    setContextConnectedState(connected, readonly) {
+    setConnectionStatus(readonly, onlyCallSetConnectionStateIfConnectedOrDisconnected = false) {
         if (this._runtime?.disposed === false && this.loaded) {
-            this.runtime.setConnectionState(connected &&
-                !readonly /* container can send ops if connected to service and not in readonly mode */, this.clientId);
+            const setConnectionStatus = this.runtime.setConnectionStatus?.bind(this.runtime);
+            if (setConnectionStatus === undefined) {
+                if (!onlyCallSetConnectionStateIfConnectedOrDisconnected ||
+                    this.connectionState === ConnectionState.Connected ||
+                    this.connectionState === ConnectionState.Disconnected) {
+                    this.runtime.setConnectionState(this.connectionState === ConnectionState.Connected &&
+                        !readonly /* container can send ops if connected to service and not in readonly mode */, this.clientId);
+                }
+            }
+            else {
+                const pendingClientConnectionId = this.connectionStateHandler.pendingClientId;
+                const connectionState = this.connectionState;
+                switch (connectionState) {
+                    case ConnectionState.EstablishingConnection: {
+                        setConnectionStatus({
+                            connectionState,
+                            canSendOps: false,
+                            readonly,
+                        });
+                        break;
+                    }
+                    case ConnectionState.CatchingUp: {
+                        // When catching up, we have a pending clientId, but it
+                        // is not usable for ops. Send clientId with canSendOps false.
+                        assert(pendingClientConnectionId !== undefined, 0xc8a /* catching up without clientId */);
+                        setConnectionStatus({
+                            connectionState,
+                            pendingClientConnectionId,
+                            canSendOps: false,
+                            readonly,
+                        });
+                        break;
+                    }
+                    case ConnectionState.Connected: {
+                        // When connected, we have an active clientId. Pass it along
+                        // with canSendOps true/false based on readonly.
+                        const clientConnectionId = this.clientId;
+                        assert(clientConnectionId !== undefined, 0xc8b /* connected without clientId */);
+                        assert(clientConnectionId === pendingClientConnectionId, 0xc8c /* connected with different clientId than pending */);
+                        setConnectionStatus({
+                            connectionState,
+                            clientConnectionId,
+                            canSendOps: !readonly,
+                            readonly,
+                        });
+                        break;
+                    }
+                    case ConnectionState.Disconnected: {
+                        setConnectionStatus({
+                            connectionState,
+                            priorPendingClientConnectionId: pendingClientConnectionId,
+                            priorConnectedClientConnectionId: this.clientId,
+                            canSendOps: false,
+                            readonly,
+                        });
+                        break;
+                    }
+                    // No default
+                }
+            }
         }
     }
     handleDeltaConnectionArg(deltaConnectionArg, connectionArgs) {