@fluidframework/container-runtime 2.51.0 → 2.53.0-350190

package/lib/containerRuntime.js

@@ -4,13 +4,14 @@
  */
 import { createEmitter, Trace, TypedEventEmitter } from "@fluid-internal/client-utils";
 import { AttachState } from "@fluidframework/container-definitions";
-import { isIDeltaManagerFull } from "@fluidframework/container-definitions/internal";
+import { ConnectionState, isIDeltaManagerFull, } from "@fluidframework/container-definitions/internal";
 import { assert, Deferred, Lazy, LazyPromise, PromiseCache, delay, fail, unreachableCase, } from "@fluidframework/core-utils/internal";
 import { SummaryType } from "@fluidframework/driver-definitions";
 import { FetchSource, MessageType } from "@fluidframework/driver-definitions/internal";
 import { readAndParse } from "@fluidframework/driver-utils/internal";
 import { createIdCompressor, createSessionId, deserializeIdCompressor, } from "@fluidframework/id-compressor/internal";
 import { FlushMode, FlushModeExperimental, channelsTreeName, gcTreeKey, } from "@fluidframework/runtime-definitions/internal";
+import { defaultMinVersionForCollab, isValidMinVersionForCollab, } from "@fluidframework/runtime-utils/internal";
 import { GCDataBuilder, RequestParser, RuntimeHeaders, TelemetryContext, addBlobToSummary, addSummarizeResultToSummary, calculateStats, create404Response, exceptionToResponse, seqFromTree, } from "@fluidframework/runtime-utils/internal";
 import { DataCorruptionError, DataProcessingError, extractSafePropertiesFromMessage, GenericError, LoggingError, PerformanceEvent, 
 // eslint-disable-next-line import/no-deprecated
@@ -20,9 +21,9 @@ import { v4 as uuid } from "uuid";
 import { BindBatchTracker } from "./batchTracker.js";
 import { BlobManager, blobManagerBasePath, blobsTreeName, isBlobPath, loadBlobManagerLoadInfo, } from "./blobManager/index.js";
 import { ChannelCollection, getSummaryForDatastores, wrapContext, } from "./channelCollection.js";
-import { defaultMinVersionForCollab, getMinVersionForCollabDefaults, isValidMinVersionForCollab, validateRuntimeOptions, } from "./compatUtils.js";
 import { CompressionAlgorithms, disabledCompressionConfig } from "./compressionDefinitions.js";
 import { ReportOpPerfTelemetry } from "./connectionTelemetry.js";
+import { getMinVersionForCollabDefaults, validateRuntimeOptions, } from "./containerCompatibility.js";
 import { ContainerFluidHandleContext } from "./containerHandleContext.js";
 import { channelToDataStore } from "./dataStore.js";
 import { FluidDataStoreRegistry } from "./dataStoreRegistry.js";
@@ -181,6 +182,12 @@ export let getSingleUseLegacyLogCallback = (logger, type) => {
         getSingleUseLegacyLogCallback = () => () => { };
     };
 };
