SERVER-39520 Use database IX lock for dropCollection

3 files changed, 69 insertions, 76 deletions

diff --git a/src/mongo/dbtests/indexupdatetests.cpp b/src/mongo/dbtests/indexupdatetests.cpp
index 68bbcd7e819..6b5b7044484 100644
--- a/src/mongo/dbtests/indexupdatetests.cpp
+++ b/src/mongo/dbtests/indexupdatetests.cpp
@@ -111,22 +111,20 @@ public:
         Collection* coll;
         {
             WriteUnitOfWork wunit(&_opCtx);
-            db->dropCollection(&_opCtx, _ns).transitional_ignore();
+            ASSERT_OK(db->dropCollection(&_opCtx, _ns));
             coll = db->createCollection(&_opCtx, _ns);
 
             OpDebug* const nullOpDebug = nullptr;
-            coll->insertDocument(&_opCtx,
-                                 InsertStatement(BSON("_id" << 1 << "a"
-                                                            << "dup")),
-                                 nullOpDebug,
-                                 true)
-                .transitional_ignore();
-            coll->insertDocument(&_opCtx,
-                                 InsertStatement(BSON("_id" << 2 << "a"
-                                                            << "dup")),
-                                 nullOpDebug,
-                                 true)
-                .transitional_ignore();
+            ASSERT_OK(coll->insertDocument(&_opCtx,
+                                           InsertStatement(BSON("_id" << 1 << "a"
+                                                                      << "dup")),
+                                           nullOpDebug,
+                                           true));
+            ASSERT_OK(coll->insertDocument(&_opCtx,
+                                           InsertStatement(BSON("_id" << 2 << "a"
+                                                                      << "dup")),
+                                           nullOpDebug,
+                                           true));
             wunit.commit();
         }
 
@@ -168,7 +166,7 @@ public:
         Collection* coll;
         {
             WriteUnitOfWork wunit(&_opCtx);
-            db->dropCollection(&_opCtx, _ns).transitional_ignore();
+            ASSERT_OK(db->dropCollection(&_opCtx, _ns));
             coll = db->createCollection(&_opCtx, _ns);
 
             OpDebug* const nullOpDebug = nullptr;
@@ -225,7 +223,7 @@ public:
         Collection* coll;
         {
             WriteUnitOfWork wunit(&_opCtx);
-            db->dropCollection(&_opCtx, _ns).transitional_ignore();
+            ASSERT_OK(db->dropCollection(&_opCtx, _ns));
             coll = db->createCollection(&_opCtx, _ns);
             // Drop all indexes including id index.
             coll->getIndexCatalog()->dropAllIndexes(&_opCtx, true);
@@ -233,8 +231,8 @@ public:
             int32_t nDocs = 1000;
             OpDebug* const nullOpDebug = nullptr;
             for (int32_t i = 0; i < nDocs; ++i) {
-                coll->insertDocument(&_opCtx, InsertStatement(BSON("a" << i)), nullOpDebug)
-                    .transitional_ignore();
+                ASSERT_OK(
+                    coll->insertDocument(&_opCtx, InsertStatement(BSON("a" << i)), nullOpDebug));
             }
             wunit.commit();
         }
@@ -267,11 +265,7 @@ public:
         Collection* coll;
         {
             WriteUnitOfWork wunit(&_opCtx);
-            {
-                // TODO SERVER-39520: Remove this DBLock
-                Lock::DBLock lock(&_opCtx, db->name(), MODE_X);
-                db->dropCollection(&_opCtx, _ns).transitional_ignore();
-            }
+            ASSERT_OK(db->dropCollection(&_opCtx, _ns));
             CollectionOptions options;
             options.capped = true;
             options.cappedSize = 10 * 1024;
@@ -281,8 +275,8 @@ public:
             int32_t nDocs = 1000;
             OpDebug* const nullOpDebug = nullptr;
             for (int32_t i = 0; i < nDocs; ++i) {
-                coll->insertDocument(&_opCtx, InsertStatement(BSON("_id" << i)), nullOpDebug, true)
-                    .transitional_ignore();
+                ASSERT_OK(coll->insertDocument(
+                    &_opCtx, InsertStatement(BSON("_id" << i)), nullOpDebug, true));
             }
             wunit.commit();
         }
diff --git a/src/mongo/dbtests/rollbacktests.cpp b/src/mongo/dbtests/rollbacktests.cpp
index d114992fb13..aa90d235361 100644
--- a/src/mongo/dbtests/rollbacktests.cpp
+++ b/src/mongo/dbtests/rollbacktests.cpp
@@ -61,10 +61,10 @@ void dropDatabase(OperationContext* opCtx, const NamespaceString& nss) {
         databaseHolder->dropDb(opCtx, db);
     }
 }
