SERVER-74084 Implement zones checks in checkConsistencyMetadata command

Author: PolPinol

jstests/sharding/check_metadata_consistency.js

@@ -241,6 +241,49 @@ function getNewDb() {
     assert.eq(0, inconsistencies.length, tojson(inconsistencies));
 })();
 
+(function testRoutingTableInconsistency() {
+    const db = getNewDb();
+    const kSourceCollName = "coll";
+    const ns = db[kSourceCollName].getFullName();
+
+    st.shardColl(db[kSourceCollName], {skey: 1});
+
+    // Insert a RoutingTableRangeOverlap inconsistency
+    const collUuid = st.config.collections.findOne({_id: ns}).uuid;
+    assert.commandWorked(st.config.chunks.updateOne({uuid: collUuid}, {$set: {max: {skey: 10}}}));
+
+    // Insert a ZonesRangeOverlap inconsistency
+    let entry = {
+        _id: {ns: ns, min: {"skey": -100}},
+        ns: ns,
+        min: {"skey": -100},
+        max: {"skey": 100},
+        tag: "a",
+    };
+    assert.commandWorked(st.config.tags.insert(entry));
+    entry = {
+        _id: {ns: ns, min: {"skey": 50}},
+        ns: ns,
+        min: {"skey": 50},
+        max: {"skey": 150},
+        tag: "a",
+    };
+    assert.commandWorked(st.config.tags.insert(entry));
+
+    // Database level mode command
+    let inconsistencies = db.checkMetadataConsistency().toArray();
+    assert.eq(2, inconsistencies.length, tojson(inconsistencies));
+    assert(inconsistencies.some(object => object.type === "RoutingTableRangeOverlap"),
+           tojson(inconsistencies));
+    assert(inconsistencies.some(object => object.type === "ZonesRangeOverlap"),
+           tojson(inconsistencies));
+
+    // Clean up the database to pass the hooks that detect inconsistencies
+    db.dropDatabase();
+    inconsistencies = mongos.getDB("admin").checkMetadataConsistency().toArray();
+    assert.eq(0, inconsistencies.length, tojson(inconsistencies));
+})();
+
 (function testClusterLevelMode() {
     const db_MisplacedCollection1 = getNewDb();
     const db_MisplacedCollection2 = getNewDb();

src/mongo/db/metadata_consistency_types.idl

@@ -40,6 +40,7 @@ enums:
         values:
             kCollectionUUIDMismatch: "CollectionUUIDMismatch"
             kCorruptedChunkShardKey: "CorruptedChunkShardKey"
+            kCorruptedZoneShardKey: "CorruptedZoneShardKey"
             kHiddenShardedCollection: "HiddenShardedCollection"
             kInconsistentIndex: "InconsistentIndex"
             kMisplacedCollection: "MisplacedCollection"
@@ -49,13 +50,15 @@ enums:
             kRoutingTableMissingMinKey: "RoutingTableMissingMinKey"
             kRoutingTableRangeGap: "RoutingTableRangeGap"
             kRoutingTableRangeOverlap: "RoutingTableRangeOverlap"
+            kZonesRangeOverlap: "ZonesRangeOverlap"
 
     MetadataInconsistencyDescription:
         description: "Description of each metadata inconsistency."
         type: string
         values:
             kCollectionUUIDMismatch: "Found collection on non primary shard with mismatching UUID"
             kCorruptedChunkShardKey: "Found chunk with a shard key pattern violation"
+            kCorruptedZoneShardKey: "Found zone with a shard key pattern violation"
             kHiddenShardedCollection: "Found sharded collection but relative database does not exist"
             kInconsistentIndex: "Found an index of a sharded collection that is inconsistent between different shards"
             kMisplacedCollection: "Unsharded collection found on shard different from database primary shard"
@@ -65,6 +68,7 @@ enums:
             kRoutingTableMissingMinKey: "Routing table has a gap because first chunk does not start from MinKey"
             kRoutingTableRangeGap: "Found a gap between two consecutive chunks"
             kRoutingTableRangeOverlap: "Found two overlapping consecutive chunks"
+            kZonesRangeOverlap: "Found two overlapping zones"
 
     MetadataConsistencyCommandLevel:
         description: "Level mode of the metadata consistency command."
@@ -213,6 +217,24 @@ structs:
                 type: object
                 description: "The shard key pattern of the collection."
 
+    CorruptedZoneShardKeyDetails:
+        description: "Details about a corrupted zone shard key inconsistency."
+        strict: false
+        fields:
+            namespace:
+                cpp_name: nss
+                type: namespacestring
+                description: "The namespace of the collection."
+            collectionUUID:
+                type: uuid
+                description: "The UUID of the collection."
+            zone:
+                type: object
+                description: "The zone with a corrupted shard key."
+            shardKeyPattern:
+                type: object
+                description: "The shard key pattern of the collection."
+
     HiddenShardedCollectionDetails:
         description: "Details about a hidden sharded collection inconsistency."
         strict: false
@@ -249,6 +271,24 @@ structs:
                 type: uuid
                 description: "The UUID of the collection."
 
+    ZonesRangeOverlapDetails:
+        description: "Details about a zones range overlap inconsistency."
+        strict: false
+        fields:
+            namespace:
+                cpp_name: nss
+                type: namespacestring
+                description: "The namespace of the collection."
+            collectionUUID:
+                type: uuid
+                description: "The UUID of the collection."
+            zoneA:
+                type: object
+                description: "The first zone that overlaps with the second zone."
+            zoneB:
+                type: object
+                description: "The second zone that overlaps with the first zone."
+
     MetadataInconsistencyItem:
         description: "Object representing a single metadata inconsistency found in a specific shard"
         strict: false

src/mongo/db/s/config/configsvr_check_metadata_consistency_command.cpp

@@ -137,6 +137,13 @@ class ConfigsvrCheckMetadataConsistencyCommand final
             inconsistenciesMerged.insert(inconsistenciesMerged.end(),
                                          std::make_move_iterator(chunksInconsistencies.begin()),
                                          std::make_move_iterator(chunksInconsistencies.end()));
+
+            auto zonesInconsistencies = metadata_consistency_util::checkZonesInconsistencies(
+                opCtx, coll, _getCollectionZones(opCtx, coll.getNss()));
+
+            inconsistenciesMerged.insert(inconsistenciesMerged.end(),
+                                         std::make_move_iterator(zonesInconsistencies.begin()),
+                                         std::make_move_iterator(zonesInconsistencies.end()));
         }
 
         std::vector<ChunkType> _getCollectionChunks(OperationContext* opCtx,
@@ -154,6 +161,12 @@ class ConfigsvrCheckMetadataConsistencyCommand final
                 repl::ReadConcernLevel::kMajorityReadConcern));
         }
 