+/**
+ * Does nothing helper to apply unverified branding to a value.
+ */
+function markUnverified(value) {
+    return value;
+}
 /**
  * This is meant to be used by a {@link @fluidframework/container-definitions#IRuntimeFactory} to instantiate a container runtime.
  * @param params - An object which specifies all required and optional params necessary to instantiate a runtime.
@@ -441,13 +448,6 @@ 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, updatedMinVersionForCollab, requestHandler, undefined, // summaryConfiguration
         recentBatchInfo);
-        runtime.blobManager.stashedBlobsUploadP.then(() => {
-            // make sure we didn't reconnect before the promise resolved
-            if (runtime.delayConnectClientId !== undefined && !runtime.disposed) {
-                runtime.delayConnectClientId = undefined;
-                runtime.setConnectionStateCore(true, runtime.delayConnectClientId);
-            }
-        }, (error) => runtime.closeFn(error));
         // 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,
@@ -591,7 +591,6 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.minVersionForCollab = minVersionForCollab;
         this.requestHandler = requestHandler;
         this.summaryConfiguration = summaryConfiguration;
-        this.imminentClosure = false;
         this.isReadOnly = () => this.deltaManager.readOnlyInfo.readonly === true;
         // We accumulate Id compressor Ops while Id compressor is not loaded yet (only for "delayed" mode)
         // Once it loads, it will process all such ops and we will stop accumulating further ops - ops will be processes as they come in.
@@ -678,16 +677,28 @@ export class ContainerRuntime extends TypedEventEmitter {
         // It is lazily create to avoid listeners (old events) that ultimately go nowhere.
         this.lazyEventsForExtensions = new Lazy(() => {
             const eventEmitter = createEmitter();
-            this.on("connected", (clientId) => eventEmitter.emit("connected", clientId));
-            this.on("disconnected", () => eventEmitter.emit("disconnected"));
+            if (this.getConnectionState) {
+                this.on("connectedToService", (clientId, canWrite) => {
+                    eventEmitter.emit("joined", { clientId, canWrite });
+                });
+                this.on("disconnectedFromService", () => eventEmitter.emit("disconnected"));
+                this.on("connectionTypeChanged", (canWrite) => eventEmitter.emit("connectionTypeChanged", canWrite));
+            }
+            else {
+                this.on("connected", (clientId) => {
+                    eventEmitter.emit("joined", { clientId, canWrite: true });
+                });
+                this.on("disconnected", () => eventEmitter.emit("disconnected"));
+            }
             return eventEmitter;
         });
-        const { options, clientDetails, connected, baseSnapshot, submitFn, submitBatchFn, submitSummaryFn, submitSignalFn, disposeFn, closeFn, deltaManager, quorum, audience, pendingLocalState, supportedFeatures, snapshotWithContents, } = context;
+        const { options, clientDetails, connected, baseSnapshot, submitFn, submitBatchFn, submitSummaryFn, submitSignalFn, disposeFn, closeFn, deltaManager, quorum, audience, 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;
         // Validate that the Loader is compatible with this Runtime.
-        const maybeloaderCompatDetailsForRuntime = context;
-        validateLoaderCompatibility(maybeloaderCompatDetailsForRuntime.ILayerCompatDetails, this.disposeFn);
+        const maybeLoaderCompatDetailsForRuntime = context;
+        validateLoaderCompatibility(maybeLoaderCompatDetailsForRuntime.ILayerCompatDetails, this.disposeFn);
         this.mc = createChildMonitoringContext({
             logger: this.baseLogger,
             namespace: "ContainerRuntime",
@@ -798,6 +809,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         // Note that we only need to pull the *initial* connected state from the context.
         // Later updates come through calls to setConnectionState.
         this.canSendOps = connected;
+        this.canSendSignals = this.getConnectionState
+            ? this.getConnectionState() === ConnectionState.Connected
+            : undefined;
         this.mc.logger.sendTelemetryEvent({
             eventName: "GCFeatureMatrix",
             metadataValue: JSON.stringify(metadata?.gcFeatureMatrix),
@@ -846,7 +860,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             this.mc.config.getNumber(maxConsecutiveReconnectsKey) ?? defaultMaxConsecutiveReconnects;
         // If the context has ILayerCompatDetails, it supports referenceSequenceNumbers since that features
         // predates ILayerCompatDetails.
-        const referenceSequenceNumbersSupported = maybeloaderCompatDetailsForRuntime.ILayerCompatDetails === undefined
+        const referenceSequenceNumbersSupported = maybeLoaderCompatDetailsForRuntime.ILayerCompatDetails === undefined
             ? supportedFeatures?.get("referenceSequenceNumbers") === true
             : true;
         if (runtimeOptions.flushMode === FlushModeExperimental.Async &&
@@ -1607,24 +1621,6 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (canSendOps && this.sessionSchema.idCompressorMode === "delayed") {
             this.loadIdCompressor();
         }
-        if (canSendOps === false && this.delayConnectClientId !== undefined) {
-            this.delayConnectClientId = undefined;
-            this.mc.logger.sendTelemetryEvent({
-                eventName: "UnsuccessfulConnectedTransition",
-            });
-            // Don't propagate "disconnected" event because we didn't propagate the previous "connected" event
-            return;
-        }
-        // If there are stashed blobs in the pending state, we need to delay
-        // propagation of the "connected" event until we have uploaded them to
-        // ensure we don't submit ops referencing a blob that has not been uploaded
-        const connecting = canSendOps && !this.canSendOps;
-        if (connecting && this.blobManager.hasPendingStashedUploads()) {
-            assert(!this.delayConnectClientId, 0x791 /* Connect event delay must be canceled before subsequent connect event */);
-            assert(!!clientId, 0x792 /* Must have clientId when connecting */);
-            this.delayConnectClientId = clientId;
-            return;
-        }
         this.setConnectionStateCore(canSendOps, clientId);
     }
     /**
@@ -1633,7 +1629,6 @@ export class ContainerRuntime extends TypedEventEmitter {
      * @remarks The connection state from container context used here when raising connected events.
      */
     setConnectionStateCore(canSendOps, clientId) {
-        assert(!this.delayConnectClientId, 0x394 /* connect event delay must be cleared before propagating connect event */);
         this.verifyNotClosed();
         // There might be no change of state due to Container calling this API after loading runtime.
         const canSendOpsChanged = this.canSendOps !== canSendOps;
@@ -1668,7 +1663,40 @@ export class ContainerRuntime extends TypedEventEmitter {
         }
         this.channelCollection.setConnectionState(canSendOps, clientId);
         this.garbageCollector.setConnectionState(canSendOps, clientId);
+        // Emit "connected" and "disconnected" events based on ability to send ops
         raiseConnectedEvent(this.mc.logger, this, this.connected /* canSendOps */, clientId);
+        // Emit "connectedToService" and "disconnectedFromService" events based on service connection status
+        this.emitServiceConnectionEvents(canSendOpsChanged, canSendOps, clientId);
+    }
+    /**
+     * Emits service connection events based on connection state changes.
+     *
+     * @remarks
+     * "connectedToService" is emitted when container connection state transitions to '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 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) {
+                // Emit for CatchingUp to Connected transition
+                this.emit("connectedToService", clientId, canSendOps);
+            }
+            else {
+                // Emit for 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);
+        }
     }
     async notifyOpReplay(message) {
         await this.pendingStateManager.applyStashedOpsAt(message.sequenceNumber);
@@ -1978,12 +2006,12 @@ export class ContainerRuntime extends TypedEventEmitter {
     }
     processSignal(message, local) {
         const envelope = message.content;
-        const transformed = {
+        const transformed = markUnverified({
             clientId: message.clientId,
             content: envelope.contents.content,
             type: envelope.contents.type,
             targetClientId: message.targetClientId,
-        };
+        });
         // Only collect signal telemetry for broadcast messages sent by the current client.
         if (message.clientId === this.clientId) {
             this.signalTelemetryManager.trackReceivedSignal(envelope, this.mc.logger, this.consecutiveReconnects);
@@ -2002,12 +2030,14 @@ export class ContainerRuntime extends TypedEventEmitter {
             // Due to a mismatch between different layers in terms of
             // what is the interface of passing signals, we need to adjust
             // the signal envelope before sending it to the datastores to be processed
-            const envelope = {
-                address,
-                contents: signalMessage.content,
+            const channelSignalMessage = {
+                ...signalMessage,
+                content: {
+                    address,
+                    contents: signalMessage.content,
+                },
             };
-            signalMessage.content = envelope;
-            this.channelCollection.processSignal(signalMessage, local);
+            this.channelCollection.processSignal(channelSignalMessage, local);
             return;
         }
         const addresses = address.split("/");
@@ -2157,7 +2187,7 @@ export class ContainerRuntime extends TypedEventEmitter {
     shouldSendOps() {
         // Note that the real (non-proxy) delta manager is needed here to get the readonly info. This is because
         // container runtime's ability to send ops depend on the actual readonly state of the delta manager.
-        return (this.connected && !this.innerDeltaManager.readOnlyInfo.readonly && !this.imminentClosure);
+        return this.connected && !this.innerDeltaManager.readOnlyInfo.readonly;
     }
     getQuorum() {
         return this._quorum;
@@ -3185,39 +3215,35 @@ export class ContainerRuntime extends TypedEventEmitter {
     }
     getPendingLocalState(props) {
         this.verifyNotClosed();
+        if (props?.notifyImminentClosure) {
+            throw new UsageError("notifyImminentClosure is no longer supported in ContainerRuntime");
+        }
         if (this.batchRunner.running) {
             throw new UsageError("can't get state while manually accumulating a batch");
         }
-        this.imminentClosure ||= props?.notifyImminentClosure ?? false;
-        const getSyncState = (pendingAttachmentBlobs) => {
+        // Flush pending batch.
+        // getPendingLocalState() is only exposed through Container.getPendingLocalState(), so it's safe
+        // to close current batch.
+        this.flush();
+        return PerformanceEvent.timedExec(this.mc.logger, {
+            eventName: "getPendingLocalState",
+        }, (event) => {
             const pending = this.pendingStateManager.getLocalState(props?.snapshotSequenceNumber);
             const sessionExpiryTimerStarted = props?.sessionExpiryTimerStarted ?? this.garbageCollector.sessionExpiryTimerStarted;
             const pendingIdCompressorState = this._idCompressor?.serialize(true);
-            return {
+            const pendingAttachmentBlobs = this.blobManager.getPendingBlobs();
+            const pendingRuntimeState = {
                 pending,
                 pendingIdCompressorState,
                 pendingAttachmentBlobs,
                 sessionExpiryTimerStarted,
             };
-        };
-        const perfEvent = {
-            eventName: "getPendingLocalState",
-            notifyImminentClosure: props?.notifyImminentClosure,
-        };
-        const logAndReturnPendingState = (event, pendingState) => {
             event.end({
-                attachmentBlobsSize: Object.keys(pendingState?.pendingAttachmentBlobs ?? {}).length,
-                pendingOpsSize: pendingState?.pending?.pendingStates.length,
+                attachmentBlobsSize: Object.keys(pendingAttachmentBlobs ?? {}).length,
+                pendingOpsSize: pendingRuntimeState?.pending?.pendingStates.length,
             });
-            return pendingState;
-        };
-        // Flush pending batch.
-        // getPendingLocalState() is only exposed through Container.closeAndGetPendingLocalState(), so it's safe
-        // to close current batch.
-        this.flush();
-        return props?.notifyImminentClosure === true
-            ? PerformanceEvent.timedExecAsync(this.mc.logger, perfEvent, async (event) => logAndReturnPendingState(event, getSyncState(await this.blobManager.attachAndGetPendingBlobs(props?.stopBlobAttachingSignal))))
-            : PerformanceEvent.timedExec(this.mc.logger, perfEvent, (event) => logAndReturnPendingState(event, getSyncState()));
+            return pendingRuntimeState;
+        });
     }
     summarizeOnDemand(options) {
         if (this._summarizer !== undefined) {
@@ -3247,11 +3273,24 @@ export class ContainerRuntime extends TypedEventEmitter {
             return this.summaryManager.enqueueSummarize(options);
         }
     }
+    getJoinedStatus() {
+        const getConnectionState = this.getConnectionState;
+        if (getConnectionState) {
+            const connectionState = getConnectionState();
+            if (connectionState === ConnectionState.Connected) {
+                return this.canSendOps ? "joinedForWriting" : "joinedForReading";
+            }
+        }
+        else if (this.canSendOps) {
+            return "joinedForWriting";
+        }
+        return "disconnected";
+    }
     acquireExtension(id, factory, ...useContext) {
         let entry = this.extensions.get(id);
         if (entry === undefined) {
             const runtime = {
-                isConnected: () => this.connected,
+                getJoinedStatus: this.getJoinedStatus.bind(this),
                 getClientId: () => this.clientId,
                 events: this.lazyEventsForExtensions.value,
                 logger: this.baseLogger,