-bool collectionExists(OldClientContext* ctx, const string& ns) {
+bool collectionExists(OperationContext* opCtx, OldClientContext* ctx, const string& ns) {
     auto nss = NamespaceString(ns);
     std::vector<NamespaceString> collections =
-        UUIDCatalog::get(getGlobalServiceContext()).getAllCollectionNamesFromDb(nss.db());
+        UUIDCatalog::get(getGlobalServiceContext()).getAllCollectionNamesFromDb(opCtx, nss.db());
     return std::count(collections.begin(), collections.end(), nss) > 0;
 }
 
@@ -73,11 +73,11 @@ void createCollection(OperationContext* opCtx, const NamespaceString& nss) {
     OldClientContext ctx(opCtx, nss.ns());
     {
         WriteUnitOfWork uow(opCtx);
-        ASSERT(!collectionExists(&ctx, nss.ns()));
+        ASSERT(!collectionExists(opCtx, &ctx, nss.ns()));
         CollectionOptions collectionOptions;
         ASSERT_OK(collectionOptions.parse(BSONObj(), CollectionOptions::parseForCommand));
         ASSERT_OK(ctx.db()->userCreateNS(opCtx, nss, collectionOptions, false));
-        ASSERT(collectionExists(&ctx, nss.ns()));
+        ASSERT(collectionExists(opCtx, &ctx, nss.ns()));
         uow.commit();
     }
 }
@@ -174,20 +174,20 @@ public:
         OldClientContext ctx(&opCtx, ns);
         {
             WriteUnitOfWork uow(&opCtx);
-            ASSERT(!collectionExists(&ctx, ns));
+            ASSERT(!collectionExists(&opCtx, &ctx, ns));
             auto options = capped ? BSON("capped" << true << "size" << 1000) : BSONObj();
             CollectionOptions collectionOptions;
             ASSERT_OK(collectionOptions.parse(options, CollectionOptions::parseForCommand));
             ASSERT_OK(ctx.db()->userCreateNS(&opCtx, nss, collectionOptions, defaultIndexes));
-            ASSERT(collectionExists(&ctx, ns));
+            ASSERT(collectionExists(&opCtx, &ctx, ns));
             if (!rollback) {
                 uow.commit();
             }
         }
         if (rollback) {
-            ASSERT(!collectionExists(&ctx, ns));
+            ASSERT(!collectionExists(&opCtx, &ctx, ns));
         } else {
-            ASSERT(collectionExists(&ctx, ns));
+            ASSERT(collectionExists(&opCtx, &ctx, ns));
         }
     }
 };
@@ -211,30 +211,30 @@ public:
         OldClientContext ctx(&opCtx, ns);
         {
             WriteUnitOfWork uow(&opCtx);
-            ASSERT(!collectionExists(&ctx, ns));
+            ASSERT(!collectionExists(&opCtx, &ctx, ns));
             auto options = capped ? BSON("capped" << true << "size" << 1000) : BSONObj();
             CollectionOptions collectionOptions;
             ASSERT_OK(collectionOptions.parse(options, CollectionOptions::parseForCommand));
             ASSERT_OK(ctx.db()->userCreateNS(&opCtx, nss, collectionOptions, defaultIndexes));
             uow.commit();
         }