+        std::vector<TagsType> _getCollectionZones(OperationContext* opCtx,
+                                                  const NamespaceString& nss) {
+            const auto catalogClient = ShardingCatalogManager::get(opCtx)->localCatalogClient();
+            return uassertStatusOK(catalogClient->getTagsForCollection(opCtx, nss));
+        }
+
         NamespaceString ns() const override {
             return request().getNamespace();
         }

src/mongo/db/s/metadata_consistency_util.cpp

@@ -299,7 +299,6 @@ std::vector<MetadataInconsistencyItem> checkChunksInconsistencies(
     const auto& uuid = collection.getUuid();
     const auto& nss = collection.getNss();
     const auto shardKeyPattern = ShardKeyPattern{collection.getKeyPattern()};
-    const auto configShardId = ShardId::kConfigServerId;
 
     std::vector<MetadataInconsistencyItem> inconsistencies;
     auto previousChunk = chunks.begin();
@@ -361,5 +360,44 @@ std::vector<MetadataInconsistencyItem> checkChunksInconsistencies(
     return inconsistencies;
 }
 
+std::vector<MetadataInconsistencyItem> checkZonesInconsistencies(
+    OperationContext* opCtx, const CollectionType& collection, const std::vector<TagsType>& zones) {
+    const auto& uuid = collection.getUuid();
+    const auto& nss = collection.getNss();
+    const auto shardKeyPattern = ShardKeyPattern{collection.getKeyPattern()};
+
+    std::vector<MetadataInconsistencyItem> inconsistencies;
+    auto previousZone = zones.begin();
+    for (auto it = zones.begin(); it != zones.end(); it++) {
+        const auto& zone = *it;
+
+        // Skip the first iteration as we need to compare the current zone with the previous one.
+        if (it == zones.begin()) {
+            continue;
+        }
+
+        if (!shardKeyPattern.isShardKey(zone.getMinKey()) ||
+            !shardKeyPattern.isShardKey(zone.getMaxKey())) {
+            inconsistencies.emplace_back(makeInconsistency(
+                MetadataInconsistencyTypeEnum::kCorruptedZoneShardKey,
+                CorruptedZoneShardKeyDetails{nss, uuid, zone.toBSON(), shardKeyPattern.toBSON()}));
+        }
+
+        // As the zones are sorted by minKey, we can check if the previous zone maxKey is less than
+        // the current zone minKey.
+        const auto& minKey = zone.getMinKey();
+        auto cmp = previousZone->getMaxKey().woCompare(minKey);
+        if (cmp > 0) {
+            inconsistencies.emplace_back(makeInconsistency(
+                MetadataInconsistencyTypeEnum::kZonesRangeOverlap,
+                ZonesRangeOverlapDetails{nss, uuid, previousZone->toBSON(), zone.toBSON()}));
+        }
+
+        previousZone = it;
+    }
+
+    return inconsistencies;
+}
+
 }  // namespace metadata_consistency_util
 }  // namespace mongo

src/mongo/db/s/metadata_consistency_util.h

@@ -34,6 +34,7 @@
 #include "mongo/db/query/plan_executor_factory.h"
 #include "mongo/s/catalog/type_chunk.h"
 #include "mongo/s/catalog/type_collection.h"
+#include "mongo/s/catalog/type_tags.h"
 #include "mongo/s/request_types/sharded_ddl_commands_gen.h"
 
 
@@ -98,5 +99,14 @@ std::vector<MetadataInconsistencyItem> checkChunksInconsistencies(
     const CollectionType& collection,
     const std::vector<ChunkType>& chunks);
 
+/**
+ * Check different types of inconsistencies from a given set of zones owned by a collection.
+ *
+ * The list of inconsistencies is returned as a vector of MetadataInconsistencies objects. If
+ * there is no inconsistency, it is returned an empty vector.
+ */
+std::vector<MetadataInconsistencyItem> checkZonesInconsistencies(
+    OperationContext* opCtx, const CollectionType& collection, const std::vector<TagsType>& zones);
+
 }  // namespace metadata_consistency_util
 }  // namespace mongo