@fluidframework/container-loader 2.0.0-dev-rc.2.0.0.246488 → 2.0.0-dev-rc.3.0.0.253463

package/dist/deltaManager.js

@@ -5,27 +5,27 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeltaManager = void 0;
-const uuid_1 = require("uuid");
 const client_utils_1 = require("@fluid-internal/client-utils");
-const core_utils_1 = require("@fluidframework/core-utils");
-const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
+const internal_1 = require("@fluidframework/core-utils/internal");
 const driver_definitions_1 = require("@fluidframework/driver-definitions");
+const internal_2 = require("@fluidframework/driver-utils/internal");
 const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
-const driver_utils_1 = require("@fluidframework/driver-utils");
+const internal_3 = require("@fluidframework/telemetry-utils/internal");
+const uuid_1 = require("uuid");
 const deltaQueue_js_1 = require("./deltaQueue.js");
 const error_js_1 = require("./error.js");
 /**
  * Determines if message was sent by client, not service
  */
 function isClientMessage(message) {
-    if ((0, driver_utils_1.isRuntimeMessage)(message)) {
+    if ((0, internal_2.isRuntimeMessage)(message)) {
         return true;
     }
     switch (message.type) {
         case protocol_definitions_1.MessageType.Propose:
         case protocol_definitions_1.MessageType.Reject:
         case protocol_definitions_1.MessageType.NoOp:
-        case driver_utils_1.MessageType2.Accept:
+        case internal_2.MessageType2.Accept:
         case protocol_definitions_1.MessageType.Summarize:
             return true;
         default:
@@ -90,7 +90,7 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
      */
     get hasCheckpointSequenceNumber() {
         // Valid to be called only if we have active connection.
-        (0, core_utils_1.assert)(this.connectionManager.connected, 0x0df /* "Missing active connection" */);
+        (0, internal_1.assert)(this.connectionManager.connected, 0x0df /* "Missing active connection" */);
         return this._checkpointSequenceNumber !== undefined;
     }
     // Forwarding connection manager properties / IDeltaManager implementation
@@ -129,7 +129,7 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
         if (message === undefined) {
             return -1;
         }
-        (0, core_utils_1.assert)(isClientMessage(message), 0x419 /* client sends non-client message */);
+        (0, internal_1.assert)(isClientMessage(message), 0x419 /* client sends non-client message */);
         if (contents !== undefined) {
             this.opsSize += contents.length;
         }
@@ -155,14 +155,14 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
         // The prepareFlush event allows listeners to append metadata to the batch prior to submission.
         this.emit("prepareSend", batch);
         if (batch.length === 1) {
-            (0, core_utils_1.assert)(batch[0].metadata?.batch === undefined, 0x3c9 /* no batch markup on single message */);
+            (0, internal_1.assert)(batch[0].metadata?.batch === undefined, 0x3c9 /* no batch markup on single message */);
         }
         else {
-            (0, core_utils_1.assert)(batch[0].metadata?.batch === true, 0x3ca /* no start batch markup */);
-            (0, core_utils_1.assert)(batch[batch.length - 1].metadata?.batch === false, 0x3cb /* no end batch markup */);
+            (0, internal_1.assert)(batch[0].metadata?.batch === true, 0x3ca /* no start batch markup */);
+            (0, internal_1.assert)(batch[batch.length - 1].metadata?.batch === false, 0x3cb /* no end batch markup */);
         }
         this.connectionManager.sendMessages(batch);
-        (0, core_utils_1.assert)(this.messageBuffer.length === 0, 0x3cc /* reentrancy */);
+        (0, internal_1.assert)(this.messageBuffer.length === 0, 0x3cc /* reentrancy */);
     }
     get connectionProps() {
         return {
@@ -179,7 +179,7 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
      * @param event - Event to log.
      */
     logConnectionIssue(event) {
-        (0, core_utils_1.assert)(this.connectionManager.connected, 0x238 /* "called only in connected state" */);
+        (0, internal_1.assert)(this.connectionManager.connected, 0x238 /* "called only in connected state" */);
         const pendingSorted = this.pending.sort((a, b) => a.sequenceNumber - b.sequenceNumber);
         this.logger.sendTelemetryEvent({
             ...event,
@@ -246,7 +246,7 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
                 }
                 catch (error) {
                     this.logger.sendErrorEvent({ eventName: "EnqueueMessages_Exception" }, error);
-                    this.close((0, telemetry_utils_1.normalizeError)(error));
+                    this.close((0, internal_3.normalizeError)(error));
                 }
             },
             signalHandler: (signals) => {
@@ -260,7 +260,7 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
             connectHandler: (connection) => this.connectHandler(connection),
             pongHandler: (latency) => this.emit("pong", latency),
             readonlyChangeHandler: (readonly, readonlyConnectionReason) => {
-                (0, telemetry_utils_1.safeRaiseEvent)(this, this.logger, "readonly", readonly, readonlyConnectionReason);
+                (0, internal_3.safeRaiseEvent)(this, this.logger, "readonly", readonly, readonlyConnectionReason);
             },
             establishConnectionHandler: (reason) => this.establishingConnection(reason),
             cancelConnectionHandler: (reason) => this.cancelEstablishingConnection(reason),
@@ -270,7 +270,7 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
             this.processInboundMessage(op);
         });
         this._inbound.on("error", (error) => {
-            this.close(telemetry_utils_1.DataProcessingError.wrapIfUnrecognized(error, "deltaManagerInboundErrorHandler", this.lastMessage));
+            this.close(internal_3.DataProcessingError.wrapIfUnrecognized(error, "deltaManagerInboundErrorHandler", this.lastMessage));
         });
         // Inbound signal queue
         this._inboundSignal = new deltaQueue_js_1.DeltaQueue((message) => {
@@ -283,7 +283,7 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
             });
         });
         this._inboundSignal.on("error", (error) => {
-            this.close((0, telemetry_utils_1.normalizeError)(error));
+            this.close((0, internal_3.normalizeError)(error));
         });
         // Initially, all queues are created paused.
         // - outbound is flipped back and forth in setupNewSuccessfulConnection / disconnectFromDeltaStream
@@ -310,7 +310,7 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
         // but it's safe to assume (until better design is put into place) that batches should not exist
         // across multiple connections. Right now we assume runtime will not submit any ops in disconnected
         // state. As requirements change, so should these checks.
-        (0, core_utils_1.assert)(this.messageBuffer.length === 0, 0x0e9 /* "messageBuffer is not empty on new connection" */);
+        (0, internal_1.assert)(this.messageBuffer.length === 0, 0x0e9 /* "messageBuffer is not empty on new connection" */);
         this.opsSize = 0;
         this.noOpCount = 0;
         this.emit("connect", connection, checkpointSequenceNumber !== undefined
@@ -341,16 +341,16 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
         this.lastQueuedSequenceNumber = sequenceNumber;
         this.lastObservedSeqNumber = sequenceNumber;
         // We will use same check in other places to make sure all the seq number above are set properly.
-        (0, core_utils_1.assert)(this.handler === undefined, 0x0e2 /* "DeltaManager already has attached op handler!" */);
+        (0, internal_1.assert)(this.handler === undefined, 0x0e2 /* "DeltaManager already has attached op handler!" */);
         this.handler = handler;
         // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        (0, core_utils_1.assert)(!!this.handler, 0x0e3 /* "Newly set op handler is null/undefined!" */);
+        (0, internal_1.assert)(!!this.handler, 0x0e3 /* "Newly set op handler is null/undefined!" */);
         // There should be no pending fetch!
         // This API is called right after attachOpHandler by Container.load().
         // We might have connection already and it might have called fetchMissingDeltas() from
         // setupNewSuccessfulConnection. But it should do nothing, because there is no way to fetch ops before
         // we know snapshot sequence number that is set in attachOpHandler. So all such calls should be noop.
-        (0, core_utils_1.assert)(this.fetchReason === undefined, 0x268 /* "There can't be pending fetch that early in boot sequence!" */);
+        (0, internal_1.assert)(this.fetchReason === undefined, 0x268 /* "There can't be pending fetch that early in boot sequence!" */);
         if (this._closed) {
             return;
         }
@@ -369,7 +369,7 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
             }
         }
         // Ensure there is no need to call this.processPendingOps() at the end of boot sequence
-        (0, core_utils_1.assert)(this.fetchReason !== undefined || this.pending.length === 0, 0x269 /* "pending ops are not dropped" */);
+        (0, internal_1.assert)(this.fetchReason !== undefined || this.pending.length === 0, 0x269 /* "pending ops are not dropped" */);
     }
     connect(args) {
         const fetchOpsFromStorage = args.fetchOpsFromStorage ?? true;
@@ -432,7 +432,7 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
         const controller = new AbortController();
         let opsFromFetch = false;
         const opListener = (op) => {
-            (0, core_utils_1.assert)(op.sequenceNumber === this.lastQueuedSequenceNumber, 0x23a /* "seq#'s" */);
+            (0, internal_1.assert)(op.sequenceNumber === this.lastQueuedSequenceNumber, 0x23a /* "seq#'s" */);
             // Ops that are coming from this request should not cancel itself.
             // This is useless for known ranges (to is defined) as it means request is over either way.
             // And it will cancel unbound request too early, not allowing us to learn where the end of the file is.
@@ -443,7 +443,7 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
         };
         try {
             this._inbound.on("push", opListener);
-            (0, core_utils_1.assert)(this.closeAbortController.signal.onabort === null, 0x1e8 /* "reentrancy" */);
+            (0, internal_1.assert)(this.closeAbortController.signal.onabort === null, 0x1e8 /* "reentrancy" */);
             this.closeAbortController.signal.onabort = () => controller.abort(this.closeAbortController.signal.reason);
             const stream = this.deltaStorage.fetchMessages(from, // inclusive
             to, // exclusive
@@ -473,7 +473,7 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
             }
             this.closeAbortController.signal.onabort = null;
             this._inbound.off("push", opListener);
-            (0, core_utils_1.assert)(!opsFromFetch, 0x289 /* "logic error" */);
+            (0, internal_1.assert)(!opsFromFetch, 0x289 /* "logic error" */);
         }
     }
     /**
@@ -505,8 +505,8 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
         if (this._disposed) {
             return;
         }
-        if (error !== undefined && !(0, telemetry_utils_1.isFluidError)(error)) {
-            throw new telemetry_utils_1.UsageError("Error must be a Fluid error");
+        if (error !== undefined && !(0, internal_3.isFluidError)(error)) {
+            throw new internal_3.UsageError("Error must be a Fluid error");
         }
         this._disposed = true;
         this._closed = true; // We consider "disposed" as a further state than "closed"
@@ -579,7 +579,7 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
         // It's responsibility of
         // - attachOpHandler()
         // - fetchMissingDeltas() after it's done with querying storage
-        (0, core_utils_1.assert)(this.pending.length === 0 || this.fetchReason !== undefined, 0x1e9 /* "Pending ops" */);
+        (0, internal_1.assert)(this.pending.length === 0 || this.fetchReason !== undefined, 0x1e9 /* "Pending ops" */);
         if (messages.length === 0) {
             return;
         }
