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

package/src/container.ts

@@ -7,7 +7,7 @@
 import merge from "lodash/merge";
 import { v4 as uuid } from "uuid";
 import {
-    IDisposable, ITelemetryLogger, ITelemetryProperties,
+    ITelemetryLogger, ITelemetryProperties,
 } from "@fluidframework/common-definitions";
 import { assert, performance, unreachableCase } from "@fluidframework/common-utils";
 import {
@@ -29,10 +29,9 @@ import {
     IContainerLoadMode,
     IFluidCodeDetails,
     isFluidCodeDetails,
+    IBatchMessage,
 } from "@fluidframework/container-definitions";
 import {
-    DataCorruptionError,
-    extractSafePropertiesFromMessage,
     GenericError,
     UsageError,
 } from "@fluidframework/container-utils";
@@ -50,8 +49,6 @@ import {
     combineAppAndProtocolSummary,
     runWithRetry,
     isFluidResolvedUrl,
-    isRuntimeMessage,
-    isUnpackedRuntimeMessage,
 } from "@fluidframework/driver-utils";
 import { IQuorumSnapshot } from "@fluidframework/protocol-base";
 import {
@@ -61,7 +58,6 @@ import {
     ICommittedProposal,
     IDocumentAttributes,
     IDocumentMessage,
-    IProcessMessageResult,
     IProtocolState,
     IQuorumClients,
     IQuorumProposals,
@@ -97,10 +93,11 @@ import { DeltaManager, IConnectionArgs } from "./deltaManager";
 import { DeltaManagerProxy } from "./deltaManagerProxy";
 import { ILoaderOptions, Loader, 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 {
+    IConnectionStateHandler,
+    createConnectionStateHandler,
+} from "./connectionStateHandler";
 import { getProtocolSnapshotTree, getSnapshotTreeFromSerializedContainer } from "./utils";
 import { initQuorumValuesFromCodeDetails, getCodeDetailsFromQuorumValues, QuorumProxy } from "./quorum";
 import { CollabWindowTracker } from "./collabWindowTracker";
@@ -151,14 +148,19 @@ export interface IContainerConfig {
 }
 
 /**
- * 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: IContainer) {
@@ -391,7 +393,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         // 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";
         }
     }
@@ -402,17 +404,9 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
 
     private _attachState = AttachState.Detached;
 
-    private readonly _storage: ContainerStorageAdapter;
+    private readonly storageService: ContainerStorageAdapter;
     public get storage(): IDocumentStorageService {
-        return this._storage;
-    }
-
-    private _storageService: IDocumentStorageService & IDisposable | undefined;
-    private get storageService(): IDocumentStorageService {
-        if (this._storageService === undefined) {
-            throw new Error("Attempted to access storageService before it was defined");
-        }
-        return this._storageService;
+        return this.storageService;
     }
 
     private readonly clientDetailsOverride: IClientDetails | undefined;
@@ -447,7 +441,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
 
     private lastVisible: number | undefined;
     private readonly visibilityEventHandler: (() => void) | undefined;
-    private readonly connectionStateHandler: ConnectionStateHandler;
+    private readonly connectionStateHandler: IConnectionStateHandler;
 
     private setAutoReconnectTime = performance.now();
 
@@ -489,7 +483,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
     }
 
     public get connected(): boolean {
-        return this.connectionStateHandler.connected;
+        return this.connectionStateHandler.connectionState === ConnectionState.Connected;
     }
 
     /**
@@ -500,12 +494,14 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         return this._deltaManager.serviceConfiguration;
     }
 
+    private _clientId: string | undefined;
+
     /**
      * The server provided id of the client.
      * Set once this.connected is true, otherwise undefined
      */
     public get clientId(): string | undefined {
-        return this.connectionStateHandler.clientId;
+        return this._clientId;
     }
 
     /**
@@ -631,11 +627,21 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
             summarizeProtocolTree,
         };
 
-        this.connectionStateHandler = new ConnectionStateHandler(
+        this._deltaManager = this.createDeltaManager();
+
+        this._clientId = config.serializedContainerState?.clientId;
+        this.connectionStateHandler = createConnectionStateHandler(
             {
-                quorumClients: () => this._protocolHandler?.quorum,
-                logConnectionStateChangeTelemetry: (value, oldState, reason) =>
-                    this.logConnectionStateChangeTelemetry(value, oldState, reason),
+                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: string, details?: ITelemetryProperties) => {
@@ -647,35 +653,21 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                         ...(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,
-            config.serializedContainerState?.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" &&
@@ -775,7 +767,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
 
                 this._context?.dispose(error !== undefined ? new Error(error.message) : undefined);
 
-                this._storageService?.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.
@@ -897,7 +889,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                 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
@@ -935,8 +927,6 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                 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" });
                 }
@@ -1112,9 +1102,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
     /**
      * 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.
      */
     private async load(
         specifiedVersion: string | undefined,
@@ -1148,10 +1136,10 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         }
 
         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;
@@ -1192,12 +1180,13 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
 
         // ...load in the existing quorum
         // Initialize the protocol handler
-        this._protocolHandler = pendingLocalState === undefined
-            ? await this.initializeProtocolStateFromSnapshot(
+        if (pendingLocalState === undefined) {
+            await this.initializeProtocolStateFromSnapshot(
                 attributes,
                 this.storageService,
-                snapshot,
-            ) : await this.initializeProtocolState(
+                snapshot);
+        } else {
+            this.initializeProtocolState(
                 attributes,
                 {
                     members: pendingLocalState.protocol.members,
@@ -1205,6 +1194,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                     values: pendingLocalState.protocol.values,
                 }, // pending IQuorumSnapshot
             );
+        }
 
         const codeDetails = this.getCodeDetailsFromQuorum();
         await this.instantiateContext(
@@ -1279,7 +1269,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
 
         // Need to just seed the source data in the code quorum. Quorum itself is empty
         const qValues = initQuorumValuesFromCodeDetails(source);
-        this._protocolHandler = await this.initializeProtocolState(
+        this.initializeProtocolState(
             attributes,
             {
                 members: [],
@@ -1304,27 +1294,26 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         }
 
         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<[string, ICommittedProposal][]>(
-            this._storage,
+            this.storageService,
             baseTree.blobs.quorumValues,
         );
         const codeDetails = getCodeDetailsFromQuorumValues(qValues);
-        this._protocolHandler =
-            await this.initializeProtocolState(
-                attributes,
-                {
-                    members: [],
-                    proposals: [],
-                    values: codeDetails !== undefined ? initQuorumValuesFromCodeDetails(codeDetails) : [],
-                }, // IQuorumSnapShot
-            );
+        this.initializeProtocolState(
+            attributes,
+            {
+                members: [],
+                proposals: [],
+                values: codeDetails !== undefined ? initQuorumValuesFromCodeDetails(codeDetails) : [],
+            }, // IQuorumSnapShot
+        );
 
         await this.instantiateContextDetached(
             true, // existing
@@ -1334,28 +1323,6 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         this.setLoaded();
     }
 
-    private async connectStorageService(): Promise<void> {
-        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(storageService.policies?.minBlobSize === this.storageService.policies?.minBlobSize,
-            0x0e0 /* "lost minBlobSize policy" */);
-    }
-
     private async getDocumentAttributes(
         storage: IDocumentStorageService,
         tree: ISnapshotTree | undefined,
@@ -1387,7 +1354,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         attributes: IDocumentAttributes,
         storage: IDocumentStorageService,
         snapshot: ISnapshotTree | undefined,
-    ): Promise<IProtocolHandler> {
+    ): Promise<void> {
         const quorumSnapshot: IQuorumSnapshot = {
             members: [],
             proposals: [],
@@ -1403,20 +1370,19 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
             ]);
         }
 
-        const protocolHandler = await this.initializeProtocolState(attributes, quorumSnapshot);
-        return protocolHandler;
+        this.initializeProtocolState(attributes, quorumSnapshot);
     }
 
-    private async initializeProtocolState(
+    private initializeProtocolState(
         attributes: IDocumentAttributes,
         quorumSnapshot: IQuorumSnapshot,
-    ): Promise<IProtocolHandler> {
+    ): void {
         const protocolHandlerBuilder =
             this.protocolHandlerBuilder ?? ((...args) => new ProtocolHandler(...args, new Audience()));
         const protocol = protocolHandlerBuilder(
             attributes,
             quorumSnapshot,
-            (key, value) => this.submitMessage(MessageType.Propose, { key, value }),
+            (key, value) => this.submitMessage(MessageType.Propose, JSON.stringify({ key, value })),
             this._initialClients ?? [],
         );
 
@@ -1452,8 +1418,11 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                     });
                 }
             });
-
-        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;
     }
 
     private captureProtocolSummary(): ISummaryTree {
@@ -1557,15 +1526,9 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                 }
             }
 
-            const deltaManagerForCatchingUp =
-                this.mc.config.getBoolean("Fluid.Container.CatchUpBeforeDeclaringConnected") === true ?
-                    this.deltaManager
-                    : undefined;
-
             this.connectionStateHandler.receivedConnectEvent(
                 this.connectionMode,
                 details,
-                deltaManagerForCatchingUp,
             );
         });
 