-        ASSERT(collectionExists(&ctx, ns));
+        ASSERT(collectionExists(&opCtx, &ctx, ns));
 
         // END OF SETUP / START OF TEST
 
         {
             WriteUnitOfWork uow(&opCtx);
-            ASSERT(collectionExists(&ctx, ns));
+            ASSERT(collectionExists(&opCtx, &ctx, ns));
             ASSERT_OK(ctx.db()->dropCollection(&opCtx, ns));
-            ASSERT(!collectionExists(&ctx, ns));
+            ASSERT(!collectionExists(&opCtx, &ctx, ns));
             if (!rollback) {
                 uow.commit();
             }
         }
         if (rollback) {
-            ASSERT(collectionExists(&ctx, ns));
+            ASSERT(collectionExists(&opCtx, &ctx, ns));
         } else {
-            ASSERT(!collectionExists(&ctx, ns));
+            ASSERT(!collectionExists(&opCtx, &ctx, ns));
         }
     }
 };
@@ -261,34 +261,34 @@ public:
 
         {
             WriteUnitOfWork uow(&opCtx);
-            ASSERT(!collectionExists(&ctx, source.ns()));
-            ASSERT(!collectionExists(&ctx, target.ns()));
+            ASSERT(!collectionExists(&opCtx, &ctx, source.ns()));
+            ASSERT(!collectionExists(&opCtx, &ctx, target.ns()));
             auto options = capped ? BSON("capped" << true << "size" << 1000) : BSONObj();
             CollectionOptions collectionOptions;
             ASSERT_OK(collectionOptions.parse(options, CollectionOptions::parseForCommand));
             ASSERT_OK(ctx.db()->userCreateNS(&opCtx, source, collectionOptions, defaultIndexes));
             uow.commit();
         }
-        ASSERT(collectionExists(&ctx, source.ns()));
-        ASSERT(!collectionExists(&ctx, target.ns()));
+        ASSERT(collectionExists(&opCtx, &ctx, source.ns()));
+        ASSERT(!collectionExists(&opCtx, &ctx, target.ns()));
 
         // END OF SETUP / START OF TEST
 
         {
             WriteUnitOfWork uow(&opCtx);
             ASSERT_OK(renameCollection(&opCtx, source, target));
-            ASSERT(!collectionExists(&ctx, source.ns()));
-            ASSERT(collectionExists(&ctx, target.ns()));
+            ASSERT(!collectionExists(&opCtx, &ctx, source.ns()));
+            ASSERT(collectionExists(&opCtx, &ctx, target.ns()));
             if (!rollback) {
                 uow.commit();
             }
         }
         if (rollback) {
-            ASSERT(collectionExists(&ctx, source.ns()));
-            ASSERT(!collectionExists(&ctx, target.ns()));
+            ASSERT(collectionExists(&opCtx, &ctx, source.ns()));
+            ASSERT(!collectionExists(&opCtx, &ctx, target.ns()));
         } else {
-            ASSERT(!collectionExists(&ctx, source.ns()));
-            ASSERT(collectionExists(&ctx, target.ns()));
+            ASSERT(!collectionExists(&opCtx, &ctx, source.ns()));
+            ASSERT(collectionExists(&opCtx, &ctx, target.ns()));
         }
     }
 };
@@ -320,8 +320,8 @@ public:
 
         {
             WriteUnitOfWork uow(&opCtx);
-            ASSERT(!collectionExists(&ctx, source.ns()));
-            ASSERT(!collectionExists(&ctx, target.ns()));
+            ASSERT(!collectionExists(&opCtx, &ctx, source.ns()));
+            ASSERT(!collectionExists(&opCtx, &ctx, target.ns()));
             auto options = capped ? BSON("capped" << true << "size" << 1000) : BSONObj();
             CollectionOptions collectionOptions;
             ASSERT_OK(collectionOptions.parse(options, CollectionOptions::parseForCommand));
@@ -334,8 +334,8 @@ public:
 
             uow.commit();
         }
-        ASSERT(collectionExists(&ctx, source.ns()));
-        ASSERT(collectionExists(&ctx, target.ns()));
+        ASSERT(collectionExists(&opCtx, &ctx, source.ns()));
+        ASSERT(collectionExists(&opCtx, &ctx, target.ns()));
         assertOnlyRecord(&opCtx, source, sourceDoc);
         assertOnlyRecord(&opCtx, target, targetDoc);
 
@@ -351,21 +351,21 @@ public:
                                {},
                                DropCollectionSystemCollectionMode::kDisallowSystemCollectionDrops));
             ASSERT_OK(renameCollection(&opCtx, source, target));
