@fluidframework/container-runtime 2.0.0-internal.2.1.1 → 2.0.0-internal.2.2.0

package/src/opLifecycle/outbox.ts

@@ -0,0 +1,204 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/common-utils";
+import { IContainerContext } from "@fluidframework/container-definitions";
+import { GenericError } from "@fluidframework/container-utils";
+import { MessageType } from "@fluidframework/protocol-definitions";
+import { ICompressionRuntimeOptions } from "../containerRuntime";
+import { PendingStateManager } from "../pendingStateManager";
+import { BatchManager } from "./batchManager";
+import { BatchMessage, IBatch } from "./definitions";
+import { OpCompressor } from "./opCompressor";
+
+export interface IOutboxConfig {
+    readonly compressionOptions: ICompressionRuntimeOptions;
+    // The maximum size of a batch that we can send over the wire.
+    readonly maxBatchSizeInBytes: number;
+};
+
+export interface IOutboxParameters {
+    readonly shouldSend: () => boolean,
+    readonly pendingStateManager: PendingStateManager,
+    readonly containerContext: IContainerContext,
+    readonly config: IOutboxConfig,
+    readonly compressor: OpCompressor;
+}
+
+export class Outbox {
+    private readonly attachFlowBatch: BatchManager;
+    private readonly mainBatch: BatchManager;
+    private readonly defaultAttachFlowSoftLimitInBytes = 64 * 1024;
+
+    constructor(private readonly params: IOutboxParameters) {
+        const isCompressionEnabled = this.params.config.compressionOptions.minimumBatchSizeInBytes !== Number.POSITIVE_INFINITY;
+        // We need to allow infinite size batches if we enable compression
+        const hardLimit = isCompressionEnabled ? Infinity : this.params.config.maxBatchSizeInBytes;
+        const softLimit = isCompressionEnabled ? Infinity : this.defaultAttachFlowSoftLimitInBytes;
+
+        this.attachFlowBatch = new BatchManager({
+            hardLimit,
+            softLimit,
+        });
+        this.mainBatch = new BatchManager({
+            hardLimit
+        });
+    }
+
+    public get isEmpty(): boolean {
+        return this.attachFlowBatch.length === 0 && this.mainBatch.length === 0;
+    }
+
+    public submit(message: BatchMessage) {
+        if (!this.mainBatch.push(message)) {
+            throw new GenericError(
+                "BatchTooLarge",
+                /* error */ undefined,
+                {
+                    opSize: (message.contents?.length) ?? 0,
+                    count: this.mainBatch.length,
+                    limit: this.mainBatch.options.hardLimit,
+                });
+        }
+    }
+
+    public submitAttach(message: BatchMessage) {
+        if (!this.attachFlowBatch.push(message)) {
+            // BatchManager has two limits - soft limit & hard limit. Soft limit is only engaged
+            // when queue is not empty.
+            // Flush queue & retry. Failure on retry would mean - single message is bigger than hard limit
+            this.flushInternal(this.attachFlowBatch.popBatch());
+            if (!this.attachFlowBatch.push(message)) {
+                throw new GenericError(
+                    "BatchTooLarge",
+                    /* error */ undefined,
+                    {
+                        opSize: (message.contents?.length) ?? 0,
+                        count: this.attachFlowBatch.length,
+                        limit: this.attachFlowBatch.options.hardLimit,
+                    });
+            }
+        }
+
+        // If compression is enabled, we will always successfully receive
+        // attach ops and compress then send them at the next JS turn, regardless
+        // of the overall size of the accumulated ops in the batch.
+        // However, it is more efficient to flush these ops faster, preferably
+        // after they reach a size which would benefit from compression.
+        if (this.attachFlowBatch.contentSizeInBytes >= this.params.config.compressionOptions.minimumBatchSizeInBytes) {
+            this.flushInternal(this.attachFlowBatch.popBatch());
+        }
+    }
+
+    public flush() {
+        this.flushInternal(this.attachFlowBatch.popBatch());
+        this.flushInternal(this.mainBatch.popBatch());
+    }
+
+    private flushInternal(rawBatch: IBatch) {
+        const processedBatch = this.compressBatch(rawBatch);
+        const clientSequenceNumber = this.sendBatch(processedBatch);
+
+        this.persistBatch(clientSequenceNumber, rawBatch.content);
+    }
+
+    private compressBatch(batch: IBatch): IBatch {
+        if (batch.content.length === 0
+            || this.params.config.compressionOptions === undefined
+            || this.params.config.compressionOptions.minimumBatchSizeInBytes > batch.contentSizeInBytes) {
+            // Nothing to do if the batch is empty or if compression is disabled or if we don't need to compress
+            return batch;
+        }
+
+        const compressedBatch = this.params.compressor.compressBatch(batch);
+        if (compressedBatch.contentSizeInBytes > this.params.config.maxBatchSizeInBytes) {
+            throw new GenericError(
+                "BatchTooLarge",
+                    /* error */ undefined,
+                {
+                    opSize: batch.contentSizeInBytes,
+                    count: batch.content.length,
+                    limit: this.params.config.maxBatchSizeInBytes,
+                    compressed: true,
+                });
+        }
+
+        // If we don't reach the maximum supported size of a batch, it safe to be sent as is
+        return compressedBatch;
+    }
+
+    /**
+     * Sends the batch object to the container context to be sent over the wire.
+     *
+     * @param batch - batch to be sent
+     * @returns the client sequence number of the last batched op which was sent and
+     * -1 if there are no ops or the container cannot send ops.
+     */
+    private sendBatch(batch: IBatch): number {
+        let clientSequenceNumber: number = -1;
+        const length = batch.content.length;
+
+        // Did we disconnect in the middle of turn-based batch?
+        // If so, do nothing, as pending state manager will resubmit it correctly on reconnect.
+        if (length === 0 || !this.params.shouldSend()) {
+            return clientSequenceNumber;
+        }
+
+        if (this.params.containerContext.submitBatchFn === undefined) {
+            // Legacy path - supporting old loader versions. Can be removed only when LTS moves above
+            // version that has support for batches (submitBatchFn)
+            for (const message of batch.content) {
+                // Legacy path doesn't support compressed payloads and will submit uncompressed payload anyways
+                if (message.metadata?.compressed) {
+                    delete message.metadata.compressed;
+                }
+
+                clientSequenceNumber = this.params.containerContext.submitFn(
+                    MessageType.Operation,
+                    message.deserializedContent,
+                    true, // batch
+                    message.metadata);
+            }
+
+            this.params.containerContext.deltaManager.flush();
+        } else {
+            // returns clientSequenceNumber of last message in a batch
+            clientSequenceNumber = this.params.containerContext.submitBatchFn(
+                batch.content.map((message) => ({ contents: message.contents, metadata: message.metadata })));
+        }
+
+        // Convert from clientSequenceNumber of last message in the batch to clientSequenceNumber of first message.
+        clientSequenceNumber -= length - 1;
+        assert(clientSequenceNumber >= 0, 0x3d0 /* clientSequenceNumber can't be negative */);
+        return clientSequenceNumber;
+    }
+
+    private persistBatch(initialClientSequenceNumber: number, batch: BatchMessage[]) {
+        let clientSequenceNumber = initialClientSequenceNumber;
+        // Let the PendingStateManager know that a message was submitted.
+        // In future, need to shift toward keeping batch as a whole!
+        for (const message of batch) {
+            this.params.pendingStateManager.onSubmitMessage(
+                message.deserializedContent.type,
+                clientSequenceNumber,
+                message.referenceSequenceNumber,
+                message.deserializedContent.contents,
+                message.localOpMetadata,
+                message.metadata,
+            );
+
+            clientSequenceNumber++;
+        }
+
+        this.params.pendingStateManager.onFlush();
+    }
+
+    public checkpoint() {
+        return {
+            mainBatch: this.mainBatch.checkpoint(),
+            attachFlowBatch: this.attachFlowBatch.checkpoint(),
+        };
+    }
+}

