@fluidframework/container-loader 1.2.0 → 2.0.0-internal.1.0.0.81589

package/dist/container.js

@@ -15,7 +15,6 @@ const common_utils_1 = require("@fluidframework/common-utils");
 const container_definitions_1 = require("@fluidframework/container-definitions");
 const container_utils_1 = require("@fluidframework/container-utils");
 const driver_utils_1 = require("@fluidframework/driver-utils");
-const protocol_base_1 = require("@fluidframework/protocol-base");
 const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
 const audience_1 = require("./audience");
@@ -34,6 +33,7 @@ const quorum_1 = require("./quorum");
 const collabWindowTracker_1 = require("./collabWindowTracker");
 const connectionManager_1 = require("./connectionManager");
 const connectionState_1 = require("./connectionState");
+const protocol_1 = require("./protocol");
 const detachedContainerRefSeqNumber = 0;
 const dirtyContainerEvent = "dirty";
 const savedContainerEvent = "saved";
@@ -63,6 +63,10 @@ async function waitContainerToCatchUp(container) {
                 : new container_utils_1.GenericError(baseMessage));
         };
         container.on("closed", closedCallback);
+        // Depending on config, transition to "connected" state may include the guarantee
+        // that all known ops have been processed.  If so, we may introduce additional wait here.
+        // Waiting for "connected" state in either case gets us at least to our own Join op
+        // which is a reasonable approximation of "caught up"
         const waitForOps = () => {
             (0, common_utils_1.assert)(container.connectionState === connectionState_1.ConnectionState.CatchingUp
                 || container.connectionState === connectionState_1.ConnectionState.Connected, 0x0cd /* "Container disconnected while waiting for ops!" */);
@@ -105,9 +109,22 @@ exports.waitContainerToCatchUp = waitContainerToCatchUp;
 const getCodeProposal = 
 // eslint-disable-next-line @typescript-eslint/no-unsafe-return
 (quorum) => { var _a; return (_a = quorum.get("code")) !== null && _a !== void 0 ? _a : quorum.get("code2"); };
+/**
+ * Helper function to report to telemetry cases where operation takes longer than expected (1s)
+ * @param logger - logger to use
+ * @param eventName - event name
+ * @param action - functor to call and measure
+ */
+async function ReportIfTooLong(logger, eventName, action) {
+    const event = telemetry_utils_1.PerformanceEvent.start(logger, { eventName });
+    const props = await action();
+    if (event.duration > 1000) {
+        event.end(props);
+    }
+}
 const summarizerClientType = "summarizer";
 class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
-    constructor(loader, config) {
+    constructor(loader, config, protocolHandlerBuilder) {
         var _a, _b;
         super((name, error) => {
             this.mc.logger.sendErrorEvent({
@@ -116,6 +133,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             }, error);
         });
         this.loader = loader;
+        this.protocolHandlerBuilder = protocolHandlerBuilder;
         // Tells if container can reconnect on losing fist connection
         // If false, container gets closed on loss of connection.
         this._canReconnect = true;
@@ -129,7 +147,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.attachStarted = false;
         this._dirtyContainer = false;
         this.setAutoReconnectTime = common_utils_1.performance.now();
-        this._audience = new audience_1.Audience();
         this.clientDetailsOverride = config.clientDetailsOverride;
         this._resolvedUrl = config.resolvedUrl;
         if (config.canReconnect !== undefined) {
@@ -149,6 +166,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 containerAttachState: () => this._attachState,
                 containerLifecycleState: () => this._lifecycleState,
                 containerConnectionState: () => connectionState_1.ConnectionState[this.connectionState],
+                serializedContainer: config.serializedContainerState !== undefined,
             },
             // we need to be judicious with our logging here to avoid generating too much data
             // all data logged here should be broadly applicable, and not specific to a
@@ -161,6 +179,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 containerLoadedFromVersionId: () => { var _a; return (_a = this.loadedFromVersion) === null || _a === void 0 ? void 0 : _a.id; },
                 containerLoadedFromVersionDate: () => { var _a; return (_a = this.loadedFromVersion) === null || _a === void 0 ? void 0 : _a.date; },
                 // message information to associate errors with the specific execution state
+                // dmLastMsqSeqNumber: if present, same as dmLastProcessedSeqNumber
                 dmLastMsqSeqNumber: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.sequenceNumber; },
                 dmLastMsqSeqTimestamp: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.timestamp; },
                 dmLastMsqSeqClientId: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.clientId; },
@@ -260,13 +279,13 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     /**
      * Load an existing container.
      */