-            ASSERT(!collectionExists(&ctx, source.ns()));
-            ASSERT(collectionExists(&ctx, target.ns()));
+            ASSERT(!collectionExists(&opCtx, &ctx, source.ns()));
+            ASSERT(collectionExists(&opCtx, &ctx, target.ns()));
             assertOnlyRecord(&opCtx, target, sourceDoc);
             if (!rollback) {
                 uow.commit();
             }
         }
         if (rollback) {
-            ASSERT(collectionExists(&ctx, source.ns()));
-            ASSERT(collectionExists(&ctx, target.ns()));
+            ASSERT(collectionExists(&opCtx, &ctx, source.ns()));
+            ASSERT(collectionExists(&opCtx, &ctx, target.ns()));
             assertOnlyRecord(&opCtx, source, sourceDoc);
             assertOnlyRecord(&opCtx, target, targetDoc);
         } else {
-            ASSERT(!collectionExists(&ctx, source.ns()));
-            ASSERT(collectionExists(&ctx, target.ns()));
+            ASSERT(!collectionExists(&opCtx, &ctx, source.ns()));
+            ASSERT(collectionExists(&opCtx, &ctx, target.ns()));
             assertOnlyRecord(&opCtx, target, sourceDoc);
         }
     }
@@ -390,14 +390,14 @@ public:
 
         {
             WriteUnitOfWork uow(&opCtx);
-            ASSERT(!collectionExists(&ctx, nss.ns()));
+            ASSERT(!collectionExists(&opCtx, &ctx, nss.ns()));
             CollectionOptions collectionOptions;
             ASSERT_OK(collectionOptions.parse(BSONObj(), CollectionOptions::parseForCommand));
             ASSERT_OK(ctx.db()->userCreateNS(&opCtx, nss, collectionOptions, defaultIndexes));
             insertRecord(&opCtx, nss, oldDoc);
             uow.commit();
         }
-        ASSERT(collectionExists(&ctx, nss.ns()));
+        ASSERT(collectionExists(&opCtx, &ctx, nss.ns()));
         assertOnlyRecord(&opCtx, nss, oldDoc);
 
         // END OF SETUP / START OF TEST
@@ -411,18 +411,18 @@ public:
                                result,
                                {},
                                DropCollectionSystemCollectionMode::kDisallowSystemCollectionDrops));
-            ASSERT(!collectionExists(&ctx, nss.ns()));
+            ASSERT(!collectionExists(&opCtx, &ctx, nss.ns()));
             CollectionOptions collectionOptions;
             ASSERT_OK(collectionOptions.parse(BSONObj(), CollectionOptions::parseForCommand));
             ASSERT_OK(ctx.db()->userCreateNS(&opCtx, nss, collectionOptions, defaultIndexes));
-            ASSERT(collectionExists(&ctx, nss.ns()));
+            ASSERT(collectionExists(&opCtx, &ctx, nss.ns()));
             insertRecord(&opCtx, nss, newDoc);
             assertOnlyRecord(&opCtx, nss, newDoc);
             if (!rollback) {
                 uow.commit();
             }
         }
-        ASSERT(collectionExists(&ctx, nss.ns()));
+        ASSERT(collectionExists(&opCtx, &ctx, nss.ns()));
         if (rollback) {
             assertOnlyRecord(&opCtx, nss, oldDoc);
         } else {
@@ -446,14 +446,14 @@ public:
         BSONObj doc = BSON("_id"
                            << "example string");
 
-        ASSERT(!collectionExists(&ctx, nss.ns()));
+        ASSERT(!collectionExists(&opCtx, &ctx, nss.ns()));
         {
             WriteUnitOfWork uow(&opCtx);
 
             CollectionOptions collectionOptions;
             ASSERT_OK(collectionOptions.parse(BSONObj(), CollectionOptions::parseForCommand));
             ASSERT_OK(ctx.db()->userCreateNS(&opCtx, nss, collectionOptions, defaultIndexes));
-            ASSERT(collectionExists(&ctx, nss.ns()));
+            ASSERT(collectionExists(&opCtx, &ctx, nss.ns()));
             insertRecord(&opCtx, nss, doc);
             assertOnlyRecord(&opCtx, nss, doc);
 
@@ -464,13 +464,13 @@ public:
                                result,
                                {},
                                DropCollectionSystemCollectionMode::kDisallowSystemCollectionDrops));