package/src/opLifecycle/remoteMessageProcessor.ts

@@ -0,0 +1,90 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
+import { ContainerMessageType, ContainerRuntimeMessage } from "../containerRuntime";
+import { OpDecompressor } from "./opDecompressor";
+import { OpSplitter } from "./opSplitter";
+
+export class RemoteMessageProcessor {
+    constructor(
+        private readonly opSplitter: OpSplitter,
+        private readonly opDecompressor: OpDecompressor,
+    ) { }
+
+    public get partialMessages(): ReadonlyMap<string, string[]> {
+        return this.opSplitter.chunks;
+    }
+
+    public clearPartialMessagesFor(clientId: string) {
+        this.opSplitter.clearPartialChunks(clientId);
+    }
+
+    public process(remoteMessage: ISequencedDocumentMessage): ISequencedDocumentMessage {
+        let message = copy(remoteMessage);
+
+        message = this.opDecompressor.processMessage(message);
+        unpackRuntimeMessage(message);
+        message = this.opSplitter.processRemoteMessage(message);
+
+        return message;
+    }
+}
+
+const copy = (remoteMessage: ISequencedDocumentMessage): ISequencedDocumentMessage => {
+    // Do shallow copy of message, as the processing flow will modify it.
+    // There might be multiple container instances receiving same message
+    // We do not need to make deep copy, as each layer will just replace message.content itself,
+    // but would not modify contents details
+    const message = { ...remoteMessage };
+
+    // back-compat: ADO #1385: eventually should become unconditional, but only for runtime messages!
+    // System message may have no contents, or in some cases (mostly for back-compat) they may have actual objects.
+    // Old ops may contain empty string (I assume noops).
+    if (typeof message.contents === "string" && message.contents !== "") {
+        message.contents = JSON.parse(message.contents);
+    }
+
+    return message;
+};
+
+/**
+ * For a given message, it moves the nested contents and type on level up.
+ *
+ */
+const unpack = (message: ISequencedDocumentMessage) => {
+    const innerContents = message.contents as ContainerRuntimeMessage;
+    message.type = innerContents.type;
+    message.contents = innerContents.contents;
+};
+
+/**
+ * Unpacks runtime messages.
+ *
+ * @remarks This API makes no promises regarding backward-compatibility. This is internal API.
+ * @param message - message (as it observed in storage / service)
+ * @returns unpacked runtime message
+ *
+ * @internal
+ */
+export function unpackRuntimeMessage(message: ISequencedDocumentMessage): boolean {
+    if (message.type !== MessageType.Operation) {
+        // Legacy format, but it's already "unpacked",
+        // i.e. message.type is actually ContainerMessageType.
+        // Or it's non-runtime message.
+        // Nothing to do in such case.
+        return false;
+    }
+
+    // legacy op format?
+    if (message.contents.address !== undefined && message.contents.type === undefined) {
+        message.type = ContainerMessageType.FluidDataStoreOp;
+    } else {
+        // new format
+        unpack(message);
+    }
+
+    return true;
+}

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.0.0-internal.2.1.1";
+export const pkgVersion = "2.0.0-internal.2.2.0";

