@fluidframework/container-loader 0.59.4000 → 1.0.1

package/lib/container.js

@@ -36,7 +36,7 @@ const savedContainerEvent = "saved";
  * Useful when resolving URIs and hitting 404, due to container being loaded from (stale) snapshot and not being
  * up to date. Host may chose to wait in such case and retry resolving URI.
  * Warning: Will wait infinitely for connection to establish if there is no connection.
- * May result in deadlock if Container.setAutoReconnect(false) is called and never switched back to auto-reconnect.
+ * May result in deadlock if Container.disconnect() is called and never followed by a call to Container.connect().
  * @returns true: container is up to date, it processed all the ops that were know at the time of first connection
  *          false: storage does not provide indication of how far the client is. Container processed
  *          all the ops known to it, but it maybe still behind.
@@ -58,7 +58,8 @@ export async function waitContainerToCatchUp(container) {
         };
         container.on("closed", closedCallback);
         const waitForOps = () => {
-            assert(container.connectionState !== ConnectionState.Disconnected, 0x0cd /* "Container disconnected while waiting for ops!" */);
+            assert(container.connectionState === ConnectionState.CatchingUp
+                || container.connectionState === ConnectionState.Connected, 0x0cd /* "Container disconnected while waiting for ops!" */);
             const hasCheckpointSequenceNumber = deltaManager.hasCheckpointSequenceNumber;
             const connectionOpSeqNumber = deltaManager.lastKnownSeqNumber;
             assert(deltaManager.lastSequenceNumber <= connectionOpSeqNumber, 0x266 /* "lastKnownSeqNumber should never be below last processed sequence number" */);
@@ -89,9 +90,7 @@ export async function waitContainerToCatchUp(container) {
             waitForOps();
         };
         container.on(connectedEventName, callback);
-        // TODO: Remove null check after next release #8523
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        container.resume();
+        container.connect();
     });
 }
 const getCodeProposal = 