-            ASSERT(!collectionExists(&ctx, nss.ns()));
+            ASSERT(!collectionExists(&opCtx, &ctx, nss.ns()));
 
             if (!rollback) {
                 uow.commit();
             }
         }
-        ASSERT(!collectionExists(&ctx, nss.ns()));
+        ASSERT(!collectionExists(&opCtx, &ctx, nss.ns()));
     }
 };
 
@@ -489,14 +489,14 @@ public:
         BSONObj doc = BSON("_id"
                            << "foo");
 
-        ASSERT(!collectionExists(&ctx, nss.ns()));
+        ASSERT(!collectionExists(&opCtx, &ctx, nss.ns()));
         {
             WriteUnitOfWork uow(&opCtx);
 
             CollectionOptions collectionOptions;
             ASSERT_OK(collectionOptions.parse(BSONObj(), CollectionOptions::parseForCommand));
             ASSERT_OK(ctx.db()->userCreateNS(&opCtx, nss, collectionOptions, defaultIndexes));
-            ASSERT(collectionExists(&ctx, nss.ns()));
+            ASSERT(collectionExists(&opCtx, &ctx, nss.ns()));
             insertRecord(&opCtx, nss, doc);
             assertOnlyRecord(&opCtx, nss, doc);
             uow.commit();
@@ -509,14 +509,14 @@ public:
             WriteUnitOfWork uow(&opCtx);
 
             ASSERT_OK(truncateCollection(&opCtx, nss));
-            ASSERT(collectionExists(&ctx, nss.ns()));
+            ASSERT(collectionExists(&opCtx, &ctx, nss.ns()));
             assertEmpty(&opCtx, nss);
 
             if (!rollback) {
                 uow.commit();
             }
         }
-        ASSERT(collectionExists(&ctx, nss.ns()));
+        ASSERT(collectionExists(&opCtx, &ctx, nss.ns()));
         if (rollback) {
             assertOnlyRecord(&opCtx, nss, doc);
         } else {
@@ -753,11 +753,11 @@ public:
 
         {
             WriteUnitOfWork uow(&opCtx);
-            ASSERT(!collectionExists(&ctx, nss.ns()));
+            ASSERT(!collectionExists(&opCtx, &ctx, nss.ns()));
             CollectionOptions collectionOptions;
             ASSERT_OK(collectionOptions.parse(BSONObj(), CollectionOptions::parseForCommand));
             ASSERT_OK(ctx.db()->userCreateNS(&opCtx, nss, collectionOptions, false));
-            ASSERT(collectionExists(&ctx, nss.ns()));
+            ASSERT(collectionExists(&opCtx, &ctx, nss.ns()));
             Collection* coll = ctx.db()->getCollection(&opCtx, nss);
             IndexCatalog* catalog = coll->getIndexCatalog();
 
@@ -770,9 +770,9 @@ public:
             }
         }  // uow
         if (rollback) {
-            ASSERT(!collectionExists(&ctx, ns));
+            ASSERT(!collectionExists(&opCtx, &ctx, ns));
         } else {
-            ASSERT(collectionExists(&ctx, ns));
+            ASSERT(collectionExists(&opCtx, &ctx, ns));
             ASSERT(indexReady(&opCtx, nss, idxNameA));
             ASSERT(indexReady(&opCtx, nss, idxNameB));
             ASSERT(indexReady(&opCtx, nss, idxNameC));
diff --git a/src/mongo/dbtests/validate_tests.cpp b/src/mongo/dbtests/validate_tests.cpp
index 2a84eef2168..8ebebbb676a 100644
--- a/src/mongo/dbtests/validate_tests.cpp
+++ b/src/mongo/dbtests/validate_tests.cpp
@@ -94,7 +94,6 @@ protected:
                       ->validate(&_opCtx,
                                  _full ? kValidateFull : kValidateIndex,
                                  _background,
-                                 std::move(lock),
                                  &results,
                                  &output));