@@ -1585,6 +1548,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         });
 
         deltaManager.on("readonly", (readonly) => {
+            this.setContextConnectedState(this.connectionState === ConnectionState.Connected, readonly);
             this.emit("readonly", readonly);
         });
 
@@ -1639,11 +1603,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                     opsBehind = checkpointSequenceNumber - this.deltaManager.lastSequenceNumber;
                 }
             }
-            if (this.firstConnection) {
-                connectionInitiationReason = "InitialConnect";
-            } else {
-                connectionInitiationReason = "AutoReconnect";
-            }
+            connectionInitiationReason = this.firstConnection ? "InitialConnect" : "AutoReconnect";
         }
 
         this.mc.logger.sendPerformanceEvent({
@@ -1669,7 +1629,17 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         }
     }
 
-    private propagateConnectionState() {
+    private propagateConnectionState(initialTransition: boolean) {
+        // 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: boolean =
             this.connectionState === ConnectionState.Connected &&
             !this.firstConnection &&
@@ -1678,13 +1648,9 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
             this.messageCountAfterDisconnection = 0;
         }
 
-        const state = this.connectionState === ConnectionState.Connected;
-
         // Both protocol and context should not be undefined if we got so far.
 
-        if (this._context?.disposed === false) {
-            this.context.setConnectionState(state, this.clientId);
-        }
+        this.setContextConnectedState(state, this._deltaManager.connectionManager.readOnlyInfo.readonly ?? false);
         this.protocolHandler.setConnectionState(state, this.clientId);
         raiseConnectedEvent(this.mc.logger, this, state, this.clientId);
 
@@ -1694,35 +1660,53 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         }
     }
 