package/src/summaryFormat.ts

@@ -8,7 +8,7 @@ import { IDocumentStorageService } from "@fluidframework/driver-definitions";
 import { readAndParse } from "@fluidframework/driver-utils";
 import { ISequencedDocumentMessage, ISnapshotTree, SummaryType } from "@fluidframework/protocol-definitions";
 import { channelsTreeName, ISummaryTreeWithStats } from "@fluidframework/runtime-definitions";
-import { gcTreeKey } from "./garbageCollection";
+import { gcTreeKey } from "./garbageCollectionConstants";
 
 type OmitAttributesVersions<T> = Omit<T, "snapshotFormatVersion" | "summaryFormatVersion">;
 interface IFluidDataStoreAttributes0 {

package/dist/batchManager.d.ts

@@ -1,36 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { IBatchMessage } from "@fluidframework/container-definitions";
-import { ContainerRuntimeMessage } from "./containerRuntime";
-/**
- * Message type used by BatchManager
- */
-export declare type BatchMessage = IBatchMessage & {
-    localOpMetadata: unknown;
-    deserializedContent: ContainerRuntimeMessage;
-    referenceSequenceNumber: number;
-};
-/**
- * Helper class that manages partial batch & rollback.
- */
-export declare class BatchManager {
-    private readonly hardLimit;
-    readonly softLimit?: number | undefined;
-    private pendingBatch;
-    private batchContentSize;
-    get length(): number;
-    get limit(): number;
-    constructor(hardLimit: number, softLimit?: number | undefined);
-    push(message: BatchMessage): boolean;
-    get empty(): boolean;
-    popBatch(): BatchMessage[];
-    /**
-     * Capture the pending state at this point
-     */
-    checkpoint(): {
-        rollback: (process: (message: BatchMessage) => void) => void;
-    };
-}
-//# sourceMappingURL=batchManager.d.ts.map

package/dist/batchManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"batchManager.d.ts","sourceRoot":"","sources":["../src/batchManager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AACtE,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAE7D;;GAEG;AACH,oBAAY,YAAY,GAAG,aAAa,GAAG;IACvC,eAAe,EAAE,OAAO,CAAC;IACzB,mBAAmB,EAAE,uBAAuB,CAAC;IAC7C,uBAAuB,EAAE,MAAM,CAAC;CACnC,CAAC;AAEF;;GAEG;AACH,qBAAa,YAAY;IAQjB,OAAO,CAAC,QAAQ,CAAC,SAAS;aACV,SAAS,CAAC;IAR9B,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,gBAAgB,CAAK;IAE7B,IAAW,MAAM,WAAuC;IACxD,IAAW,KAAK,WAA6B;gBAGxB,SAAS,EAAE,MAAM,EAClB,SAAS,CAAC,oBAAQ;IAG/B,IAAI,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO;IA2B3C,IAAW,KAAK,YAA6C;IAEtD,QAAQ;IAOf;;OAEG;IACI,UAAU;sCAGqB,YAAY,KAAK,IAAI;;CAY9D"}

package/dist/batchManager.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"batchManager.js","sourceRoot":"","sources":["../src/batchManager.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAcH;;GAEG;AACH,MAAa,YAAY;IAOrB,YACqB,SAAiB,EAClB,SAAkB;QADjB,cAAS,GAAT,SAAS,CAAQ;QAClB,cAAS,GAAT,SAAS,CAAS;QAR9B,iBAAY,GAAmB,EAAE,CAAC;QAClC,qBAAgB,GAAG,CAAC,CAAC;IAQzB,CAAC;IANL,IAAW,MAAM,KAAK,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;IACxD,IAAW,KAAK,KAAK,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;IAOtC,IAAI,CAAC,OAAqB;QAC7B,MAAM,WAAW,GAAG,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;QACpE,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC;QAEzC,2DAA2D;QAC3D,iEAAiE;QACjE,sGAAsG;QACtG,iGAAiG;QACjG,gFAAgF;QAChF,MAAM,iBAAiB,GAAG,WAAW,GAAG,GAAG,GAAG,OAAO,CAAC;QAEtD,0DAA0D;QAC1D,wGAAwG;QACxG,0DAA0D;QAC1D,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,iBAAiB,IAAI,IAAI,CAAC,SAAS,EAAE;YACxF,OAAO,KAAK,CAAC;SAChB;QAED,IAAI,iBAAiB,IAAI,IAAI,CAAC,KAAK,EAAE;YACjC,OAAO,KAAK,CAAC;SAChB;QAED,IAAI,CAAC,gBAAgB,GAAG,WAAW,CAAC;QACpC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAChC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,IAAW,KAAK,KAAK,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;IAEtD,QAAQ;QACX,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC;QAChC,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC;QAC1B,OAAO,KAAK,CAAC;IACjB,CAAC;IAED;;OAEG;IACI,UAAU;QACb,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC;QAC5C,OAAO;YACH,QAAQ,EAAE,CAAC,OAAwC,EAAE,EAAE;gBACnD,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,GAAG,UAAU,GAAG;oBACpD,CAAC,EAAE,CAAC;oBACJ,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;oBACrC,IAAI,CAAC,gBAAgB,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;oBACjD,OAAO,CAAC,OAAO,CAAC,CAAC;iBACpB;gBAED,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,UAAU,CAAC;YAC1C,CAAC;SACJ,CAAC;IACN,CAAC;CACJ;AAlED,oCAkEC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { IBatchMessage } from \"@fluidframework/container-definitions\";\nimport { ContainerRuntimeMessage } from \"./containerRuntime\";\n\n/**\n * Message type used by BatchManager\n */\nexport type BatchMessage = IBatchMessage & {\n    localOpMetadata: unknown;\n    deserializedContent: ContainerRuntimeMessage;\n    referenceSequenceNumber: number;\n};\n\n/**\n * Helper class that manages partial batch & rollback.\n */\nexport class BatchManager {\n    private pendingBatch: BatchMessage[] = [];\n    private batchContentSize = 0;\n\n    public get length() { return this.pendingBatch.length; }\n    public get limit() { return this.hardLimit; }\n\n    constructor(\n        private readonly hardLimit: number,\n        public readonly softLimit?: number,\n    ) { }\n\n    public push(message: BatchMessage): boolean {\n        const contentSize = this.batchContentSize + message.contents.length;\n        const opCount = this.pendingBatch.length;\n\n        // Attempt to estimate batch size, aka socket message size.\n        // Each op has pretty large envelope, estimating to be 200 bytes.\n        // Also content will be strigified, and that adds a lot of overhead due to a lot of escape characters.\n        // Not taking it into account, as compression work should help there - compressed payload will be\n        // initially stored as base64, and that requires only 2 extra escape characters.\n        const socketMessageSize = contentSize + 200 * opCount;\n\n        // If we were provided soft limit, check for exceeding it.\n        // But only if we have any ops, as the intention here is to flush existing ops (on exceeding this limit)\n        // and start over. That's not an option if we have no ops.\n        if (this.softLimit !== undefined && this.length > 0 && socketMessageSize >= this.softLimit) {\n            return false;\n        }\n\n        if (socketMessageSize >= this.limit) {\n            return false;\n        }\n\n        this.batchContentSize = contentSize;\n        this.pendingBatch.push(message);\n        return true;\n    }\n\n    public get empty() { return this.pendingBatch.length === 0; }\n\n    public popBatch() {\n        const batch = this.pendingBatch;\n        this.pendingBatch = [];\n        this.batchContentSize = 0;\n        return batch;\n    }\n\n    /**\n     * Capture the pending state at this point\n     */\n    public checkpoint() {\n        const startPoint = this.pendingBatch.length;\n        return {\n            rollback: (process: (message: BatchMessage) => void) => {\n                for (let i = this.pendingBatch.length; i > startPoint;) {\n                    i--;\n                    const message = this.pendingBatch[i];\n                    this.batchContentSize -= message.contents.length;\n                    process(message);\n                }\n\n                this.pendingBatch.length = startPoint;\n            },\n        };\n    }\n}\n"]}

