@fluidframework/container-loader 0.56.0 → 0.57.0-51086

package/lib/container.js

@@ -11,7 +11,7 @@ import { AttachState, } 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 { FileMode, MessageType, SummaryType, TreeEntry, } from "@fluidframework/protocol-definitions";
+import { MessageType, SummaryType, } from "@fluidframework/protocol-definitions";
 import { ChildLogger, EventEmitterWithErrorHandling, PerformanceEvent, raiseConnectedEvent, TelemetryLogger, connectedEventName, disconnectedEventName, normalizeError, loggerToMonitoringContext, } from "@fluidframework/telemetry-utils";
 import { Audience } from "./audience";
 import { ContainerContext } from "./containerContext";
@@ -215,7 +215,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 }
                 else {
                     // settimeout so this will hopefully fire after disconnect event if being hidden caused it
-                    setTimeout(() => this.lastVisible = undefined, 0);
+                    setTimeout(() => { this.lastVisible = undefined; }, 0);
                 }
             };
             document.addEventListener("visibilitychange", this.visibilityEventHandler);
@@ -594,25 +594,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" });
     }
-    async snapshot(tagMessage, fullTree = false) {
-        // Only snapshot once a code quorum has been established
-        if (!this.protocolHandler.quorum.has("code") && !this.protocolHandler.quorum.has("code2")) {
-            this.mc.logger.sendTelemetryEvent({ eventName: "SkipSnapshot" });
-            return;
-        }
-        // Stop inbound message processing while we complete the snapshot
-        try {
-            await this.deltaManager.inbound.pause();
-            await this.snapshotCore(tagMessage, fullTree);
-        }
-        catch (ex) {
-            this.mc.logger.sendErrorEvent({ eventName: "SnapshotExceptionError" }, ex);
-            throw ex;
-        }
-        finally {
-            this.deltaManager.inbound.resume();
-        }
-    }
     setAutoReconnect(reconnect) {
         if (this.closed) {
             throw new Error("Attempting to setAutoReconnect() a closed Container");
@@ -710,74 +691,6 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         this.close(new GenericError("existingContextDoesNotSatisfyIncomingProposal"));
     }
-    async snapshotCore(tagMessage, fullTree = false) {
-        // Snapshots base document state and currently running context
-        const root = this.snapshotBase();
-        const dataStoreEntries = await this.context.snapshot(tagMessage, fullTree);
-        // And then combine
-        if (dataStoreEntries !== null) {
-            root.entries.push(...dataStoreEntries.entries);
-        }
-        // Generate base snapshot message
-        const deltaDetails = `${this._deltaManager.lastSequenceNumber}:${this._deltaManager.minimumSequenceNumber}`;
-        const message = `Commit @${deltaDetails} ${tagMessage}`;
-        // Pull in the prior version and snapshot tree to store against
-        const lastVersion = await this.getVersion(null);
-        const parents = lastVersion !== undefined ? [lastVersion.id] : [];
-        // Write the full snapshot
-        return this.storageService.write(root, parents, message, "");
-    }
-    snapshotBase() {
-        const entries = [];
-        const quorumSnapshot = this.protocolHandler.quorum.snapshot();
-        entries.push({
-            mode: FileMode.File,
-            path: "quorumMembers",
-            type: TreeEntry.Blob,
-            value: {
-                contents: JSON.stringify(quorumSnapshot.members),
-                encoding: "utf-8",
-            },
-        });
-        entries.push({
-            mode: FileMode.File,
-            path: "quorumProposals",
-            type: TreeEntry.Blob,
-            value: {
-                contents: JSON.stringify(quorumSnapshot.proposals),
-                encoding: "utf-8",
-            },
-        });
-        entries.push({
-            mode: FileMode.File,
-            path: "quorumValues",
-            type: TreeEntry.Blob,
-            value: {
-                contents: JSON.stringify(quorumSnapshot.values),
-                encoding: "utf-8",
-            },
-        });
-        // Save attributes for the document
-        const documentAttributes = {
-            minimumSequenceNumber: this._deltaManager.minimumSequenceNumber,
-            sequenceNumber: this._deltaManager.lastSequenceNumber,
-            term: this._deltaManager.referenceTerm,
-        };
-        entries.push({
-            mode: FileMode.File,
-            path: ".attributes",
-            type: TreeEntry.Blob,
-            value: {
-                contents: JSON.stringify(documentAttributes),
-                encoding: "utf-8",
-            },
-        });
-        // Output the tree
-        const root = {
-            entries,
-        };
-        return root;
-    }
     async getVersion(version) {
         const versions = await this.storageService.getVersions(version, 1);
         return versions[0];
@@ -991,7 +904,9 @@ 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 }), (sequenceNumber) => this.submitMessage(MessageType.Reject, sequenceNumber));
+        const protocol = new ProtocolOpHandler(attributes.minimumSequenceNumber, attributes.sequenceNumber, attributes.term, members, proposals, values, (key, value) => this.submitMessage(MessageType.Propose, { key, value }), 
+        // Quorum proposal rejection removed, delete when protocol-base 0.1035 is integrated.
+        () => { });
         const protocolLogger = ChildLogger.create(this.subLogger, "ProtocolHandler");
         protocol.quorum.on("error", (error) => {
             protocolLogger.sendErrorEvent(error);
@@ -1305,19 +1220,19 @@ export class Container extends EventEmitterWithErrorHandling {
     async instantiateContext(existing, codeDetails, snapshot, pendingLocalState) {
         var _a;
         assert(((_a = this._context) === null || _a === void 0 ? void 0 : _a.disposed) !== false, 0x0dd /* "Existing context not disposed" */);
-        // If this assert fires, our state tracking is likely not synchronized between COntainer & runtime.
-        if (this._dirtyContainer) {
-            this.mc.logger.sendErrorEvent({ eventName: "DirtyContainerReloadContainer" });
-        }
         // The relative loader will proxy requests to '/' to the loader itself assuming no non-cache flags
         // are set. Global requests will still go directly to the loader
         const loader = new RelativeLoader(this, this.loader);
-        this._context = await ContainerContext.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new DeltaManagerProxy(this._deltaManager), new QuorumProxy(this.protocolHandler.quorum), loader, (warning) => this.raiseContainerWarning(warning), (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (message) => this.submitSignal(message), (error) => this.close(error), Container.version, (dirty) => {
-            this._dirtyContainer = dirty;
-            this.emit(dirty ? dirtyContainerEvent : savedContainerEvent);
-        }, existing, pendingLocalState);
+        this._context = await ContainerContext.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new DeltaManagerProxy(this._deltaManager), new QuorumProxy(this.protocolHandler.quorum), loader, (warning) => this.raiseContainerWarning(warning), (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (message) => this.submitSignal(message), (error) => this.close(error), Container.version, (dirty) => this.updateDirtyContainerState(dirty), existing, pendingLocalState);
         this.emit("contextChanged", codeDetails);
     }
+    updateDirtyContainerState(dirty) {
+        if (this._dirtyContainer === dirty) {
+            return;
+        }
+        this._dirtyContainer = dirty;
+        this.emit(dirty ? dirtyContainerEvent : savedContainerEvent);
+    }
     logContainerError(warning) {
         this.mc.logger.sendErrorEvent({ eventName: "ContainerWarning" }, warning);
     }