+    // back-compat: ADO #1385: Remove in the future, summary op should come through submitSummaryMessage()
     private submitContainerMessage(type: MessageType, contents: any, batch?: boolean, metadata?: any): number {
-        const outboundMessageType: string = 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 as ISummaryContent;
-                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 as unknown as ISummaryContent);
             default:
                 this.close(new GenericError("invalidContainerSubmitOpType",
                     undefined /* error */,
                     { messageType: type }));
                 return -1;
         }
-        return this.submitMessage(type, contents, batch, metadata);
     }
 
-    private submitMessage(type: MessageType, contents: any, batch?: boolean, metadata?: any): number {
+    /** @returns clientSequenceNumber of last message in a batch */
+    private submitBatch(batch: IBatchMessage[]): number {
+        let clientSequenceNumber = -1;
+        for (const message of batch) {
+            clientSequenceNumber = this.submitMessage(
+                MessageType.Operation,
+                message.contents,
+                true, // batch
+                message.metadata);
+        }
+        this._deltaManager.flush();
+        return clientSequenceNumber;
+    }
+
+    private submitSummaryMessage(summary: ISummaryContent) {
+        // 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 */);
+    }
+
+    private submitMessage(type: MessageType, contents?: string, batch?: boolean, metadata?: any): number {
         if (this.connectionState !== ConnectionState.Connected) {
             this.mc.logger.sendErrorEvent({ eventName: "SubmitMessageWithNoConnection", type });
             return -1;
@@ -1733,28 +1717,14 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         return this._deltaManager.submit(type, contents, batch, metadata);
     }
 
-    private processRemoteMessage(message: ISequencedDocumentMessage): IProcessMessageResult {
+    private processRemoteMessage(message: ISequencedDocumentMessage) {
         const local = this.clientId === message.clientId;
 
         // Allow the protocol handler to process the message
-        let result: IProcessMessageResult = { immediateNoOp: false };
-        try {
-            result = this.protocolHandler.processMessage(message, local);
-        } catch (error) {
-            this.close(wrapError(error, (errorMessage) =>
-                new DataCorruptionError(errorMessage, extractSafePropertiesFromMessage(message))));
-        }
+        const result = this.protocolHandler.processMessage(message, local);
 
-        // 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);
-        }
+        // 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()) {
@@ -1767,10 +1737,10 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                     this.serviceConfiguration !== undefined,
                     0x2e4 /* "there should be service config for active connection" */);
                 this.collabWindowTracker = new CollabWindowTracker(
-                    (type, contents) => {
+                    (type) => {
                         assert(this.activeConnection(),
                             0x241 /* "disconnect should result in stopSequenceNumberUpdate() call" */);
-                        this.submitMessage(type, contents);
+                        this.submitMessage(type);
                     },
                     this.serviceConfiguration.noopTimeFrequency,
                     this.serviceConfiguration.noopCountFrequency,
@@ -1780,8 +1750,6 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         }
 
         this.emit("op", message);
-
-        return result;
     }
 
     private submitSignal(message: any) {
@@ -1857,6 +1825,8 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
             new QuorumProxy(this.protocolHandler.quorum),
             loader,
             (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata),
+            (summaryOp: ISummaryContent) => this.submitSummaryMessage(summaryOp),
+            (batch: IBatchMessage[]) => this.submitBatch(batch),
             (message) => this.submitSignal(message),
             (error?: ICriticalContainerError) => this.close(error),
             Container.version,
@@ -1879,4 +1849,22 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
     private logContainerError(warning: ContainerWarning) {
         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?
+     */
+    private setContextConnectedState(state: boolean, readonly: boolean): void {
+        if (this._context?.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);
+        }
+    }
 }