package/lib/batchManager.d.ts

@@ -1,36 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { IBatchMessage } from "@fluidframework/container-definitions";
-import { ContainerRuntimeMessage } from "./containerRuntime";
-/**
- * Message type used by BatchManager
- */
-export declare type BatchMessage = IBatchMessage & {
-    localOpMetadata: unknown;
-    deserializedContent: ContainerRuntimeMessage;
-    referenceSequenceNumber: number;
-};
-/**
- * Helper class that manages partial batch & rollback.
- */
-export declare class BatchManager {
-    private readonly hardLimit;
-    readonly softLimit?: number | undefined;
-    private pendingBatch;
-    private batchContentSize;
-    get length(): number;
-    get limit(): number;
-    constructor(hardLimit: number, softLimit?: number | undefined);
-    push(message: BatchMessage): boolean;
-    get empty(): boolean;
-    popBatch(): BatchMessage[];
-    /**
-     * Capture the pending state at this point
-     */
-    checkpoint(): {
-        rollback: (process: (message: BatchMessage) => void) => void;
-    };
-}
-//# sourceMappingURL=batchManager.d.ts.map

package/lib/batchManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"batchManager.d.ts","sourceRoot":"","sources":["../src/batchManager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AACtE,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAE7D;;GAEG;AACH,oBAAY,YAAY,GAAG,aAAa,GAAG;IACvC,eAAe,EAAE,OAAO,CAAC;IACzB,mBAAmB,EAAE,uBAAuB,CAAC;IAC7C,uBAAuB,EAAE,MAAM,CAAC;CACnC,CAAC;AAEF;;GAEG;AACH,qBAAa,YAAY;IAQjB,OAAO,CAAC,QAAQ,CAAC,SAAS;aACV,SAAS,CAAC;IAR9B,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,gBAAgB,CAAK;IAE7B,IAAW,MAAM,WAAuC;IACxD,IAAW,KAAK,WAA6B;gBAGxB,SAAS,EAAE,MAAM,EAClB,SAAS,CAAC,oBAAQ;IAG/B,IAAI,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO;IA2B3C,IAAW,KAAK,YAA6C;IAEtD,QAAQ;IAOf;;OAEG;IACI,UAAU;sCAGqB,YAAY,KAAK,IAAI;;CAY9D"}

