SERVER-29405 delay deleting orphaned shard chunks

When deleting the donor range after migrating a chunk off of a shard,
the range deleter will schedule the deletion at some time in the future,
according to a server parameter orphanCleanupDelaySecs, which defaults
to 900, or 15 minutes.  It does not delay range deletions preparatory to
migrating a range in, and does not put off deleting the donor range if
the moveChunk command has set the option _waitForDelete.

The file jstests/sharding/write_commands_sharding_state.js had CR (0x0D)
line endings, which made the patch fail lint.  The substantive changes
in the file were to add "_waitForDelete" options to the moveChunk
commands.

1 files changed, 74 insertions, 92 deletions

diff --git a/src/mongo/db/s/metadata_manager_test.cpp b/src/mongo/db/s/metadata_manager_test.cpp
index a17eed1c6b4..698d8a05ba7 100644
--- a/src/mongo/db/s/metadata_manager_test.cpp
+++ b/src/mongo/db/s/metadata_manager_test.cpp
@@ -85,6 +85,8 @@ protected:
             .transitional_ignore();
 
         configTargeter()->setFindHostReturnValue(dummyHost);
+
+        _manager = std::make_shared<MetadataManager>(getServiceContext(), kNss, executor());
     }
 
     std::unique_ptr<DistLockCatalog> makeDistLockCatalog(ShardRegistry* shardRegistry) override {
@@ -150,27 +152,25 @@ protected:
         manager->refreshActiveMetadata(std::move(cm2));
         return cm2Ptr;
     }
+
+    std::shared_ptr<MetadataManager> _manager;
 };
 
 TEST_F(MetadataManagerTest, SetAndGetActiveMetadata) {
-    std::shared_ptr<MetadataManager> manager =
-        std::make_shared<MetadataManager>(getServiceContext(), kNss, executor());
     std::unique_ptr<CollectionMetadata> cm = makeEmptyMetadata();
     auto cmPtr = cm.get();
 
-    manager->refreshActiveMetadata(std::move(cm));
-    ScopedCollectionMetadata scopedMetadata = manager->getActiveMetadata(manager);
+    _manager->refreshActiveMetadata(std::move(cm));
+    ScopedCollectionMetadata scopedMetadata = _manager->getActiveMetadata(_manager);
 
     ASSERT_EQ(cmPtr, scopedMetadata.getMetadata());
 };
 
 
 TEST_F(MetadataManagerTest, ResetActiveMetadata) {
-    std::shared_ptr<MetadataManager> manager =
-        std::make_shared<MetadataManager>(getServiceContext(), kNss, executor());
-    manager->refreshActiveMetadata(makeEmptyMetadata());
-    auto cm2Ptr = addChunk(manager);
-    ScopedCollectionMetadata scopedMetadata2 = manager->getActiveMetadata(manager);
+    _manager->refreshActiveMetadata(makeEmptyMetadata());
+    auto cm2Ptr = addChunk(_manager);
+    ScopedCollectionMetadata scopedMetadata2 = _manager->getActiveMetadata(_manager);
     ASSERT_EQ(cm2Ptr, scopedMetadata2.getMetadata());
 };
 
