@fluidframework/container-loader 1.2.7 → 2.0.0-dev.1.3.0.96595

package/lib/container.js

@@ -7,9 +7,8 @@ import merge from "lodash/merge";
 import { v4 as uuid } from "uuid";
 import { assert, performance, unreachableCase } from "@fluidframework/common-utils";
 import { AttachState, isFluidCodeDetails, } from "@fluidframework/container-definitions";
-import { DataCorruptionError, extractSafePropertiesFromMessage, GenericError, UsageError, } from "@fluidframework/container-utils";
-import { readAndParse, OnlineStatus, isOnline, ensureFluidResolvedUrl, combineAppAndProtocolSummary, runWithRetry, isFluidResolvedUrl, isRuntimeMessage, isUnpackedRuntimeMessage, } from "@fluidframework/driver-utils";
-import { ProtocolOpHandlerWithClientValidation, } from "@fluidframework/protocol-base";
+import { GenericError, UsageError, } from "@fluidframework/container-utils";
+import { readAndParse, OnlineStatus, isOnline, ensureFluidResolvedUrl, combineAppAndProtocolSummary, runWithRetry, isFluidResolvedUrl, } from "@fluidframework/driver-utils";
 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";
@@ -19,27 +18,31 @@ import { DeltaManager } from "./deltaManager";
 import { DeltaManagerProxy } from "./deltaManagerProxy";
 import { RelativeLoader } from "./loader";
 import { pkgVersion } from "./packageVersion";
-import { ConnectionStateHandler } from "./connectionStateHandler";
-import { RetriableDocumentStorageService } from "./retriableDocumentStorageService";
-import { ProtocolTreeStorageService } from "./protocolTreeDocumentStorageService";
-import { BlobOnlyStorage, ContainerStorageAdapter } from "./containerStorageAdapter";
+import { ContainerStorageAdapter } from "./containerStorageAdapter";
+import { createConnectionStateHandler, } from "./connectionStateHandler";
 import { getProtocolSnapshotTree, getSnapshotTreeFromSerializedContainer } from "./utils";
 import { initQuorumValuesFromCodeDetails, getCodeDetailsFromQuorumValues, QuorumProxy } from "./quorum";
 import { CollabWindowTracker } from "./collabWindowTracker";
 import { ConnectionManager } from "./connectionManager";
 import { ConnectionState } from "./connectionState";
