@fluidframework/container-loader 1.0.0 → 1.1.0-76254

package/lib/container.js

@@ -9,7 +9,7 @@ import { assert, performance, unreachableCase } from "@fluidframework/common-uti
 import { AttachState, isFluidCodeDetails, } from "@fluidframework/container-definitions";
 import { DataCorruptionError, extractSafePropertiesFromMessage, GenericError, UsageError, } from "@fluidframework/container-utils";
 import { readAndParse, OnlineStatus, isOnline, ensureFluidResolvedUrl, combineAppAndProtocolSummary, runWithRetry, isFluidResolvedUrl, } from "@fluidframework/driver-utils";
-import { isSystemMessage, ProtocolOpHandler, } from "@fluidframework/protocol-base";
+import { isSystemMessage, ProtocolOpHandlerWithClientValidation, } from "@fluidframework/protocol-base";
 import { MessageType, SummaryType, } from "@fluidframework/protocol-definitions";
 import { ChildLogger, EventEmitterWithErrorHandling, PerformanceEvent, raiseConnectedEvent, TelemetryLogger, connectedEventName, disconnectedEventName, normalizeError, loggerToMonitoringContext, wrapError, } from "@fluidframework/telemetry-utils";
 import { Audience } from "./audience";
@@ -110,7 +110,7 @@ export class Container extends EventEmitterWithErrorHandling {
         // Tells if container can reconnect on losing fist connection
         // If false, container gets closed on loss of connection.
         this._canReconnect = true;
-        this._lifecycleState = "created";
+        this._lifecycleState = "loading";
         this._attachState = AttachState.Detached;
         this.resumedOpProcessingAfterLoad = false;
         this.firstConnection = true;
@@ -166,16 +166,14 @@ export class Container extends EventEmitterWithErrorHandling {
             logConnectionStateChangeTelemetry: (value, oldState, reason) => this.logConnectionStateChangeTelemetry(value, oldState, reason),
             shouldClientJoinWrite: () => this._deltaManager.connectionManager.shouldJoinWrite(),
             maxClientLeaveWaitTime: this.loader.services.options.maxClientLeaveWaitTime,
-            logConnectionIssue: (eventName) => {
+            logConnectionIssue: (eventName, details) => {
                 // We get here when socket does not receive any ops on "write" connection, including
                 // its own join op. Attempt recovery option.
-                this._deltaManager.logConnectionIssue({
-                    eventName,
-                    duration: performance.now() - this.connectionTransitionTimes[ConnectionState.CatchingUp],
-                });
+                this._deltaManager.logConnectionIssue(Object.assign({ eventName, duration: performance.now() - this.connectionTransitionTimes[ConnectionState.CatchingUp] }, (details === undefined ? {} : { details: JSON.stringify(details) })));
             },
             connectionStateChanged: () => {
-                if (this.loaded) {
+                // Fire events only if container is fully loaded and not closed
+                if (this._lifecycleState === "loaded") {
                     this.propagateConnectionState();
                 }
             },
@@ -261,7 +259,6 @@ export class Container extends EventEmitterWithErrorHandling {
         });
         return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "Load" }, async (event) => new Promise((resolve, reject) => {
             var _a, _b;
-            container._lifecycleState = "loading";
             const version = loadOptions.version;
             const defaultMode = { opsBeforeReturn: "cached" };
             // if we have pendingLocalState, anything we cached is not useful and we shouldn't wait for connection
@@ -296,7 +293,6 @@ export class Container extends EventEmitterWithErrorHandling {
     static async createDetached(loader, codeDetails) {
         const container = new Container(loader, {});
         return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "CreateDetached" }, async (_event) => {
-            container._lifecycleState = "loading";
             await container.createDetached(codeDetails);
             return container;
         }, { start: true, end: true, cancel: "generic" });
@@ -309,20 +305,16 @@ export class Container extends EventEmitterWithErrorHandling {
         const container = new Container(loader, {});
         return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
             const deserializedSummary = JSON.parse(snapshot);
-            container._lifecycleState = "loading";
             await container.rehydrateDetachedFromSnapshot(deserializedSummary);
             return container;
         }, { start: true, end: true, cancel: "generic" });
     }
-    get loaded() {
-        return (this._lifecycleState !== "created" && this._lifecycleState !== "loading");
-    }
-    set loaded(t) {
-        assert(t, 0x27d /* "Setting loaded state to false is not supported" */);
-        assert(this._lifecycleState !== "created", 0x27e /* "Must go through loading state before loaded" */);
+    setLoaded() {
         // It's conceivable the container could be closed when this is called
         // Only transition states if currently loading
         if (this._lifecycleState === "loading") {
+            // Propagate current connection state through the system.
+            this.propagateConnectionState();
             this._lifecycleState = "loaded";
         }
     }
@@ -444,19 +436,30 @@ export class Container extends EventEmitterWithErrorHandling {
         return this.protocolHandler.quorum;
     }
     close(error) {
+        // 1. Ensure that close sequence is exactly the same no matter if it's initiated by host or by DeltaManager
+        // 2. We need to ensure that we deliver disconnect event to runtime properly. See connectionStateChanged
+        //    handler. We only deliver events if container fully loaded. Transitioning from "loading" ->
+        //    "closing" will lose that info (can also solve by tracking extra state).
+        this._deltaManager.close(error);
+        assert(this.connectionState === ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
+        assert(this._lifecycleState === "closed", 0x314 /* Container properly closed */);
+    }
+    closeCore(error) {
         var _a, _b, _c, _d;
-        if (this.closed) {
-            return;
-        }
+        assert(!this.closed, 0x315 /* re-entrancy */);
         try {
-            this._lifecycleState = "closing";
             // Ensure that we raise all key events even if one of these throws
             try {
-                this._deltaManager.close(error);
+                // Raise event first, to ensure we capture _lifecycleState before transition.
+                // This gives us a chance to know what errors happened on open vs. on fully loaded container.
+                this.mc.logger.sendTelemetryEvent({
+                    eventName: "ContainerClose",
+                    category: error === undefined ? "generic" : "error",
+                }, error);
+                this._lifecycleState = "closing";
                 (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.close();
                 this.connectionStateHandler.dispose();
                 (_b = this._context) === null || _b === void 0 ? void 0 : _b.dispose(error !== undefined ? new Error(error.message) : undefined);
-                assert(this.connectionState === ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
                 (_c = this._storageService) === null || _c === void 0 ? void 0 : _c.dispose();
                 // Notify storage about critical errors. They may be due to disconnect between client & server knowledge
                 // about file, like file being overwritten in storage, but client having stale local cache.
@@ -466,10 +469,6 @@ export class Container extends EventEmitterWithErrorHandling {
             catch (exception) {
                 this.mc.logger.sendErrorEvent({ eventName: "ContainerCloseException" }, exception);
             }
-            this.mc.logger.sendTelemetryEvent({
-                eventName: "ContainerClose",
-                category: error === undefined ? "generic" : "error",
-            }, error);
             this.emit("closed", error);
             this.removeAllListeners();
             if (this.visibilityEventHandler !== undefined) {
@@ -487,11 +486,12 @@ export class Container extends EventEmitterWithErrorHandling {
         assert(this.attachState === AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
         assert(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
         assert(!!this._protocolHandler, 0x2e3 /* "Must have a valid protocol handler instance" */);
+        assert(this._protocolHandler.attributes.term !== undefined, 0x30b /* Must have a valid protocol handler instance */);
         const pendingState = {
             pendingRuntimeState: this.context.getPendingLocalState(),
             url: this.resolvedUrl.url,
-            protocol: this._protocolHandler.getProtocolState(),
-            term: this._protocolHandler.term,
+            protocol: this.protocolHandler.getProtocolState(),
+            term: this._protocolHandler.attributes.term,
             clientId: this.clientId,
         };
         this.close();
@@ -790,10 +790,8 @@ export class Container extends EventEmitterWithErrorHandling {
         const codeDetails = this.getCodeDetailsFromQuorum();
         await this.instantiateContext(true, // existing
         codeDetails, snapshot, pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.pendingRuntimeState);
-        // Propagate current connection state through the system.
-        this.propagateConnectionState();
         // Internal context is fully loaded at this point
-        this.loaded = true;
+        this.setLoaded();
         // We might have hit some failure that did not manifest itself in exception in this flow,
         // do not start op processing in such case - static version of Container.load() will handle it correctly.
         if (!this.closed) {
@@ -849,8 +847,7 @@ export class Container extends EventEmitterWithErrorHandling {
         qValues);
         // The load context - given we seeded the quorum - will be great
         await this.instantiateContextDetached(false);
-        this.propagateConnectionState();
-        this.loaded = true;
+        this.setLoaded();
     }
     async rehydrateDetachedFromSnapshot(detachedContainerSnapshot) {
         if (detachedContainerSnapshot.tree[".hasAttachmentBlobs"] !== undefined) {
@@ -871,8 +868,7 @@ export class Container extends EventEmitterWithErrorHandling {
             codeDetails !== undefined ? initQuorumValuesFromCodeDetails(codeDetails) : []);
         await this.instantiateContextDetached(true, // existing
         snapshotTree);
-        this.loaded = true;
-        this.propagateConnectionState();
+        this.setLoaded();
     }
     async connectStorageService() {
         var _a, _b;
@@ -926,7 +922,7 @@ export class Container extends EventEmitterWithErrorHandling {
         return protocolHandler;
     }
     async initializeProtocolState(attributes, members, proposals, values) {
-        const protocol = new ProtocolOpHandler(attributes.minimumSequenceNumber, attributes.sequenceNumber, attributes.term, members, proposals, values, (key, value) => this.submitMessage(MessageType.Propose, { key, value }));
+        const protocol = new ProtocolOpHandlerWithClientValidation(attributes.minimumSequenceNumber, attributes.sequenceNumber, attributes.term, members, proposals, values, (key, value) => this.submitMessage(MessageType.Propose, { key, value }));
         const protocolLogger = ChildLogger.create(this.subLogger, "ProtocolHandler");
         protocol.quorum.on("error", (error) => {
             protocolLogger.sendErrorEvent(error);
@@ -954,17 +950,11 @@ export class Container extends EventEmitterWithErrorHandling {
         return protocol;
     }
     captureProtocolSummary() {
-        const quorumSnapshot = this.protocolHandler.quorum.snapshot();
-        // Save attributes for the document
-        const documentAttributes = {
-            minimumSequenceNumber: this.protocolHandler.minimumSequenceNumber,
-            sequenceNumber: this.protocolHandler.sequenceNumber,
-            term: this.protocolHandler.term,
-        };
+        const quorumSnapshot = this.protocolHandler.snapshot();
         const summary = {
             tree: {
                 attributes: {
-                    content: JSON.stringify(documentAttributes),
+                    content: JSON.stringify(this.protocolHandler.attributes),
                     type: SummaryType.Blob,
                 },
                 quorumMembers: {
@@ -1053,7 +1043,7 @@ export class Container extends EventEmitterWithErrorHandling {
             this.emit("readonly", readonly);
         });
         deltaManager.on("closed", (error) => {
-            this.close(error);
+            this.closeCore(error);
         });
         return deltaManager;
     }
@@ -1109,6 +1099,7 @@ export class Container extends EventEmitterWithErrorHandling {
         }
     }
     propagateConnectionState() {
+        var _a;
         const logOpsOnReconnect = this.connectionState === ConnectionState.Connected &&
             !this.firstConnection &&
             this.connectionMode === "write";
@@ -1116,11 +1107,11 @@ export class Container extends EventEmitterWithErrorHandling {
             this.messageCountAfterDisconnection = 0;
         }
         const state = this.connectionState === ConnectionState.Connected;
-        if (!this.context.disposed) {
+        // Both protocol and context should not be undefined if we got so far.
+        if (((_a = this._context) === null || _a === void 0 ? void 0 : _a.disposed) === false) {
             this.context.setConnectionState(state, this.clientId);
         }
-        assert(this.protocolHandler !== undefined, 0x0dc /* "Protocol handler should be set here" */);
-        this.protocolHandler.quorum.setConnectionState(state, this.clientId);
+        this.protocolHandler.setConnectionState(state, this.clientId);
         raiseConnectedEvent(this.mc.logger, this, state, this.clientId);
         if (logOpsOnReconnect) {
             this.mc.logger.sendTelemetryEvent({ eventName: "OpsSentOnReconnect", count: this.messageCountAfterDisconnection });
@@ -1162,32 +1153,19 @@ export class Container extends EventEmitterWithErrorHandling {
         return this._deltaManager.submit(type, contents, batch, metadata);
     }
     processRemoteMessage(message) {
-        var _a, _b;
-        // Check and report if we're getting messages from a clientId that we previously
-        // flagged as shouldHaveLeft, or from a client that's not in the quorum but should be
-        if (message.clientId != null) {
-            let errorMsg;
-            const client = this.getQuorum().getMember(message.clientId);
-            if (client === undefined && message.type !== MessageType.ClientJoin) {
-                // pre-0.58 error message: messageClientIdMissingFromQuorum
-                errorMsg = "Remote message's clientId is missing from the quorum";
-            }
-            else if ((client === null || client === void 0 ? void 0 : client.shouldHaveLeft) === true && message.type !== MessageType.NoOp) {
-                // pre-0.58 error message: messageClientIdShouldHaveLeft
-                errorMsg = "Remote message's clientId already should have left";
-            }
-            if (errorMsg !== undefined) {
-                const error = new DataCorruptionError(errorMsg, extractSafePropertiesFromMessage(message));
-                this.close(normalizeError(error));
-            }
-        }
         const local = this.clientId === message.clientId;
+        // Allow the protocol handler to process the message
+        let result = { immediateNoOp: false };
+        try {
+            result = this.protocolHandler.processMessage(message, local);
+        }
+        catch (error) {
+            this.close(wrapError(error, (errorMessage) => new DataCorruptionError(errorMessage, extractSafePropertiesFromMessage(message))));
+        }
         // Forward non system messages to the loaded runtime for processing
         if (!isSystemMessage(message)) {
             this.context.process(message, local, undefined);
         }
-        // Allow the protocol handler to process the message
-        const result = this.protocolHandler.processMessage(message, local);
         // Inactive (not in quorum or not writers) clients don't take part in the minimum sequence number calculation.
         if (this.activeConnection()) {
             if (this.collabWindowTracker === undefined) {
@@ -1199,7 +1177,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 this.collabWindowTracker = new CollabWindowTracker((type, contents) => {
                     assert(this.activeConnection(), 0x241 /* "disconnect should result in stopSequenceNumberUpdate() call" */);
                     this.submitMessage(type, contents);
-                }, (_a = this.serviceConfiguration) === null || _a === void 0 ? void 0 : _a.noopTimeFrequency, (_b = this.serviceConfiguration) === null || _b === void 0 ? void 0 : _b.noopCountFrequency);
+                }, this.serviceConfiguration.noopTimeFrequency, this.serviceConfiguration.noopCountFrequency);
             }
             this.collabWindowTracker.scheduleSequenceNumberUpdate(message, result.immediateNoOp === true);
         }