@@ -179,32 +179,28 @@ TEST_F(MetadataManagerTest, ResetActiveMetadata) {
 // doing anything.
 
 TEST_F(MetadataManagerTest, CleanUpForMigrateIn) {
-    std::shared_ptr<MetadataManager> manager =
-        std::make_shared<MetadataManager>(getServiceContext(), kNss, executor());
-    manager->refreshActiveMetadata(makeEmptyMetadata());
+    _manager->refreshActiveMetadata(makeEmptyMetadata());
 
     ChunkRange range1(BSON("key" << 0), BSON("key" << 10));
     ChunkRange range2(BSON("key" << 10), BSON("key" << 20));
-    auto notif1 = manager->beginReceive(range1);
+    auto notif1 = _manager->beginReceive(range1);
     ASSERT_TRUE(!notif1.ready());
-    auto notif2 = manager->beginReceive(range2);
+    auto notif2 = _manager->beginReceive(range2);
     ASSERT_TRUE(!notif2.ready());
-    ASSERT_EQ(manager->numberOfRangesToClean(), 2UL);
-    ASSERT_EQ(manager->numberOfRangesToCleanStillInUse(), 0UL);
+    ASSERT_EQ(_manager->numberOfRangesToClean(), 2UL);
+    ASSERT_EQ(_manager->numberOfRangesToCleanStillInUse(), 0UL);
     notif1.abandon();
     notif2.abandon();
 }
 
 TEST_F(MetadataManagerTest, AddRangeNotificationsBlockAndYield) {
-    std::shared_ptr<MetadataManager> manager =
-        std::make_shared<MetadataManager>(getServiceContext(), kNss, executor());
-    manager->refreshActiveMetadata(makeEmptyMetadata());
+    _manager->refreshActiveMetadata(makeEmptyMetadata());
 
     ChunkRange cr1(BSON("key" << 0), BSON("key" << 10));
-    auto notifn1 = manager->cleanUpRange(cr1);
+    auto notifn1 = _manager->cleanUpRange(cr1, Date_t{});
     ASSERT_FALSE(notifn1.ready());
-    ASSERT_EQ(manager->numberOfRangesToClean(), 1UL);
-    auto optNotifn = manager->trackOrphanedDataCleanup(cr1);
+    ASSERT_EQ(_manager->numberOfRangesToClean(), 1UL);
+    auto optNotifn = _manager->trackOrphanedDataCleanup(cr1);
     ASSERT_FALSE(notifn1.ready());
     ASSERT_FALSE(optNotifn->ready());
     ASSERT(notifn1 == *optNotifn);
@@ -214,49 +210,47 @@ TEST_F(MetadataManagerTest, AddRangeNotificationsBlockAndYield) {
 
 TEST_F(MetadataManagerTest, NotificationBlocksUntilDeletion) {
     ChunkRange cr1(BSON("key" << 20), BSON("key" << 30));
-    std::shared_ptr<MetadataManager> manager =
-        std::make_shared<MetadataManager>(getServiceContext(), kNss, executor());
-    manager->refreshActiveMetadata(makeEmptyMetadata());
-    auto optNotif = manager->trackOrphanedDataCleanup(cr1);
+    _manager->refreshActiveMetadata(makeEmptyMetadata());
+    auto optNotif = _manager->trackOrphanedDataCleanup(cr1);
     ASSERT_FALSE(optNotif);  // nothing to track yet
     {
-        ASSERT_EQ(manager->numberOfMetadataSnapshots(), 0UL);
-        ASSERT_EQ(manager->numberOfRangesToClean(), 0UL);
+        ASSERT_EQ(_manager->numberOfMetadataSnapshots(), 0UL);
+        ASSERT_EQ(_manager->numberOfRangesToClean(), 0UL);
 
-        auto scm1 = manager->getActiveMetadata(manager);  // and increment refcount
+        auto scm1 = _manager->getActiveMetadata(_manager);  // and increment refcount
         ASSERT_TRUE(bool(scm1));
         ASSERT_EQ(0ULL, scm1->getChunks().size());
 
-        addChunk(manager);                                // push new metadata
-        auto scm2 = manager->getActiveMetadata(manager);  // and increment refcount
+        addChunk(_manager);                                 // push new metadata
+        auto scm2 = _manager->getActiveMetadata(_manager);  // and increment refcount
         ASSERT_EQ(1ULL, scm2->getChunks().size());
 
         // this is here solely to pacify an invariant in addChunk
-        manager->refreshActiveMetadata(makeEmptyMetadata());
+        _manager->refreshActiveMetadata(makeEmptyMetadata());
 
-        addChunk(manager);                                // push new metadata
-        auto scm3 = manager->getActiveMetadata(manager);  // and increment refcount
+        addChunk(_manager);                                 // push new metadata
+        auto scm3 = _manager->getActiveMetadata(_manager);  // and increment refcount
         ASSERT_EQ(1ULL, scm3->getChunks().size());
 
-        auto overlaps =
-            manager->overlappingMetadata(manager, ChunkRange(BSON("key" << 0), BSON("key" << 10)));
+        auto overlaps = _manager->overlappingMetadata(
+            _manager, ChunkRange(BSON("key" << 0), BSON("key" << 10)));
         ASSERT_EQ(2ULL, overlaps.size());
         std::vector<ScopedCollectionMetadata> ref;
         ref.push_back(std::move(scm3));
         ref.push_back(std::move(scm2));
         ASSERT(ref == overlaps);
 
-        ASSERT_EQ(manager->numberOfMetadataSnapshots(), 3UL);
-        ASSERT_EQ(manager->numberOfRangesToClean(), 0UL);  // not yet...
+        ASSERT_EQ(_manager->numberOfMetadataSnapshots(), 3UL);
+        ASSERT_EQ(_manager->numberOfRangesToClean(), 0UL);  // not yet...
 
-        optNotif = manager->cleanUpRange(cr1);
-        ASSERT_EQ(manager->numberOfMetadataSnapshots(), 3UL);
-        ASSERT_EQ(manager->numberOfRangesToClean(), 1UL);
+        optNotif = _manager->cleanUpRange(cr1, Date_t{});
+        ASSERT_EQ(_manager->numberOfMetadataSnapshots(), 3UL);
+        ASSERT_EQ(_manager->numberOfRangesToClean(), 1UL);
     }  // scm1,2,3 destroyed, refcount of each metadata goes to zero
-    ASSERT_EQ(manager->numberOfMetadataSnapshots(), 0UL);
-    ASSERT_EQ(manager->numberOfRangesToClean(), 1UL);
+    ASSERT_EQ(_manager->numberOfMetadataSnapshots(), 0UL);
+    ASSERT_EQ(_manager->numberOfRangesToClean(), 1UL);
     ASSERT_FALSE(optNotif->ready());
-    auto optNotif2 = manager->trackOrphanedDataCleanup(cr1);  // now tracking it in _rangesToClean
+    auto optNotif2 = _manager->trackOrphanedDataCleanup(cr1);  // now tracking it in _rangesToClean
     ASSERT_TRUE(optNotif && !optNotif->ready());
     ASSERT_TRUE(optNotif2 && !optNotif2->ready());
     ASSERT(*optNotif == *optNotif2);
@@ -265,111 +259,101 @@ TEST_F(MetadataManagerTest, NotificationBlocksUntilDeletion) {
 }
 
 TEST_F(MetadataManagerTest, RefreshAfterSuccessfulMigrationSinglePending) {
-    std::shared_ptr<MetadataManager> manager =
-        std::make_shared<MetadataManager>(getServiceContext(), kNss, executor());
-    manager->refreshActiveMetadata(makeEmptyMetadata());
+    _manager->refreshActiveMetadata(makeEmptyMetadata());
     const ChunkRange cr1(BSON("key" << 0), BSON("key" << 10));
-    ASSERT_EQ(manager->getActiveMetadata(manager)->getChunks().size(), 0UL);
+    ASSERT_EQ(_manager->getActiveMetadata(_manager)->getChunks().size(), 0UL);
 
-    ChunkVersion version = manager->getActiveMetadata(manager)->getCollVersion();
+    ChunkVersion version = _manager->getActiveMetadata(_manager)->getCollVersion();
     version.incMajor();
 
-    manager->refreshActiveMetadata(cloneMetadataPlusChunk(
-        *manager->getActiveMetadata(manager).getMetadata(), cr1.getMin(), cr1.getMax(), version));
-    ASSERT_EQ(manager->getActiveMetadata(manager)->getChunks().size(), 1UL);
+    _manager->refreshActiveMetadata(cloneMetadataPlusChunk(
+        *_manager->getActiveMetadata(_manager).getMetadata(), cr1.getMin(), cr1.getMax(), version));
+    ASSERT_EQ(_manager->getActiveMetadata(_manager)->getChunks().size(), 1UL);
 }
 
 
 TEST_F(MetadataManagerTest, RefreshAfterSuccessfulMigrationMultiplePending) {
-    std::shared_ptr<MetadataManager> manager =
-        std::make_shared<MetadataManager>(getServiceContext(), kNss, executor());
-    manager->refreshActiveMetadata(makeEmptyMetadata());
+    _manager->refreshActiveMetadata(makeEmptyMetadata());
 
     const ChunkRange cr1(BSON("key" << 0), BSON("key" << 10));
     const ChunkRange cr2(BSON("key" << 30), BSON("key" << 40));
-    ASSERT_EQ(manager->getActiveMetadata(manager)->getChunks().size(), 0UL);
+    ASSERT_EQ(_manager->getActiveMetadata(_manager)->getChunks().size(), 0UL);
 
     {
-        ChunkVersion version = manager->getActiveMetadata(manager)->getCollVersion();
+        ChunkVersion version = _manager->getActiveMetadata(_manager)->getCollVersion();
         version.incMajor();
 
-        manager->refreshActiveMetadata(
-            cloneMetadataPlusChunk(*manager->getActiveMetadata(manager).getMetadata(),
+        _manager->refreshActiveMetadata(
+            cloneMetadataPlusChunk(*_manager->getActiveMetadata(_manager).getMetadata(),
                                    cr1.getMin(),
                                    cr1.getMax(),
                                    version));
-        ASSERT_EQ(manager->numberOfRangesToClean(), 0UL);
-        ASSERT_EQ(manager->getActiveMetadata(manager)->getChunks().size(), 1UL);
+        ASSERT_EQ(_manager->numberOfRangesToClean(), 0UL);
+        ASSERT_EQ(_manager->getActiveMetadata(_manager)->getChunks().size(), 1UL);
     }
 
     {
-        ChunkVersion version = manager->getActiveMetadata(manager)->getCollVersion();
+        ChunkVersion version = _manager->getActiveMetadata(_manager)->getCollVersion();
         version.incMajor();
 
-        manager->refreshActiveMetadata(
-            cloneMetadataPlusChunk(*manager->getActiveMetadata(manager).getMetadata(),
+        _manager->refreshActiveMetadata(
+            cloneMetadataPlusChunk(*_manager->getActiveMetadata(_manager).getMetadata(),
                                    cr2.getMin(),
                                    cr2.getMax(),
                                    version));
-        ASSERT_EQ(manager->getActiveMetadata(manager)->getChunks().size(), 2UL);
+        ASSERT_EQ(_manager->getActiveMetadata(_manager)->getChunks().size(), 2UL);
     }
 }
 
 TEST_F(MetadataManagerTest, RefreshAfterNotYetCompletedMigrationMultiplePending) {
-    std::shared_ptr<MetadataManager> manager =
-        std::make_shared<MetadataManager>(getServiceContext(), kNss, executor());
-    manager->refreshActiveMetadata(makeEmptyMetadata());
+    _manager->refreshActiveMetadata(makeEmptyMetadata());
 
     const ChunkRange cr1(BSON("key" << 0), BSON("key" << 10));
     const ChunkRange cr2(BSON("key" << 30), BSON("key" << 40));
-    ASSERT_EQ(manager->getActiveMetadata(manager)->getChunks().size(), 0UL);
+    ASSERT_EQ(_manager->getActiveMetadata(_manager)->getChunks().size(), 0UL);
 
-    ChunkVersion version = manager->getActiveMetadata(manager)->getCollVersion();
+    ChunkVersion version = _manager->getActiveMetadata(_manager)->getCollVersion();
     version.incMajor();
 
-    manager->refreshActiveMetadata(
-        cloneMetadataPlusChunk(*manager->getActiveMetadata(manager).getMetadata(),
+    _manager->refreshActiveMetadata(
+        cloneMetadataPlusChunk(*_manager->getActiveMetadata(_manager).getMetadata(),
                                BSON("key" << 50),
                                BSON("key" << 60),
                                version));
-    ASSERT_EQ(manager->getActiveMetadata(manager)->getChunks().size(), 1UL);
+    ASSERT_EQ(_manager->getActiveMetadata(_manager)->getChunks().size(), 1UL);
 }
 
 TEST_F(MetadataManagerTest, BeginReceiveWithOverlappingRange) {
-    std::shared_ptr<MetadataManager> manager =
-        std::make_shared<MetadataManager>(getServiceContext(), kNss, executor());
-    manager->refreshActiveMetadata(makeEmptyMetadata());
+    _manager->refreshActiveMetadata(makeEmptyMetadata());
 
     const ChunkRange cr1(BSON("key" << 0), BSON("key" << 10));
     const ChunkRange cr2(BSON("key" << 30), BSON("key" << 40));
     const ChunkRange crOverlap(BSON("key" << 5), BSON("key" << 35));
 
-    ASSERT_EQ(manager->getActiveMetadata(manager)->getChunks().size(), 0UL);
+    ASSERT_EQ(_manager->getActiveMetadata(_manager)->getChunks().size(), 0UL);
 }
 
 TEST_F(MetadataManagerTest, RefreshMetadataAfterDropAndRecreate) {
-    std::shared_ptr<MetadataManager> manager =
-        std::make_shared<MetadataManager>(getServiceContext(), kNss, executor());
-    manager->refreshActiveMetadata(makeEmptyMetadata());
+    _manager->refreshActiveMetadata(makeEmptyMetadata());
 
     {
-        auto metadata = manager->getActiveMetadata(manager);
+        auto metadata = _manager->getActiveMetadata(_manager);
         ChunkVersion newVersion = metadata->getCollVersion();
         newVersion.incMajor();
 
-        manager->refreshActiveMetadata(cloneMetadataPlusChunk(
+        _manager->refreshActiveMetadata(cloneMetadataPlusChunk(
             *metadata.getMetadata(), BSON("key" << 0), BSON("key" << 10), newVersion));
     }
 
     // Now, pretend that the collection was dropped and recreated
     auto recreateMetadata = makeEmptyMetadata();
-    ChunkVersion newVersion = manager->getActiveMetadata(manager)->getCollVersion();
+    ChunkVersion newVersion = _manager->getActiveMetadata(_manager)->getCollVersion();
     newVersion.incMajor();
-    manager->refreshActiveMetadata(cloneMetadataPlusChunk(
+    _manager->refreshActiveMetadata(cloneMetadataPlusChunk(
         *recreateMetadata, BSON("key" << 20), BSON("key" << 30), newVersion));
-    ASSERT_EQ(manager->getActiveMetadata(manager)->getChunks().size(), 1UL);
+    ASSERT_EQ(_manager->getActiveMetadata(_manager)->getChunks().size(), 1UL);
 
-    const auto chunkEntry = manager->getActiveMetadata(manager)->getChunks().begin();
+    const auto chunkEntry = _manager->getActiveMetadata(_manager)->getChunks().begin();
     ASSERT_BSONOBJ_EQ(BSON("key" << 20), chunkEntry->first);
     ASSERT_BSONOBJ_EQ(BSON("key" << 30), chunkEntry->second.getMaxKey());
     ASSERT_EQ(newVersion, chunkEntry->second.getVersion());
@@ -377,16 +361,14 @@ TEST_F(MetadataManagerTest, RefreshMetadataAfterDropAndRecreate) {
 
 // Tests membership functions for _rangesToClean
 TEST_F(MetadataManagerTest, RangesToCleanMembership) {
-    std::shared_ptr<MetadataManager> manager =
-        std::make_shared<MetadataManager>(getServiceContext(), kNss, executor());
-    manager->refreshActiveMetadata(makeEmptyMetadata());
+    _manager->refreshActiveMetadata(makeEmptyMetadata());
 
-    ASSERT(manager->numberOfRangesToClean() == 0UL);
+    ASSERT(_manager->numberOfRangesToClean() == 0UL);
 
     ChunkRange cr1 = ChunkRange(BSON("key" << 0), BSON("key" << 10));
-    auto notifn = manager->cleanUpRange(cr1);
+    auto notifn = _manager->cleanUpRange(cr1, Date_t{});
     ASSERT(!notifn.ready());
-    ASSERT(manager->numberOfRangesToClean() == 1UL);
+    ASSERT(_manager->numberOfRangesToClean() == 1UL);
     notifn.abandon();
 }