@fluidframework/map 2.0.0-internal.8.0.3 → 2.0.0-internal.8.0.5

package/dist/directory.cjs

@@ -186,6 +186,9 @@ class DirectoryCreationTracker {
         }, keys);
         return keys;
     }
+    get size() {
+        return this.keyToIndex.size;
+    }
 }
 /**
  * {@inheritDoc ISharedDirectory}
@@ -242,7 +245,7 @@ class SharedDirectory extends shared_object_base_1.SharedObject {
         /**
          * Root of the SharedDirectory, most operations on the SharedDirectory itself act on the root.
          */
-        this.root = new SubDirectory({ seq: 0, clientSeq: 0 }, new Set(), this, this.runtime, this.serializer, posix.sep);
+        this.root = new SubDirectory({ seq: 0, clientSeq: 0 }, new Set(), this, this.runtime, this.serializer, posix.sep, this.logger);
         /**
          * Mapping of op types to message handlers.
          */
@@ -476,10 +479,7 @@ class SharedDirectory extends shared_object_base_1.SharedObject {
                         // guaranteed during the serialization process. As a result, it is only essential to utilize the
                         // "fake" client sequence number to signify the loading order, and there is no need to retain
                         // the actual client sequence number at this point.
-                        if (createInfo !== undefined && createInfo.csn > -1) {
-                            // If csn is -1, then initialize it with 0, otherwise we will never process ops for this
-                            // sub directory. This could be done at serialization time too, but we need to maintain
-                            // back compat too and also we will actually know the state when it was serialized.
+                        if (createInfo !== undefined && createInfo.csn > 0) {
                             if (!tempSeqNums.has(createInfo.csn)) {
                                 tempSeqNums.set(createInfo.csn, 0);
                             }
@@ -488,6 +488,13 @@ class SharedDirectory extends shared_object_base_1.SharedObject {
                             tempSeqNums.set(createInfo.csn, ++fakeClientSeq);
                         }
                         else {
+                            /**
+                             * 1. If csn is -1, then initialize it with 0, otherwise we will never process ops for this
+                             * sub directory. This could be done at serialization time too, but we need to maintain
+                             * back compat too and also we will actually know the state when it was serialized.
+                             * 2. We need to make the csn = -1 and csn = 0 share the same counter, there are cases
+                             * where both -1 and 0 coexist within a single document.
+                             */
                             seqData = {
                                 seq: 0,
                                 clientSeq: ++currentSubDir.localCreationSeq,
@@ -495,7 +502,7 @@ class SharedDirectory extends shared_object_base_1.SharedObject {
                         }
                         newSubDir = new SubDirectory(seqData, createInfo !== undefined
                             ? new Set(createInfo.ccIds)
-                            : new Set(), this, this.runtime, this.serializer, posix.join(currentSubDir.absolutePath, subdirName));
+                            : new Set(), this, this.runtime, this.serializer, posix.join(currentSubDir.absolutePath, subdirName), this.logger);
                         currentSubDir.populateSubDirectory(subdirName, newSubDir);
                         // Record the newly inserted subdirectory to the creation tracker
                         currentSubDir.ackedCreationSeqTracker.set(subdirName, {
@@ -797,6 +804,7 @@ function isDirectoryLocalOpMetadata(metadata) {
 function assertNonNullClientId(clientId) {
     (0, core_utils_1.assert)(clientId !== null, 0x6af /* client id should never be null */);
 }
+let hasLoggedDirectoryInconsistency = false;
 /**
  * Node of the directory tree.
  * @sealed
@@ -811,7 +819,7 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
      * @param serializer - The serializer to serialize / parse handles
      * @param absolutePath - The absolute path of this IDirectory
      */
-    constructor(seqData, clientIds, directory, runtime, serializer, absolutePath) {
+    constructor(seqData, clientIds, directory, runtime, serializer, absolutePath, logger) {
         super();
         this.seqData = seqData;
         this.clientIds = clientIds;
@@ -819,6 +827,7 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
         this.runtime = runtime;
         this.serializer = serializer;
         this.absolutePath = absolutePath;
+        this.logger = logger;
         /**
          * Tells if the sub directory is deleted or not.
          */
@@ -1027,7 +1036,23 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
         const ackedSubdirsInOrder = this.ackedCreationSeqTracker.keys();
         const localSubdirsInOrder = this.localCreationSeqTracker.keys((key) => !this.ackedCreationSeqTracker.has(key));
         const subdirNames = [...ackedSubdirsInOrder, ...localSubdirsInOrder];
-        (0, core_utils_1.assert)(subdirNames.length === this._subdirectories.size, 0x85c /* The count of keys for iteration should be consistent with the size of actual data */);
+        if (subdirNames.length !== this._subdirectories.size) {
+            // TODO: AB#7022: Hitting this block indicates that the eventual consistency scheme for ordering subdirectories
+            // has failed. Fall back to previous directory behavior, which didn't guarantee ordering.
+            // It's not currently clear how to reach this state, so log some diagnostics to help understand the issue.
+            // This whole block should eventually be replaced by an assert that the two sizes align.
+            if (!hasLoggedDirectoryInconsistency) {
+                this.logger.sendTelemetryEvent({
+                    eventName: "inconsistentSubdirectoryOrdering",
+                    localKeyCount: this.localCreationSeqTracker.size,
+                    ackedKeyCount: this.ackedCreationSeqTracker.size,
+                    subdirNamesLength: subdirNames.length,
+                    subdirectoriesSize: this._subdirectories.size,
+                });
+                hasLoggedDirectoryInconsistency = true;
+            }
+            return this._subdirectories.entries();
+        }
         const entriesIterator = {
             index: 0,
             dirs: this._subdirectories,
@@ -1872,7 +1897,7 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
         const subdir = this._subdirectories.get(subdirName);
         if (subdir === undefined) {
             const absolutePath = posix.join(this.absolutePath, subdirName);
-            const subDir = new SubDirectory({ ...seqData }, new Set([clientId]), this.directory, this.runtime, this.serializer, absolutePath);
+            const subDir = new SubDirectory({ ...seqData }, new Set([clientId]), this.directory, this.runtime, this.serializer, absolutePath, this.logger);
             /**
              * Store the sequnce numbers of newly created subdirectory to the proper creation tracker, based
              * on whether the creation behavior has been ack'd or not