package/lib/batchManager.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"batchManager.js","sourceRoot":"","sources":["../src/batchManager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAcH;;GAEG;AACH,MAAM,OAAO,YAAY;IAOrB,YACqB,SAAiB,EAClB,SAAkB;QADjB,cAAS,GAAT,SAAS,CAAQ;QAClB,cAAS,GAAT,SAAS,CAAS;QAR9B,iBAAY,GAAmB,EAAE,CAAC;QAClC,qBAAgB,GAAG,CAAC,CAAC;IAQzB,CAAC;IANL,IAAW,MAAM,KAAK,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;IACxD,IAAW,KAAK,KAAK,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;IAOtC,IAAI,CAAC,OAAqB;QAC7B,MAAM,WAAW,GAAG,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;QACpE,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC;QAEzC,2DAA2D;QAC3D,iEAAiE;QACjE,sGAAsG;QACtG,iGAAiG;QACjG,gFAAgF;QAChF,MAAM,iBAAiB,GAAG,WAAW,GAAG,GAAG,GAAG,OAAO,CAAC;QAEtD,0DAA0D;QAC1D,wGAAwG;QACxG,0DAA0D;QAC1D,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,iBAAiB,IAAI,IAAI,CAAC,SAAS,EAAE;YACxF,OAAO,KAAK,CAAC;SAChB;QAED,IAAI,iBAAiB,IAAI,IAAI,CAAC,KAAK,EAAE;YACjC,OAAO,KAAK,CAAC;SAChB;QAED,IAAI,CAAC,gBAAgB,GAAG,WAAW,CAAC;QACpC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAChC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,IAAW,KAAK,KAAK,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;IAEtD,QAAQ;QACX,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC;QAChC,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC;QAC1B,OAAO,KAAK,CAAC;IACjB,CAAC;IAED;;OAEG;IACI,UAAU;QACb,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC;QAC5C,OAAO;YACH,QAAQ,EAAE,CAAC,OAAwC,EAAE,EAAE;gBACnD,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,GAAG,UAAU,GAAG;oBACpD,CAAC,EAAE,CAAC;oBACJ,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;oBACrC,IAAI,CAAC,gBAAgB,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;oBACjD,OAAO,CAAC,OAAO,CAAC,CAAC;iBACpB;gBAED,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,UAAU,CAAC;YAC1C,CAAC;SACJ,CAAC;IACN,CAAC;CACJ","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { IBatchMessage } from \"@fluidframework/container-definitions\";\nimport { ContainerRuntimeMessage } from \"./containerRuntime\";\n\n/**\n * Message type used by BatchManager\n */\nexport type BatchMessage = IBatchMessage & {\n    localOpMetadata: unknown;\n    deserializedContent: ContainerRuntimeMessage;\n    referenceSequenceNumber: number;\n};\n\n/**\n * Helper class that manages partial batch & rollback.\n */\nexport class BatchManager {\n    private pendingBatch: BatchMessage[] = [];\n    private batchContentSize = 0;\n\n    public get length() { return this.pendingBatch.length; }\n    public get limit() { return this.hardLimit; }\n\n    constructor(\n        private readonly hardLimit: number,\n        public readonly softLimit?: number,\n    ) { }\n\n    public push(message: BatchMessage): boolean {\n        const contentSize = this.batchContentSize + message.contents.length;\n        const opCount = this.pendingBatch.length;\n\n        // Attempt to estimate batch size, aka socket message size.\n        // Each op has pretty large envelope, estimating to be 200 bytes.\n        // Also content will be strigified, and that adds a lot of overhead due to a lot of escape characters.\n        // Not taking it into account, as compression work should help there - compressed payload will be\n        // initially stored as base64, and that requires only 2 extra escape characters.\n        const socketMessageSize = contentSize + 200 * opCount;\n\n        // If we were provided soft limit, check for exceeding it.\n        // But only if we have any ops, as the intention here is to flush existing ops (on exceeding this limit)\n        // and start over. That's not an option if we have no ops.\n        if (this.softLimit !== undefined && this.length > 0 && socketMessageSize >= this.softLimit) {\n            return false;\n        }\n\n        if (socketMessageSize >= this.limit) {\n            return false;\n        }\n\n        this.batchContentSize = contentSize;\n        this.pendingBatch.push(message);\n        return true;\n    }\n\n    public get empty() { return this.pendingBatch.length === 0; }\n\n    public popBatch() {\n        const batch = this.pendingBatch;\n        this.pendingBatch = [];\n        this.batchContentSize = 0;\n        return batch;\n    }\n\n    /**\n     * Capture the pending state at this point\n     */\n    public checkpoint() {\n        const startPoint = this.pendingBatch.length;\n        return {\n            rollback: (process: (message: BatchMessage) => void) => {\n                for (let i = this.pendingBatch.length; i > startPoint;) {\n                    i--;\n                    const message = this.pendingBatch[i];\n                    this.batchContentSize -= message.contents.length;\n                    process(message);\n                }\n\n                this.pendingBatch.length = startPoint;\n            },\n        };\n    }\n}\n"]}