@@ -100,7 +99,7 @@ const getCodeProposal =
 const summarizerClientType = "summarizer";
 export class Container extends EventEmitterWithErrorHandling {
     constructor(loader, config) {
-        var _a;
+        var _a, _b;
         super((name, error) => {
             this.mc.logger.sendErrorEvent({
                 eventName: "ContainerEventHandlerException",
@@ -172,7 +171,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 // its own join op. Attempt recovery option.
                 this._deltaManager.logConnectionIssue({
                     eventName,
-                    duration: performance.now() - this.connectionTransitionTimes[ConnectionState.Connecting],
+                    duration: performance.now() - this.connectionTransitionTimes[ConnectionState.CatchingUp],
                 });
             },
             connectionStateChanged: () => {
@@ -180,7 +179,7 @@ export class Container extends EventEmitterWithErrorHandling {
                     this.propagateConnectionState();
                 }
             },
-        }, this.mc.logger);
+        }, this.mc.logger, (_b = config.serializedContainerState) === null || _b === void 0 ? void 0 : _b.clientId);
         this.on(savedContainerEvent, () => {
             this.connectionStateHandler.containerSaved();
         });
@@ -258,16 +257,17 @@ export class Container extends EventEmitterWithErrorHandling {
             clientDetailsOverride: loadOptions.clientDetailsOverride,
             resolvedUrl: loadOptions.resolvedUrl,
             canReconnect: loadOptions.canReconnect,
+            serializedContainerState: pendingLocalState,
         });
         return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "Load" }, async (event) => new Promise((resolve, reject) => {
-            var _a;
+            var _a, _b;
             container._lifecycleState = "loading";
             const version = loadOptions.version;
-            // always load unpaused with pending ops!
-            // It is also default mode in general.
             const defaultMode = { opsBeforeReturn: "cached" };
-            assert(pendingLocalState === undefined || loadOptions.loadMode === undefined, 0x1e1 /* "pending state requires immediate connection!" */);
-            const mode = (_a = loadOptions.loadMode) !== null && _a !== void 0 ? _a : defaultMode;
+            // if we have pendingLocalState, anything we cached is not useful and we shouldn't wait for connection
+            // to return container, so ignore this value and use undefined for opsBeforeReturn
+            const mode = pendingLocalState
+                ? Object.assign(Object.assign({}, ((_a = loadOptions.loadMode) !== null && _a !== void 0 ? _a : defaultMode)), { opsBeforeReturn: undefined }) : (_b = loadOptions.loadMode) !== null && _b !== void 0 ? _b : defaultMode;
             const onClosed = (err) => {
                 // pre-0.58 error message: containerClosedWithoutErrorDuringLoad
                 reject(err !== null && err !== void 0 ? err : new GenericError("Container closed without error during load"));
@@ -486,9 +486,13 @@ export class Container extends EventEmitterWithErrorHandling {
         // a new clientId and a future container using stale pending state without the new clientId would resubmit them
         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" */);
         const pendingState = {
             pendingRuntimeState: this.context.getPendingLocalState(),
             url: this.resolvedUrl.url,
+            protocol: this._protocolHandler.getProtocolState(),
+            term: this._protocolHandler.term,
+            clientId: this.clientId,
         };
         this.close();
         return JSON.stringify(pendingState);
@@ -532,7 +536,7 @@ export class Container extends EventEmitterWithErrorHandling {
                     // starting to attach the container to storage.
                     // Also, this should only be fired in detached container.
                     this._attachState = AttachState.Attaching;
-                    this.context.notifyAttaching();
+                    this.context.notifyAttaching(getSnapshotTreeFromSerializedContainer(summary));
                 }
                 // Actually go and create the resolved document
                 const createNewResolvedUrl = await this.urlResolver.resolve(request);
@@ -567,7 +571,7 @@ export class Container extends EventEmitterWithErrorHandling {
                     const protocolSummary = this.captureProtocolSummary();
                     summary = combineAppAndProtocolSummary(appSummary, protocolSummary);
                     this._attachState = AttachState.Attaching;
-                    this.context.notifyAttaching();
+                    this.context.notifyAttaching(getSnapshotTreeFromSerializedContainer(summary));
                     await this.storageService.uploadSummaryWithContext(summary, {
                         referenceSequenceNumber: 0,
                         ackHandle: undefined,
@@ -597,27 +601,6 @@ export class Container extends EventEmitterWithErrorHandling {
     async request(path) {
         return PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Request" }, async () => this.context.request(path), { end: true, cancel: "error" });
     }
-    /**
-     * Dictates whether or not the current container will automatically attempt to reconnect to the delta stream
-     * after receiving a disconnect event
-     * @param reconnect - Boolean indicating if reconnect should automatically occur
-     * @deprecated - 0.58, This API will be removed in 1.0
-     * Use `connect()` and `disconnect()` instead of `setAutoReconnect(true)` and `setAutoReconnect(false)` respectively
-     * See https://github.com/microsoft/FluidFramework/issues/9167 for context
-     */
-    setAutoReconnect(reconnect) {
-        if (this.closed) {
-            throw new Error("Attempting to setAutoReconnect() a closed Container");
-        }
-        const mode = reconnect ? ReconnectMode.Enabled : ReconnectMode.Disabled;
-        this.setAutoReconnectInternal(mode);
-        // If container state is not attached and resumed, then don't connect to delta stream. Also don't set the
-        // manual reconnection flag to true as we haven't made the initial connection yet.
-        if (reconnect && this._attachState === AttachState.Attached && this.resumedOpProcessingAfterLoad) {
-            // Ensure connection to web socket
-            this.connectToDeltaStream({ reason: "autoReconnect" });
-        }
-    }
     setAutoReconnectInternal(mode) {
         const currentMode = this._deltaManager.connectionManager.reconnectMode;
         if (currentMode === mode) {
@@ -671,22 +654,8 @@ export class Container extends EventEmitterWithErrorHandling {
         const mode = ReconnectMode.Disabled;
         this.setAutoReconnectInternal(mode);
     }
-    /**
-     * Have the container attempt to resume processing ops
-     * @deprecated - 0.58, This API will be removed in 1.0
-     * Use `connect()` instead
-     * See https://github.com/microsoft/FluidFramework/issues/9167 for context
-     */
-    resume() {
-        if (!this.closed) {
-            // Note: no need to fetch ops as we do it preemptively as part of DeltaManager.attachOpHandler().
-            // If there is gap, we will learn about it once connected, but the gap should be small (if any),
-            // assuming that resume() is called quickly after initial container boot.
-            this.resumeInternal({ reason: "DocumentOpenResume", fetchOpsFromStorage: false });
-        }
-    }
     resumeInternal(args) {
-        assert(!this.closed, 0x0d9 /* "Attempting to setAutoReconnect() a closed DeltaManager" */);
+        assert(!this.closed, 0x0d9 /* "Attempting to connect() a closed DeltaManager" */);
         // Resume processing ops
         if (!this.resumedOpProcessingAfterLoad) {
             this.resumedOpProcessingAfterLoad = true;
@@ -775,12 +744,26 @@ export class Container extends EventEmitterWithErrorHandling {
         if (loadMode.deltaConnection === undefined) {
             this.connectToDeltaStream(connectionArgs);
         }
-        await this.connectStorageService();
+        if (!pendingLocalState) {
+            await this.connectStorageService();
+        }
+        else {
+            // if we have pendingLocalState we can load without storage; don't wait for connection
+            this.connectStorageService().catch((error) => this.close(error));
+        }
         this._attachState = AttachState.Attached;
         // Fetch specified snapshot.
-        const { snapshot, versionId } = await this.fetchSnapshotTree(specifiedVersion);
-        assert(snapshot !== undefined, 0x237 /* "Snapshot should exist" */);
-        const attributes = await this.getDocumentAttributes(this.storageService, snapshot);
+        const { snapshot, versionId } = pendingLocalState === undefined
+            ? await this.fetchSnapshotTree(specifiedVersion)
+            : { snapshot: undefined, versionId: undefined };
+        assert(snapshot !== undefined || pendingLocalState !== undefined, 0x237 /* "Snapshot should exist" */);
+        const attributes = pendingLocalState === undefined
+            ? await this.getDocumentAttributes(this.storageService, snapshot)
+            : {
+                sequenceNumber: pendingLocalState.protocol.sequenceNumber,
+                minimumSequenceNumber: pendingLocalState.protocol.minimumSequenceNumber,
+                term: pendingLocalState.term,
+            };
         let opsBeforeReturnP;
         // Attach op handlers to finish initialization and be able to start processing ops
         // Kick off any ops fetching if required.
@@ -801,11 +784,12 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         // ...load in the existing quorum
         // Initialize the protocol handler
-        this._protocolHandler =
-            await this.initializeProtocolStateFromSnapshot(attributes, this.storageService, snapshot);
+        this._protocolHandler = pendingLocalState === undefined
+            ? await this.initializeProtocolStateFromSnapshot(attributes, this.storageService, snapshot)
+            : await this.initializeProtocolState(attributes, pendingLocalState.protocol.members, pendingLocalState.protocol.proposals, pendingLocalState.protocol.values);
         const codeDetails = this.getCodeDetailsFromQuorum();
         await this.instantiateContext(true, // existing
-        codeDetails, snapshot, pendingLocalState);
+        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
@@ -822,7 +806,10 @@ export class Container extends EventEmitterWithErrorHandling {
             }
             switch (loadMode.deltaConnection) {
                 case undefined:
-                    this.resume();
+                    // Note: no need to fetch ops as we do it preemptively as part of DeltaManager.attachOpHandler().
+                    // If there is gap, we will learn about it once connected, but the gap should be small (if any),
+                    // assuming that resumeInternal() is called quickly after initial container boot.
+                    this.resumeInternal({ reason: "DocumentLoad", fetchOpsFromStorage: false });
                     break;
                 case "delayed":
                     this.resumedOpProcessingAfterLoad = true;
@@ -945,12 +932,7 @@ export class Container extends EventEmitterWithErrorHandling {
             protocolLogger.sendErrorEvent(error);
         });
         // Track membership changes and update connection state accordingly
-        protocol.quorum.on("addMember", (clientId, details) => {
-            this.connectionStateHandler.receivedAddMemberEvent(clientId);
-        });
-        protocol.quorum.on("removeMember", (clientId) => {
-            this.connectionStateHandler.receivedRemoveMemberEvent(clientId);
-        });
+        this.connectionStateHandler.initProtocol(protocol);
         protocol.quorum.on("addProposal", (proposal) => {
             if (proposal.key === "code" || proposal.key === "code2") {
                 this.emit("codeDetailsProposed", proposal.value, proposal);
@@ -1085,6 +1067,7 @@ export class Container extends EventEmitterWithErrorHandling {
         }, prefetchType);
     }
     logConnectionStateChangeTelemetry(value, oldState, reason) {
+        var _a;
         // Log actual event
         const time = performance.now();
         this.connectionTransitionTimes[value] = time;
@@ -1120,7 +1103,7 @@ export class Container extends EventEmitterWithErrorHandling {
             durationFromDisconnected,
             reason,
             connectionInitiationReason, pendingClientId: this.connectionStateHandler.pendingClientId, clientId: this.clientId, autoReconnect,
-            opsBehind, online: OnlineStatus[isOnline()], lastVisible: this.lastVisible !== undefined ? performance.now() - this.lastVisible : undefined, checkpointSequenceNumber }, this._deltaManager.connectionProps));
+            opsBehind, online: OnlineStatus[isOnline()], lastVisible: this.lastVisible !== undefined ? performance.now() - this.lastVisible : undefined, checkpointSequenceNumber, quorumSize: (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.quorum.getMembers().size }, this._deltaManager.connectionProps));
         if (value === ConnectionState.Connected) {
             this.firstConnection = false;
         }
@@ -1179,6 +1162,7 @@ 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) {
@@ -1211,35 +1195,17 @@ export class Container extends EventEmitterWithErrorHandling {
                 // That means that if relay service changes settings, such changes will impact only newly booted
                 // clients.
                 // All existing will continue to use settings they got earlier.
-                const [noopTimeFrequency, noopCountFrequency] = this.getNoopConfig();
+                assert(this.serviceConfiguration !== undefined, 0x2e4 /* "there should be service config for active connection" */);
                 this.collabWindowTracker = new CollabWindowTracker((type, contents) => {
                     assert(this.activeConnection(), 0x241 /* "disconnect should result in stopSequenceNumberUpdate() call" */);
                     this.submitMessage(type, contents);
-                }, noopTimeFrequency, noopCountFrequency);
+                }, (_a = this.serviceConfiguration) === null || _a === void 0 ? void 0 : _a.noopTimeFrequency, (_b = this.serviceConfiguration) === null || _b === void 0 ? void 0 : _b.noopCountFrequency);
             }
             this.collabWindowTracker.scheduleSequenceNumberUpdate(message, result.immediateNoOp === true);
         }
         this.emit("op", message);
         return result;
     }
-    /**
-     *  #260 (ADO)
-     * back-compat: noopTimeFrequency & noopCountFrequency properties were added to
-     * IClientConfiguration in 0.59.3000. During the integration, we must read the
-     * available configuration from the loader options.
-     */
-    getNoopConfig() {
-        var _a, _b;
-        assert(this.serviceConfiguration !== undefined, 0x2e2);
-        if (this.serviceConfiguration.noopTimeFrequency !== undefined ||
-            this.serviceConfiguration.noopCountFrequency !== undefined) {
-            return [
-                this.serviceConfiguration.noopTimeFrequency,
-                this.serviceConfiguration.noopCountFrequency,
-            ];
-        }
-        return [(_a = this.loader.services.options) === null || _a === void 0 ? void 0 : _a.noopTimeFrequency, (_b = this.loader.services.options) === null || _b === void 0 ? void 0 : _b.noopCountFrequency];
-    }
     submitSignal(message) {
         this._deltaManager.submitSignal(JSON.stringify(message));
     }
@@ -1280,12 +1246,12 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         return { snapshot, versionId: version === null || version === void 0 ? void 0 : version.id };
     }
-    async instantiateContextDetached(existing, snapshot, pendingLocalState) {
+    async instantiateContextDetached(existing, snapshot) {
         const codeDetails = this.getCodeDetailsFromQuorum();
         if (codeDetails === undefined) {
             throw new Error("pkg should be provided in create flow!!");
         }
-        await this.instantiateContext(existing, codeDetails, snapshot, pendingLocalState);
+        await this.instantiateContext(existing, codeDetails, snapshot);
     }
     async instantiateContext(existing, codeDetails, snapshot, pendingLocalState) {
         var _a;