@fluidframework/container-runtime 2.70.0-361248 → 2.70.0

package/lib/containerRuntime.js

@@ -454,6 +454,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         };
         const runtime = new containerRuntimeCtor(context, registry, metadata, electedSummarizerData, chunks ?? [], aliases ?? [], internalRuntimeOptions, containerScope, logger, existing, blobManagerLoadInfo, context.storage, createIdCompressorFn, documentSchemaController, featureGatesForTelemetry, provideEntryPoint, semanticVersionToMinimumVersionForCollab(updatedMinVersionForCollab), requestHandler, undefined, // summaryConfiguration
         recentBatchInfo);
+        runtime.sharePendingBlobs();
         // Initialize the base state of the runtime before it's returned.
         await runtime.initializeBaseState(context.loader);
         // Apply stashed ops with a reference sequence number equal to the sequence number of the snapshot,
@@ -621,9 +622,8 @@ export class ContainerRuntime extends TypedEventEmitter {
          * Enter Staging Mode, such that ops submitted to the ContainerRuntime will not be sent to the ordering service.
          * To exit Staging Mode, call either discardChanges or commitChanges on the Stage Controls returned from this method.
          *
-         * @returns StageControlsExperimental - Controls for exiting Staging Mode.
+         * @returns Controls for exiting Staging Mode.
          */
-        // eslint-disable-next-line import/no-deprecated
         this.enterStagingMode = () => {
             if (this.stageControls !== undefined) {
                 throw new UsageError("Already in staging mode");
@@ -652,7 +652,6 @@ export class ContainerRuntime extends TypedEventEmitter {
                     throw normalizedError;
                 }
             };
-            // eslint-disable-next-line import/no-deprecated
             const stageControls = {
                 discardChanges: () => exitStagingMode(() => {
                     // Pop all staged batches from the PSM and roll them back in LIFO order
@@ -678,6 +677,39 @@ export class ContainerRuntime extends TypedEventEmitter {
             return this.stageControls;
         };
         this.readAndParseBlob = async (id) => readAndParse(this.storage, id);
+        /**
+         * ContainerRuntime knows about additional restrictions on when blob sharing can be resumed as compared
+         * to BlobManager. In particular, it wants to avoid sharing blobs while in readonly state, and it also
+         * wants to avoid sharing blobs before connection completes (otherwise it may cause the sharing to happen
+         * before processing shared ops).
+         *
+         * This method can be called safely before those conditions are met. In the background, it will wait until
+         * it is safe before initiating sharing. It will close the container on any error.
+         */
+        this.sharePendingBlobs = () => {
+            new Promise((resolve) => {
+                // eslint-disable-next-line unicorn/consistent-function-scoping
+                const canStartSharing = () => this.connected && this.deltaManager.readOnlyInfo.readonly !== true;
+                if (canStartSharing()) {
+                    resolve();
+                    return;
+                }
+                const checkCanShare = (readonly) => {
+                    if (canStartSharing()) {
+                        this.deltaManager.off("readonly", checkCanShare);
+                        this.off("connected", checkCanShare);
+                        resolve();
+                    }
+                };
+                this.deltaManager.on("readonly", checkCanShare);
+                this.on("connected", checkCanShare);
+            })
+                .then(this.blobManager.sharePendingBlobs)
+                // It may not be necessary to close the container on failures - this should just mean there's
+                // a handle in the container that is stuck pending, which is a scenario that customers need to
+                // handle anyway. Starting with this more aggressive/restrictive behavior to be cautious.
+                .catch(this.closeFn);
+        };
         // While internal, ContainerRuntime has not been converted to use the new events support.
         // Recreate the required events (new pattern) with injected, wrapper new emitter.
         // It is lazily create to avoid listeners (old events) that ultimately go nowhere.
@@ -688,7 +720,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                     eventEmitter.emit("joined", { clientId, canWrite });
                 });
                 this.on("disconnectedFromService", () => eventEmitter.emit("disconnected"));
-                this.on("connectionTypeChanged", (canWrite) => eventEmitter.emit("connectionTypeChanged", canWrite));
+                this.on("operabilityChanged", (canWrite) => eventEmitter.emit("operabilityChanged", canWrite));
             }
             else {
                 this.on("connected", (clientId) => {
@@ -698,14 +730,11 @@ export class ContainerRuntime extends TypedEventEmitter {
             }
             return eventEmitter;
         });
-        const { options, clientDetails, connected, baseSnapshot, submitFn, submitBatchFn, submitSummaryFn, submitSignalFn, disposeFn, closeFn, deltaManager, quorum, audience, pendingLocalState, supportedFeatures, snapshotWithContents, getConnectionState, } = context;
+        const { options, clientDetails, connected, baseSnapshot, submitFn, submitBatchFn, submitSummaryFn, submitSignalFn, disposeFn, closeFn, deltaManager, quorum, audience, signalAudience, pendingLocalState, supportedFeatures, snapshotWithContents, getConnectionState, } = context;
         this.getConnectionState = getConnectionState;
         // In old loaders without dispose functionality, closeFn is equivalent but will also switch container to readonly mode
         this.disposeFn = disposeFn ?? closeFn;
         this.isSnapshotInstanceOfISnapshot = snapshotWithContents !== undefined;
-        // Validate that the Loader is compatible with this Runtime.
-        const maybeLoaderCompatDetailsForRuntime = context;
-        validateLoaderCompatibility(maybeLoaderCompatDetailsForRuntime.ILayerCompatDetails, this.disposeFn);
         this.mc = createChildMonitoringContext({
             logger: this.baseLogger,
             namespace: "ContainerRuntime",
@@ -715,6 +744,9 @@ export class ContainerRuntime extends TypedEventEmitter {
                 },
             },
         });
+        // Validate that the Loader is compatible with this Runtime.
+        const maybeLoaderCompatDetailsForRuntime = context;
+        validateLoaderCompatibility(maybeLoaderCompatDetailsForRuntime.ILayerCompatDetails, this.disposeFn, this.mc.logger);
         // If we support multiple algorithms in the future, then we would need to manage it here carefully.
         // We can use runtimeOptions.compressionOptions.compressionAlgorithm, but only if it's in the schema list!
         // If it's not in the list, then we will need to either use no compression, or fallback to some other (supported by format)
@@ -814,10 +846,11 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.nextSummaryNumber = loadSummaryNumber + 1;
         this.messageAtLastSummary = lastMessageFromMetadata(metadata);
         // Note that we only need to pull the *initial* connected state from the context.
-        // Later updates come through calls to setConnectionState.
+        // Later updates come through calls to setConnectionState/Status.
         this.canSendOps = connected;
         this.canSendSignals = this.getConnectionState
-            ? this.getConnectionState() === ConnectionState.Connected
+            ? this.getConnectionState() === ConnectionState.Connected ||
+                this.getConnectionState() === ConnectionState.CatchingUp
             : undefined;
         this.mc.logger.sendTelemetryEvent({
             eventName: "GCFeatureMatrix",
@@ -1041,6 +1074,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 oldClientId = clientId;
             });
         }
+        this.signalAudience = signalAudience;
         const closeSummarizerDelayOverride = this.mc.config.getNumber("Fluid.ContainerRuntime.Test.CloseSummarizerDelayOverrideMs");
         this.closeSummarizerDelayMs =
             closeSummarizerDelayOverride ?? defaultCloseSummarizerDelayMs;
@@ -1622,6 +1656,38 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
     }
     setConnectionState(canSendOps, clientId) {
+        this.setConnectionStateToConnectedOrDisconnected(canSendOps, clientId);
+    }
+    setConnectionStatus(status) {
+        switch (status.connectionState) {
+            case ConnectionState.Connected: {
+                this.setConnectionStateToConnectedOrDisconnected(status.canSendOps, status.clientConnectionId);
+                break;
+            }
+            case ConnectionState.Disconnected: {
+                this.setConnectionStateToConnectedOrDisconnected(status.canSendOps, status.priorConnectedClientConnectionId);
+                break;
+            }
+            case ConnectionState.CatchingUp: {
+                assert(this.getConnectionState !== undefined &&
+                    this.getConnectionState() === ConnectionState.CatchingUp, 0xc8d /* connection state mismatch between getConnectionState and setConnectionStatus notification */);
+                // Note: Historically when only `setConnectionState` of `IRuntime`
+                // was supported, it was possible to be in `CatchingUp` state and
+                // call through to `setConnectionStateCore` when there is a readonly
+                // change - see `Container`'s `"deltaManager.on("readonly"`. There
+                // would not be a transition of `canSendOps` in that case, but
+                // `channelCollection` and `garbageCollector` would receive early
+                // `setConnectionState` call AND `this` would `emit` "disconnected"
+                // event.
+                this.emitServiceConnectionEvents(
+                /* canSendOpsChanged */ this.canSendOps, 
+                /* canSendOps */ false, status.pendingClientConnectionId);
+                break;
+            }
+            // No default
+        }
+    }
+    setConnectionStateToConnectedOrDisconnected(canSendOps, clientId) {
         // Validate we have consistent state
         const currentClientId = this._audience.getSelf()?.clientId;
         assert(clientId === currentClientId, 0x977 /* input clientId does not match Audience */);
@@ -1680,30 +1746,33 @@ export class ContainerRuntime extends TypedEventEmitter {
      * Emits service connection events based on connection state changes.
      *
      * @remarks
-     * "connectedToService" is emitted when container connection state transitions to 'Connected' regardless of connection mode.
+     * "connectedToService" is emitted when container connection state transitions to 'CatchingUp' or 'Connected' regardless of connection mode.
      * "disconnectedFromService" excludes false "disconnected" events that happen when readonly client transitions to 'Connected'.
      */
     emitServiceConnectionEvents(canSendOpsChanged, canSendOps, clientId) {
         if (!this.getConnectionState) {
             return;
         }
-        const canSendSignals = this.getConnectionState() === ConnectionState.Connected;
+        const connectionState = this.getConnectionState();
+        const canSendSignals = connectionState === ConnectionState.Connected ||
+            connectionState === ConnectionState.CatchingUp;
         const canSendSignalsChanged = this.canSendSignals !== canSendSignals;
         this.canSendSignals = canSendSignals;
         if (canSendSignalsChanged) {
-            // If canSendSignals changed, we either transitioned from Connected to Disconnected or CatchingUp to Connected
+            // If canSendSignals changed, we either transitioned from CatchingUp or
+            // Connected to Disconnected or EstablishingConnection to CatchingUp.
             if (canSendSignals) {
-                // Emit for CatchingUp to Connected transition
+                // Emit for EstablishingConnection to CatchingUp or Connected transition
                 this.emit("connectedToService", clientId, canSendOps);
             }
             else {
-                // Emit for Connected to Disconnected transition
+                // Emit for CatchingUp or Connected to Disconnected transition
                 this.emit("disconnectedFromService");
             }
         }
         else if (canSendOpsChanged) {
-            // If canSendSignals did not change but canSendOps did, then connection type has changed.
-            this.emit("connectionTypeChanged", canSendOps);
+            // If canSendSignals did not change but canSendOps did, then operations possible has changed.
+            this.emit("operabilityChanged", canSendOps);
         }
     }
     async notifyOpReplay(message) {
@@ -2094,7 +2163,6 @@ export class ContainerRuntime extends TypedEventEmitter {
      */
     orderSequentially(callback) {
         let checkpoint;
-        // eslint-disable-next-line import/no-deprecated
         let stageControls;
         if (this.mc.config.getBoolean("Fluid.ContainerRuntime.EnableRollback") === true) {
             if (!this.batchRunner.running && !this.inStagingMode) {
@@ -2835,7 +2903,6 @@ export class ContainerRuntime extends TypedEventEmitter {
     // TODO: better typing
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     contents, localOpMetadata = undefined) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         this.submit({ type, contents }, localOpMetadata);
     }
     async uploadBlob(blob, signal) {
@@ -3304,7 +3371,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         const getConnectionState = this.getConnectionState;
         if (getConnectionState) {
             const connectionState = getConnectionState();
-            if (connectionState === ConnectionState.Connected) {
+            if (connectionState === ConnectionState.Connected ||
+                connectionState === ConnectionState.CatchingUp) {
+                // Note: when CatchingUp, canSendOps will always be false.
                 return this.canSendOps ? "joinedForWriting" : "joinedForReading";
             }
         }
@@ -3316,16 +3385,17 @@ export class ContainerRuntime extends TypedEventEmitter {
     acquireExtension(id, factory, ...useContext) {
         let entry = this.extensions.get(id);
         if (entry === undefined) {
+            const audience = this.signalAudience;
             const runtime = {
                 getJoinedStatus: this.getJoinedStatus.bind(this),
-                getClientId: () => this.clientId,
+                getClientId: audience ? () => audience.getSelf()?.clientId : () => this.clientId,
                 events: this.lazyEventsForExtensions.value,
                 logger: this.baseLogger,
                 submitAddressedSignal: (addressChain, message) => {
                     this.submitExtensionSignal(id, addressChain, message);
                 },
                 getQuorum: this.getQuorum.bind(this),
-                getAudience: this.getAudience.bind(this),
+                getAudience: audience ? () => audience : this.getAudience.bind(this),
                 supportedFeatures: this.ILayerCompatDetails.supportedFeatures,
             };
             entry = new factory(runtime, ...useContext);