-    static async load(loader, loadOptions, pendingLocalState) {
+    static async load(loader, loadOptions, pendingLocalState, protocolHandlerBuilder) {
         const container = new Container(loader, {
             clientDetailsOverride: loadOptions.clientDetailsOverride,
             resolvedUrl: loadOptions.resolvedUrl,
             canReconnect: loadOptions.canReconnect,
             serializedContainerState: pendingLocalState,
-        });
+        }, protocolHandlerBuilder);
         return telemetry_utils_1.PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "Load" }, async (event) => new Promise((resolve, reject) => {
             var _a, _b;
             const version = loadOptions.version;
@@ -300,8 +319,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     /**
      * Create a new container in a detached state.
      */
-    static async createDetached(loader, codeDetails) {
-        const container = new Container(loader, {});
+    static async createDetached(loader, codeDetails, protocolHandlerBuilder) {
+        const container = new Container(loader, {}, protocolHandlerBuilder);
         return telemetry_utils_1.PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "CreateDetached" }, async (_event) => {
             await container.createDetached(codeDetails);
             return container;
@@ -311,8 +330,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      * Create a new container in a detached state that is initialized with a
      * snapshot from a previous detached container.
      */
-    static async rehydrateDetachedFromSnapshot(loader, snapshot) {
-        const container = new Container(loader, {});
+    static async rehydrateDetachedFromSnapshot(loader, snapshot, protocolHandlerBuilder) {
+        const container = new Container(loader, {}, protocolHandlerBuilder);
         return telemetry_utils_1.PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
             const deserializedSummary = JSON.parse(snapshot);
             await container.rehydrateDetachedFromSnapshot(deserializedSummary);
@@ -425,12 +444,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      * Retrieves the audience associated with the document
      */
     get audience() {
-        return this._audience;
+        return this.protocolHandler.audience;
     }
     /**
      * Returns true if container is dirty.
      * Which means data loss if container is closed at that same moment
-     * Most likely that happens when there is no network connection to ordering service
+     * Most likely that happens when there is no network connection to Relay Service
      */
     get isDirty() {
         return this._dirtyContainer;
@@ -496,7 +515,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         (0, common_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
         (0, common_utils_1.assert)(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
         (0, common_utils_1.assert)(!!this._protocolHandler, 0x2e3 /* "Must have a valid protocol handler instance" */);
-        (0, common_utils_1.assert)(this._protocolHandler.attributes.term !== undefined, 0x30b /* Must have a valid protocol handler instance */);
+        (0, common_utils_1.assert)(this._protocolHandler.attributes.term !== undefined, "Must have a valid protocol handler instance");
         const pendingState = {
             pendingRuntimeState: this.context.getPendingLocalState(),
             url: this.resolvedUrl.url,
@@ -795,20 +814,21 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // ...load in the existing quorum
         // Initialize the protocol handler
         this._protocolHandler = pendingLocalState === undefined
-            ? await this.initializeProtocolStateFromSnapshot(attributes, this.storageService, snapshot)
-            : await this.initializeProtocolState(attributes, pendingLocalState.protocol.members, pendingLocalState.protocol.proposals, pendingLocalState.protocol.values);
+            ? await this.initializeProtocolStateFromSnapshot(attributes, this.storageService, snapshot) : await this.initializeProtocolState(attributes, {
+            members: pendingLocalState.protocol.members,
+            proposals: pendingLocalState.protocol.proposals,
+            values: pendingLocalState.protocol.values,
+        });
         const codeDetails = this.getCodeDetailsFromQuorum();
         await this.instantiateContext(true, // existing
         codeDetails, snapshot, pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.pendingRuntimeState);
-        // Internal context is fully loaded at this point
-        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) {
             if (opsBeforeReturnP !== undefined) {
                 this._deltaManager.inbound.resume();
-                await opsBeforeReturnP;
-                await this._deltaManager.inbound.waitTillProcessingDone();
+                await ReportIfTooLong(this.mc.logger, "WaitOps", async () => { await opsBeforeReturnP; return {}; });
+                await ReportIfTooLong(this.mc.logger, "WaitOpProcessing", async () => this._deltaManager.inbound.waitTillProcessingDone());
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 this._deltaManager.inbound.pause();
             }
@@ -834,9 +854,13 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         if (this.closed) {
             throw new Error("Container was closed while load()");
         }
+        // Internal context is fully loaded at this point
+        this.setLoaded();
         return {
             sequenceNumber: attributes.sequenceNumber,
             version: versionId,
+            dmLastProcessedSeqNumber: this._deltaManager.lastSequenceNumber,
+            dmLastKnownSeqNumber: this._deltaManager.lastKnownSeqNumber,
         };
     }
     async createDetached(source) {
@@ -848,9 +872,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         await this.attachDeltaManagerOpHandler(attributes);
         // Need to just seed the source data in the code quorum. Quorum itself is empty
         const qValues = (0, quorum_1.initQuorumValuesFromCodeDetails)(source);
-        this._protocolHandler = await this.initializeProtocolState(attributes, [], // members
-        [], // proposals
-        qValues);
+        this._protocolHandler = await this.initializeProtocolState(attributes, {
+            members: [],
+            proposals: [],
+            values: qValues,
+        });
         // The load context - given we seeded the quorum - will be great
         await this.instantiateContextDetached(false);
         this.setLoaded();
@@ -869,9 +895,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         const qValues = await (0, driver_utils_1.readAndParse)(this._storage, baseTree.blobs.quorumValues);
         const codeDetails = (0, quorum_1.getCodeDetailsFromQuorumValues)(qValues);
         this._protocolHandler =
-            await this.initializeProtocolState(attributes, [], // members
-            [], // proposals
-            codeDetails !== undefined ? (0, quorum_1.initQuorumValuesFromCodeDetails)(codeDetails) : []);
+            await this.initializeProtocolState(attributes, {
+                members: [],
+                proposals: [],
+                values: codeDetails !== undefined ? (0, quorum_1.initQuorumValuesFromCodeDetails)(codeDetails) : [],
+            });
         await this.instantiateContextDetached(true, // existing
         snapshotTree);
         this.setLoaded();
@@ -913,22 +941,27 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         return attributes;
     }
     async initializeProtocolStateFromSnapshot(attributes, storage, snapshot) {
-        let members = [];
-        let proposals = [];
-        let values = [];
+        const quorumSnapshot = {
+            members: [],
+            proposals: [],
+            values: [],
+        };
         if (snapshot !== undefined) {
             const baseTree = (0, utils_1.getProtocolSnapshotTree)(snapshot);
-            [members, proposals, values] = await Promise.all([
+            [quorumSnapshot.members, quorumSnapshot.proposals, quorumSnapshot.values] = await Promise.all([
                 (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumMembers),
                 (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumProposals),
                 (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumValues),
             ]);
         }
-        const protocolHandler = await this.initializeProtocolState(attributes, members, proposals, values);
+        const protocolHandler = await this.initializeProtocolState(attributes, quorumSnapshot);
         return protocolHandler;
     }
-    async initializeProtocolState(attributes, members, proposals, values) {
-        const protocol = new protocol_base_1.ProtocolOpHandlerWithClientValidation(attributes.minimumSequenceNumber, attributes.sequenceNumber, attributes.term, members, proposals, values, (key, value) => this.submitMessage(protocol_definitions_1.MessageType.Propose, { key, value }));
+    async initializeProtocolState(attributes, quorumSnapshot) {
+        var _a, _b;
+        const protocolHandlerBuilder = (_a = this.protocolHandlerBuilder) !== null && _a !== void 0 ? _a : ((...args) => new protocol_1.ProtocolHandler(...args, new audience_1.Audience()));
+        const protocol = protocolHandlerBuilder(attributes, quorumSnapshot, (key, value) => this.submitMessage(protocol_definitions_1.MessageType.Propose, { key, value }), (_b = this._initialClients) !== null && _b !== void 0 ? _b : []);
+        this._initialClients = undefined;
         const protocolLogger = telemetry_utils_1.ChildLogger.create(this.subLogger, "ProtocolHandler");
         protocol.quorum.on("error", (error) => {
             protocolLogger.sendErrorEvent(error);
@@ -1022,14 +1055,25 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         deltaManager.inbound.pause();
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         deltaManager.inboundSignal.pause();
-        deltaManager.on("connect", (details, opsBehind) => {
+        deltaManager.on("connect", (details, _opsBehind) => {
             var _a;
-            // Back-compat for new client and old server.
-            this._audience.clear();
-            for (const priorClient of (_a = details.initialClients) !== null && _a !== void 0 ? _a : []) {
-                this._audience.addMember(priorClient.clientId, priorClient.client);
+            if (this._protocolHandler === undefined) {
+                // Store the initial clients so that they can be submitted to the
+                // protocol handler when it is created.
+                this._initialClients = details.initialClients;
             }
-            this.connectionStateHandler.receivedConnectEvent(this.connectionMode, details);
+            else {
+                // When reconnecting, the protocol handler is already created,
+                // so we can update the audience right now.
+                this._protocolHandler.audience.clear();
+                for (const priorClient of (_a = details.initialClients) !== null && _a !== void 0 ? _a : []) {
+                    this._protocolHandler.audience.addMember(priorClient.clientId, priorClient.client);
+                }
+            }
+            const deltaManagerForCatchingUp = this.mc.config.getBoolean("Fluid.Container.CatchUpBeforeDeclaringConnected") === true ?
+                this.deltaManager
+                : undefined;
+            this.connectionStateHandler.receivedConnectEvent(this.connectionMode, details, deltaManagerForCatchingUp);
         });
         deltaManager.on("disconnect", (reason) => {
             var _a;
@@ -1201,15 +1245,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     processSignal(message) {
         // No clientId indicates a system signal message.
         if (message.clientId === null) {
-            const innerContent = message.content;
-            if (innerContent.type === protocol_definitions_1.MessageType.ClientJoin) {
-                const newClient = innerContent.content;
-                this._audience.addMember(newClient.clientId, newClient.client);
-            }
-            else if (innerContent.type === protocol_definitions_1.MessageType.ClientLeave) {
-                const leftClientId = innerContent.content;
-                this._audience.removeMember(leftClientId);
-            }
+            this.protocolHandler.processSignal(message);
         }
         else {
             const local = this.clientId === message.clientId;