+import { ProtocolHandler, } from "./protocol";
 const detachedContainerRefSeqNumber = 0;
 const dirtyContainerEvent = "dirty";
 const savedContainerEvent = "saved";
 /**
- * Waits until container connects to delta storage and gets up-to-date
+ * Waits until container connects to delta storage and gets up-to-date.
+ *
  * 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.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.
+ *
+ * @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.
+ *
  * @throws an error beginning with `"Container closed"` if the container is closed before it catches up.
  */
 export async function waitContainerToCatchUp(container) {
@@ -57,6 +60,10 @@ export async function waitContainerToCatchUp(container) {
                 : new 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 = () => {
             assert(container.connectionState === ConnectionState.CatchingUp
                 || container.connectionState === ConnectionState.Connected, 0x0cd /* "Container disconnected while waiting for ops!" */);
@@ -98,9 +105,22 @@ export async function waitContainerToCatchUp(container) {
 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 = PerformanceEvent.start(logger, { eventName });
+    const props = await action();
+    if (event.duration > 1000) {
+        event.end(props);
+    }
+}
 const summarizerClientType = "summarizer";
 export class Container extends EventEmitterWithErrorHandling {
-    constructor(loader, config) {
+    constructor(loader, config, protocolHandlerBuilder) {
         var _a, _b;
         super((name, error) => {
             this.mc.logger.sendErrorEvent({
@@ -109,6 +129,7 @@ export class Container extends 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;
@@ -122,7 +143,6 @@ export class Container extends EventEmitterWithErrorHandling {
         this.attachStarted = false;
         this._dirtyContainer = false;
         this.setAutoReconnectTime = performance.now();
-        this._audience = new Audience();
         this.clientDetailsOverride = config.clientDetailsOverride;
         this._resolvedUrl = config.resolvedUrl;
         if (config.canReconnect !== undefined) {
@@ -142,6 +162,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 containerAttachState: () => this._attachState,
                 containerLifecycleState: () => this._lifecycleState,
                 containerConnectionState: () => 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
@@ -154,6 +175,7 @@ export class Container extends 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; },
@@ -164,9 +186,19 @@ export class Container extends EventEmitterWithErrorHandling {
         this.mc = loggerToMonitoringContext(ChildLogger.create(this.subLogger, "Container"));
         const summarizeProtocolTree = (_a = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree")) !== null && _a !== void 0 ? _a : this.loader.services.options.summarizeProtocolTree;
         this.options = Object.assign(Object.assign({}, this.loader.services.options), { summarizeProtocolTree });
-        this.connectionStateHandler = new ConnectionStateHandler({
-            quorumClients: () => { var _a; return (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.quorum; },
-            logConnectionStateChangeTelemetry: (value, oldState, reason) => this.logConnectionStateChangeTelemetry(value, oldState, reason),
+        this._deltaManager = this.createDeltaManager();
+        this._clientId = (_b = config.serializedContainerState) === null || _b === void 0 ? void 0 : _b.clientId;
+        this.connectionStateHandler = createConnectionStateHandler({
+            logger: this.mc.logger,
+            connectionStateChanged: (value, oldState, reason) => {
+                if (value === ConnectionState.Connected) {
+                    this._clientId = this.connectionStateHandler.pendingClientId;
+                }
+                this.logConnectionStateChangeTelemetry(value, oldState, reason);
+                if (this._lifecycleState === "loaded") {
+                    this.propagateConnectionState(false /* initial transition */);
+                }
+            },
             shouldClientJoinWrite: () => this._deltaManager.connectionManager.shouldJoinWrite(),
             maxClientLeaveWaitTime: this.loader.services.options.maxClientLeaveWaitTime,
             logConnectionIssue: (eventName, details) => {
@@ -174,29 +206,13 @@ export class Container extends EventEmitterWithErrorHandling {
                 // its own join op. Attempt recovery option.
                 this._deltaManager.logConnectionIssue(Object.assign({ eventName, duration: performance.now() - this.connectionTransitionTimes[ConnectionState.CatchingUp] }, (details === undefined ? {} : { details: JSON.stringify(details) })));
             },
-            connectionStateChanged: () => {
-                // Fire events only if container is fully loaded and not closed
-                if (this._lifecycleState === "loaded") {
-                    this.propagateConnectionState();
-                }
-            },
-        }, this.mc.logger, (_b = config.serializedContainerState) === null || _b === void 0 ? void 0 : _b.clientId);
+        }, this.deltaManager, this._clientId);
         this.on(savedContainerEvent, () => {
             this.connectionStateHandler.containerSaved();
         });
-        this._deltaManager = this.createDeltaManager();
-        this._storage = new ContainerStorageAdapter(() => {
-            if (this.attachState !== AttachState.Attached) {
-                if (this.loader.services.detachedBlobStorage !== undefined) {
-                    return new BlobOnlyStorage(this.loader.services.detachedBlobStorage, this.mc.logger);
-                }
-                this.mc.logger.sendErrorEvent({
-                    eventName: "NoRealStorageInDetachedContainer",
-                });
-                throw new Error("Real storage calls not allowed in Unattached container");
-            }
-            return this.storageService;
-        });
+        this.storageService = new ContainerStorageAdapter(this.loader.services.detachedBlobStorage, this.mc.logger, this.options.summarizeProtocolTree === true
+            ? () => this.captureProtocolSummary()
+            : undefined);
         const isDomAvailable = typeof document === "object" &&
             document !== null &&
             typeof document.addEventListener === "function" &&
@@ -253,13 +269,13 @@ export class Container extends 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 PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "Load" }, async (event) => new Promise((resolve, reject) => {
             var _a, _b;
             const version = loadOptions.version;
@@ -293,8 +309,8 @@ export class Container extends 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 PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "CreateDetached" }, async (_event) => {
             await container.createDetached(codeDetails);
             return container;
@@ -304,8 +320,8 @@ export class Container extends 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 PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
             const deserializedSummary = JSON.parse(snapshot);
             await container.rehydrateDetachedFromSnapshot(deserializedSummary);
@@ -317,7 +333,7 @@ export class Container extends EventEmitterWithErrorHandling {
         // Only transition states if currently loading
         if (this._lifecycleState === "loading") {
             // Propagate current connection state through the system.
-            this.propagateConnectionState();
+            this.propagateConnectionState(true /* initial transition */);
             this._lifecycleState = "loaded";
         }
     }
@@ -325,13 +341,7 @@ export class Container extends EventEmitterWithErrorHandling {
         return (this._lifecycleState === "closing" || this._lifecycleState === "closed");
     }
     get storage() {
-        return this._storage;
-    }
-    get storageService() {
-        if (this._storageService === undefined) {
-            throw new Error("Attempted to access storageService before it was defined");
-        }
-        return this._storageService;
+        return this.storageService;
     }
     get context() {
         if (this._context === undefined) {
@@ -372,7 +382,7 @@ export class Container extends EventEmitterWithErrorHandling {
         return this.connectionStateHandler.connectionState;
     }
     get connected() {
-        return this.connectionStateHandler.connected;
+        return this.connectionStateHandler.connectionState === ConnectionState.Connected;
     }
     /**
      * Service configuration details. If running in offline mode will be undefined otherwise will contain service
@@ -386,7 +396,7 @@ export class Container extends EventEmitterWithErrorHandling {
      * Set once this.connected is true, otherwise undefined
      */
     get clientId() {
-        return this.connectionStateHandler.clientId;
+        return this._clientId;
     }
     /**
      * The server provided claims of the client.
@@ -418,12 +428,12 @@ export class Container extends 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;
@@ -448,7 +458,7 @@ export class Container extends EventEmitterWithErrorHandling {
         assert(this._lifecycleState === "closed", 0x314 /* Container properly closed */);
     }
     closeCore(error) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         assert(!this.closed, 0x315 /* re-entrancy */);
         try {
             // Ensure that we raise all key events even if one of these throws
@@ -463,11 +473,11 @@ export class Container extends EventEmitterWithErrorHandling {
                 (_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);
-                (_c = this._storageService) === null || _c === void 0 ? void 0 : _c.dispose();
+                this.storageService.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.
                 // Driver need to ensure all caches are cleared on critical errors
-                (_d = this.service) === null || _d === void 0 ? void 0 : _d.dispose(error);
+                (_c = this.service) === null || _c === void 0 ? void 0 : _c.dispose(error);
             }
             catch (exception) {
                 this.mc.logger.sendErrorEvent({ eventName: "ContainerCloseException" }, exception);
@@ -489,7 +499,7 @@ 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 */);
+        assert(this._protocolHandler.attributes.term !== undefined, 0x37e /* Must have a valid protocol handler instance */);
         const pendingState = {
             pendingRuntimeState: this.context.getPendingLocalState(),
             url: this.resolvedUrl.url,
@@ -497,6 +507,7 @@ export class Container extends EventEmitterWithErrorHandling {
             term: this._protocolHandler.attributes.term,
             clientId: this.clientId,
         };
+        this.mc.logger.sendTelemetryEvent({ eventName: "CloseAndGetPendingLocalState" });
         this.close();
         return JSON.stringify(pendingState);
     }
@@ -553,7 +564,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 const resolvedUrl = this.service.resolvedUrl;
                 ensureFluidResolvedUrl(resolvedUrl);
                 this._resolvedUrl = resolvedUrl;
-                await this.connectStorageService();
+                await this.storageService.connectToService(this.service);
                 if (hasAttachmentBlobs) {
                     // upload blobs to storage
                     assert(!!this.loader.services.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
@@ -583,8 +594,6 @@ export class Container extends EventEmitterWithErrorHandling {
                 }
                 this._attachState = AttachState.Attached;
                 this.emit("attached");
-                // Propagate current connection state through the system.
-                this.propagateConnectionState();
                 if (!this.closed) {
                     this.resumeInternal({ fetchOpsFromStorage: false, reason: "createDetached" });
                 }
@@ -723,9 +732,7 @@ export class Container extends EventEmitterWithErrorHandling {
     /**
      * Load container.
      *
-     * @param specifiedVersion - one of the following
-     *   - undefined - fetch latest snapshot
-     *   - otherwise, version sha to load snapshot
+     * @param specifiedVersion - Version SHA to load snapshot. If not specified, will fetch the latest snapshot.
      */
     async load(specifiedVersion, loadMode, pendingLocalState) {
         if (this._resolvedUrl === undefined) {
@@ -748,11 +755,11 @@ export class Container extends EventEmitterWithErrorHandling {
             this.connectToDeltaStream(connectionArgs);
         }
         if (!pendingLocalState) {
-            await this.connectStorageService();
+            await this.storageService.connectToService(this.service);
         }
         else {
             // if we have pendingLocalState we can load without storage; don't wait for connection
-            this.connectStorageService().catch((error) => this.close(error));
+            this.storageService.connectToService(this.service).catch((error) => this.close(error));
         }
         this._attachState = AttachState.Attached;
         // Fetch specified snapshot.
@@ -787,21 +794,26 @@ export class Container extends 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);
+        if (pendingLocalState === undefined) {
+            await this.initializeProtocolStateFromSnapshot(attributes, this.storageService, snapshot);
+        }
+        else {
+            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();
             }
@@ -827,9 +839,13 @@ export class Container extends 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) {
@@ -841,9 +857,11 @@ export class Container extends EventEmitterWithErrorHandling {
         await this.attachDeltaManagerOpHandler(attributes);
         // Need to just seed the source data in the code quorum. Quorum itself is empty
         const qValues = initQuorumValuesFromCodeDetails(source);
-        this._protocolHandler = await this.initializeProtocolState(attributes, [], // members
-        [], // proposals
-        qValues);
+        this.initializeProtocolState(attributes, {
+            members: [],
+            proposals: [],
+            values: qValues,
+        });
         // The load context - given we seeded the quorum - will be great
         await this.instantiateContextDetached(false);
         this.setLoaded();
@@ -854,38 +872,22 @@ export class Container extends EventEmitterWithErrorHandling {
             delete detachedContainerSnapshot.tree[".hasAttachmentBlobs"];
         }
         const snapshotTree = getSnapshotTreeFromSerializedContainer(detachedContainerSnapshot);
-        this._storage.loadSnapshotForRehydratingContainer(snapshotTree);
-        const attributes = await this.getDocumentAttributes(this._storage, snapshotTree);
+        this.storageService.loadSnapshotForRehydratingContainer(snapshotTree);
+        const attributes = await this.getDocumentAttributes(this.storageService, snapshotTree);
         await this.attachDeltaManagerOpHandler(attributes);
         // Initialize the protocol handler
         const baseTree = getProtocolSnapshotTree(snapshotTree);
-        const qValues = await readAndParse(this._storage, baseTree.blobs.quorumValues);
+        const qValues = await readAndParse(this.storageService, baseTree.blobs.quorumValues);
         const codeDetails = getCodeDetailsFromQuorumValues(qValues);
-        this._protocolHandler =
-            await this.initializeProtocolState(attributes, [], // members
-            [], // proposals
-            codeDetails !== undefined ? initQuorumValuesFromCodeDetails(codeDetails) : []);
+        this.initializeProtocolState(attributes, {
+            members: [],
+            proposals: [],
+            values: codeDetails !== undefined ? initQuorumValuesFromCodeDetails(codeDetails) : [],
+        });
         await this.instantiateContextDetached(true, // existing
         snapshotTree);
         this.setLoaded();
     }
-    async connectStorageService() {
-        var _a, _b;
-        if (this._storageService !== undefined) {
-            return;
-        }
-        assert(this.service !== undefined, 0x1ef /* "services must be defined" */);
-        const storageService = await this.service.connectToStorage();
-        this._storageService =
-            new RetriableDocumentStorageService(storageService, this.mc.logger);
-        if (this.options.summarizeProtocolTree === true) {
-            this.mc.logger.sendTelemetryEvent({ eventName: "summarizeProtocolTreeEnabled" });
-            this._storageService =
-                new ProtocolTreeStorageService(this._storageService, () => this.captureProtocolSummary());
-        }
-        // ensure we did not lose that policy in the process of wrapping
-        assert(((_a = storageService.policies) === null || _a === void 0 ? void 0 : _a.minBlobSize) === ((_b = this.storageService.policies) === null || _b === void 0 ? void 0 : _b.minBlobSize), 0x0e0 /* "lost minBlobSize policy" */);
-    }
     async getDocumentAttributes(storage, tree) {
         if (tree === undefined) {
             return {
@@ -906,22 +908,25 @@ export class Container extends EventEmitterWithErrorHandling {
         return attributes;
     }
     async initializeProtocolStateFromSnapshot(attributes, storage, snapshot) {
-        let members = [];
-        let proposals = [];
-        let values = [];
+        const quorumSnapshot = {
+            members: [],
+            proposals: [],
+            values: [],
+        };
         if (snapshot !== undefined) {
             const baseTree = getProtocolSnapshotTree(snapshot);
-            [members, proposals, values] = await Promise.all([
+            [quorumSnapshot.members, quorumSnapshot.proposals, quorumSnapshot.values] = await Promise.all([
                 readAndParse(storage, baseTree.blobs.quorumMembers),
                 readAndParse(storage, baseTree.blobs.quorumProposals),
                 readAndParse(storage, baseTree.blobs.quorumValues),
             ]);
         }
-        const protocolHandler = await this.initializeProtocolState(attributes, members, proposals, values);
-        return protocolHandler;
+        this.initializeProtocolState(attributes, quorumSnapshot);
     }
-    async initializeProtocolState(attributes, members, proposals, values) {
-        const protocol = new ProtocolOpHandlerWithClientValidation(attributes.minimumSequenceNumber, attributes.sequenceNumber, attributes.term, members, proposals, values, (key, value) => this.submitMessage(MessageType.Propose, { key, value }));
+    initializeProtocolState(attributes, quorumSnapshot) {
+        var _a;
+        const protocolHandlerBuilder = (_a = this.protocolHandlerBuilder) !== null && _a !== void 0 ? _a : ((...args) => new ProtocolHandler(...args, new Audience()));
+        const protocol = protocolHandlerBuilder(attributes, quorumSnapshot, (key, value) => this.submitMessage(MessageType.Propose, JSON.stringify({ key, value })));
         const protocolLogger = ChildLogger.create(this.subLogger, "ProtocolHandler");
         protocol.quorum.on("error", (error) => {
             protocolLogger.sendErrorEvent(error);
@@ -946,7 +951,11 @@ export class Container extends EventEmitterWithErrorHandling {
                 });
             }
         });
-        return protocol;
+        // we need to make sure this member get set in a synchronous context,
+        // or other things can happen after the object that will be set is created, but not yet set
+        // this was breaking this._initialClients handling
+        //
+        this._protocolHandler = protocol;
     }
     captureProtocolSummary() {
         const quorumSnapshot = this.protocolHandler.snapshot();
@@ -1015,13 +1024,7 @@ export class Container extends EventEmitterWithErrorHandling {
         deltaManager.inbound.pause();
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         deltaManager.inboundSignal.pause();
-        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);
-            }
+        deltaManager.on("connect", (details, _opsBehind) => {
             this.connectionStateHandler.receivedConnectEvent(this.connectionMode, details);
         });
         deltaManager.on("disconnect", (reason) => {
@@ -1039,6 +1042,7 @@ export class Container extends EventEmitterWithErrorHandling {
             this.emit("warning", warn);
         });
         deltaManager.on("readonly", (readonly) => {
+            this.setContextConnectedState(this.connectionState === ConnectionState.Connected, readonly);
             this.emit("readonly", readonly);
         });
         deltaManager.on("closed", (error) => {
@@ -1081,12 +1085,7 @@ export class Container extends EventEmitterWithErrorHandling {
                     opsBehind = checkpointSequenceNumber - this.deltaManager.lastSequenceNumber;
                 }
             }
-            if (this.firstConnection) {
-                connectionInitiationReason = "InitialConnect";
-            }
-            else {
-                connectionInitiationReason = "AutoReconnect";
-            }
+            connectionInitiationReason = this.firstConnection ? "InitialConnect" : "AutoReconnect";
         }
         this.mc.logger.sendPerformanceEvent(Object.assign({ eventName: `ConnectionStateChange_${ConnectionState[value]}`, from: ConnectionState[oldState], duration,
             durationFromDisconnected,
@@ -1097,49 +1096,64 @@ export class Container extends EventEmitterWithErrorHandling {
             this.firstConnection = false;
         }
     }
-    propagateConnectionState() {
+    propagateConnectionState(initialTransition) {
         var _a;
+        // When container loaded, we want to propagate initial connection state.
+        // After that, we communicate only transitions to Connected & Disconnected states, skipping all other states.
+        // This can be changed in the future, for example we likely should add "CatchingUp" event on Container.
+        if (!initialTransition &&
+            this.connectionState !== ConnectionState.Connected &&
+            this.connectionState !== ConnectionState.Disconnected) {
+            return;
+        }
+        const state = this.connectionState === ConnectionState.Connected;
         const logOpsOnReconnect = this.connectionState === ConnectionState.Connected &&
             !this.firstConnection &&
             this.connectionMode === "write";
         if (logOpsOnReconnect) {
             this.messageCountAfterDisconnection = 0;
         }
-        const state = this.connectionState === ConnectionState.Connected;
         // 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);
-        }
+        this.setContextConnectedState(state, (_a = this._deltaManager.connectionManager.readOnlyInfo.readonly) !== null && _a !== void 0 ? _a : false);
         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 });
         }
     }
+    // back-compat: ADO #1385: Remove in the future, summary op should come through submitSummaryMessage()
     submitContainerMessage(type, contents, batch, metadata) {
-        const outboundMessageType = type;
-        switch (outboundMessageType) {
+        switch (type) {
             case MessageType.Operation:
-            case MessageType.RemoteHelp:
-                break;
-            case MessageType.Summarize: {
-                // github #6451: this is only needed for staging so the server
-                // know when the protocol tree is included
-                // this can be removed once all clients send
-                // protocol tree by default
-                const summary = contents;
-                if (summary.details === undefined) {
-                    summary.details = {};
-                }
-                summary.details.includesProtocolTree =
-                    this.options.summarizeProtocolTree === true;
-                break;
-            }
+                return this.submitMessage(type, JSON.stringify(contents), batch, metadata);
+            case MessageType.Summarize:
+                return this.submitSummaryMessage(contents);
             default:
                 this.close(new GenericError("invalidContainerSubmitOpType", undefined /* error */, { messageType: type }));
                 return -1;
         }
-        return this.submitMessage(type, contents, batch, metadata);
+    }
+    /** @returns clientSequenceNumber of last message in a batch */
+    submitBatch(batch) {
+        let clientSequenceNumber = -1;
+        for (const message of batch) {
+            clientSequenceNumber = this.submitMessage(MessageType.Operation, message.contents, true, // batch
+            message.metadata);
+        }
+        this._deltaManager.flush();
+        return clientSequenceNumber;
+    }
+    submitSummaryMessage(summary) {
+        // github #6451: this is only needed for staging so the server
+        // know when the protocol tree is included
+        // this can be removed once all clients send
+        // protocol tree by default
+        if (summary.details === undefined) {
+            summary.details = {};
+        }
+        summary.details.includesProtocolTree =
+            this.options.summarizeProtocolTree === true;
+        return this.submitMessage(MessageType.Summarize, JSON.stringify(summary), false /* batch */);
     }
     submitMessage(type, contents, batch, metadata) {
         var _a;
@@ -1154,22 +1168,9 @@ export class Container extends EventEmitterWithErrorHandling {
     processRemoteMessage(message) {
         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))));
-        }
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        if (isUnpackedRuntimeMessage(message) && !isRuntimeMessage(message)) {
-            this.mc.logger.sendTelemetryEvent({ eventName: "UnpackedRuntimeMessage", type: message.type });
-        }
-        // Forward non system messages to the loaded runtime for processing
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        if (isRuntimeMessage(message) || isUnpackedRuntimeMessage(message)) {
-            this.context.process(message, local, undefined);
-        }
+        const result = this.protocolHandler.processMessage(message, local);
+        // Forward messages to the loaded runtime for processing
+        this.context.process(message, local, undefined);
         // 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) {
@@ -1178,15 +1179,14 @@ export class Container extends EventEmitterWithErrorHandling {
                 // clients.
                 // All existing will continue to use settings they got earlier.
                 assert(this.serviceConfiguration !== undefined, 0x2e4 /* "there should be service config for active connection" */);
-                this.collabWindowTracker = new CollabWindowTracker((type, contents) => {
+                this.collabWindowTracker = new CollabWindowTracker((type) => {
                     assert(this.activeConnection(), 0x241 /* "disconnect should result in stopSequenceNumberUpdate() call" */);
-                    this.submitMessage(type, contents);
+                    this.submitMessage(type);
                 }, this.serviceConfiguration.noopTimeFrequency, this.serviceConfiguration.noopCountFrequency);
             }
             this.collabWindowTracker.scheduleSequenceNumberUpdate(message, result.immediateNoOp === true);
         }
         this.emit("op", message);
-        return result;
     }
     submitSignal(message) {
         this._deltaManager.submitSignal(JSON.stringify(message));
@@ -1194,15 +1194,7 @@ export class Container extends EventEmitterWithErrorHandling {
     processSignal(message) {
         // No clientId indicates a system signal message.
         if (message.clientId === null) {
-            const innerContent = message.content;
-            if (innerContent.type === MessageType.ClientJoin) {
-                const newClient = innerContent.content;
-                this._audience.addMember(newClient.clientId, newClient.client);
-            }
-            else if (innerContent.type === MessageType.ClientLeave) {
-                const leftClientId = innerContent.content;
-                this._audience.removeMember(leftClientId);
-            }
+            this.protocolHandler.processSignal(message);
         }
         else {
             const local = this.clientId === message.clientId;
@@ -1241,7 +1233,7 @@ export class Container extends EventEmitterWithErrorHandling {
         // 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, (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._context = await ContainerContext.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new DeltaManagerProxy(this._deltaManager), new QuorumProxy(this.protocolHandler.quorum), loader, (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (summaryOp) => this.submitSummaryMessage(summaryOp), (batch) => this.submitBatch(batch), (message) => this.submitSignal(message), (error) => this.close(error), Container.version, (dirty) => this.updateDirtyContainerState(dirty), existing, pendingLocalState);
         this.emit("contextChanged", codeDetails);
     }
     updateDirtyContainerState(dirty) {
@@ -1254,6 +1246,24 @@ export class Container extends EventEmitterWithErrorHandling {
     logContainerError(warning) {
         this.mc.logger.sendErrorEvent({ eventName: "ContainerWarning" }, warning);
     }
+    /**
+     * Set the connected state of the ContainerContext
+     * This controls the "connected" state of the ContainerRuntime as well
+     * @param state - Is the container currently connected?
+     * @param readonly - Is the container in readonly mode?
+     */
+    setContextConnectedState(state, readonly) {
+        var _a;
+        if (((_a = this._context) === null || _a === void 0 ? void 0 : _a.disposed) === false) {
+            /**
+             * We want to lie to the ContainerRuntime when we are in readonly mode to prevent issues with pending
+             * ops getting through to the DeltaManager.
+             * The ContainerRuntime's "connected" state simply means it is ok to send ops
+             * See https://dev.azure.com/fluidframework/internal/_workitems/edit/1246
+             */
+            this.context.setConnectionState(state && !readonly, this.clientId);
+        }
+    }
 }
 Container.version = "^0.1.0";
 //# sourceMappingURL=container.js.map