@@ -645,7 +645,7 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
         }
         this.updateLatestKnownOpSeqNumber(messages[messages.length - 1].sequenceNumber);
         const n = this.previouslyProcessedMessage?.sequenceNumber;
-        (0, core_utils_1.assert)(n === undefined || n === this.lastQueuedSequenceNumber, 0x0ec /* "Unexpected value for previously processed message's sequence number" */);
+        (0, internal_1.assert)(n === undefined || n === this.lastQueuedSequenceNumber, 0x0ec /* "Unexpected value for previously processed message's sequence number" */);
         for (const message of messages) {
             // Check that the messages are arriving in the expected order
             if (message.sequenceNumber <= this.lastQueuedSequenceNumber) {
@@ -655,7 +655,7 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
                     const message1 = this.comparableMessagePayload(this.previouslyProcessedMessage);
                     const message2 = this.comparableMessagePayload(message);
                     if (message1 !== message2) {
-                        const error = new driver_utils_1.NonRetryableError(
+                        const error = new internal_2.NonRetryableError(
                         // This looks like a data corruption but the culprit was that the file was overwritten
                         // in storage.  See PR #5882.
                         // Likely to be an issue with Fluid Services. Content does not match previous client
@@ -692,18 +692,18 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
     }
     processInboundMessage(message) {
         const startTime = Date.now();
-        (0, core_utils_1.assert)(!this.currentlyProcessingOps, 0x3af /* Already processing ops. */);
+        (0, internal_1.assert)(!this.currentlyProcessingOps, 0x3af /* Already processing ops. */);
         this.currentlyProcessingOps = true;
         this.lastProcessedMessage = message;
         const isString = typeof message.clientId === "string";
-        (0, core_utils_1.assert)(message.clientId === null || isString, 0x41a /* undefined or string */);
+        (0, internal_1.assert)(message.clientId === null || isString, 0x41a /* undefined or string */);
         // All client messages are coming from some client, and should have clientId,
         // and non-client message should not have clientId. But, there are two exceptions:
         // 1. (Legacy) We can see message.type === "attach" or "chunkedOp" for legacy files before RTM
         // 2. Non-immediate noops (contents: null) can be sent by service without clientId
         if (!isString && isClientMessage(message) && message.type !== protocol_definitions_1.MessageType.NoOp) {
-            throw new telemetry_utils_1.DataCorruptionError("Mismatch in clientId", {
-                ...(0, telemetry_utils_1.extractSafePropertiesFromMessage)(message),
+            throw new internal_3.DataCorruptionError("Mismatch in clientId", {
+                ...(0, internal_3.extractSafePropertiesFromMessage)(message),
                 messageType: message.type,
             });
         }
@@ -731,8 +731,8 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
         // Watch the minimum sequence number and be ready to update as needed
         if (this.minSequenceNumber > message.minimumSequenceNumber) {
             // pre-0.58 error message: msnMovesBackwards
-            throw new telemetry_utils_1.DataCorruptionError("Found a lower minimumSequenceNumber (msn) than previously recorded", {
-                ...(0, telemetry_utils_1.extractSafePropertiesFromMessage)(message),
+            throw new internal_3.DataCorruptionError("Found a lower minimumSequenceNumber (msn) than previously recorded", {
+                ...(0, internal_3.extractSafePropertiesFromMessage)(message),
                 clientId: this.connectionManager.clientId,
             });
         }
@@ -741,19 +741,19 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
         // System ops (when no clients are connected) are the only ops where equation is possible.
         const diff = message.sequenceNumber - message.minimumSequenceNumber;
         if (diff < 0 || (diff === 0 && message.clientId !== null)) {
-            throw new telemetry_utils_1.DataCorruptionError("MSN has to be lower than sequence #", (0, telemetry_utils_1.extractSafePropertiesFromMessage)(message));
+            throw new internal_3.DataCorruptionError("MSN has to be lower than sequence #", (0, internal_3.extractSafePropertiesFromMessage)(message));
         }
         this.minSequenceNumber = message.minimumSequenceNumber;
         if (message.sequenceNumber !== this.lastProcessedSequenceNumber + 1) {
             // pre-0.58 error message: nonSequentialSequenceNumber
-            throw new telemetry_utils_1.DataCorruptionError("Found a non-Sequential sequenceNumber", {
-                ...(0, telemetry_utils_1.extractSafePropertiesFromMessage)(message),
+            throw new internal_3.DataCorruptionError("Found a non-Sequential sequenceNumber", {
+                ...(0, internal_3.extractSafePropertiesFromMessage)(message),
                 clientId: this.connectionManager.clientId,
             });
         }
         this.lastProcessedSequenceNumber = message.sequenceNumber;
         // a bunch of code assumes that this is true
-        (0, core_utils_1.assert)(this.lastProcessedSequenceNumber <= this.lastObservedSeqNumber, 0x267 /* "lastObservedSeqNumber should be updated first" */);
+        (0, internal_1.assert)(this.lastProcessedSequenceNumber <= this.lastObservedSeqNumber, 0x267 /* "lastObservedSeqNumber should be updated first" */);
         if (this.handler === undefined) {
             throw new Error("Attempted to process an inbound message without a handler attached");
         }
@@ -789,7 +789,7 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
         }
         if (this.handler === undefined) {
             // We do not poses yet any information
-            (0, core_utils_1.assert)(this.lastQueuedSequenceNumber === 0, 0x26b /* "initial state" */);
+            (0, internal_1.assert)(this.lastQueuedSequenceNumber === 0, 0x26b /* "initial state" */);
             return;
         }
         try {
@@ -801,8 +801,8 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
                 // Knowing about this mechanism, we could ask for op we already observed to increase validation.
                 // This is especially useful when coming out of offline mode or loading from
                 // very old cached (by client / driver) snapshot.
-                (0, core_utils_1.assert)(n === this.lastQueuedSequenceNumber, 0x0f2 /* "previouslyProcessedMessage" */);
-                (0, core_utils_1.assert)(from > 1, 0x0f3 /* "not positive" */);
+                (0, internal_1.assert)(n === this.lastQueuedSequenceNumber, 0x0f2 /* "previouslyProcessedMessage" */);
+                (0, internal_1.assert)(from > 1, 0x0f3 /* "not positive" */);
                 from--;
             }
             const fetchReason = `${reason}_fetch`;
@@ -814,7 +814,7 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
         }
         catch (error) {
             this.logger.sendErrorEvent({ eventName: "GetDeltas_Exception" }, error);
-            this.close((0, telemetry_utils_1.normalizeError)(error));
+            this.close((0, internal_3.normalizeError)(error));
         }
         finally {
             this.refreshDelayInfo(this.deltaStorageDelayId);
@@ -829,7 +829,7 @@ class DeltaManager extends client_utils_1.TypedEventEmitter {
         if (this._closed) {
             return;
         }
-        (0, core_utils_1.assert)(this.handler !== undefined, 0x26c /* "handler should be installed" */);
+        (0, internal_1.assert)(this.handler !== undefined, 0x26c /* "handler should be installed" */);
         const pendingSorted = this.pending.sort((a, b) => a.sequenceNumber - b.sequenceNumber);
         this.pending = [];
         // Given that we do not track where these ops came from any more, it's not very