From 78052771af75f9c6fdff10796c82a38167274a6f Mon Sep 17 00:00:00 2001 From: Geert Bosch Date: Thu, 2 Mar 2017 14:07:32 -0500 Subject: SERVER-27987 Create and persist UUIDs for newly created collections --- src/mongo/bson/bsonelement.h | 11 +++ src/mongo/db/catalog/SConscript | 12 +++- src/mongo/db/catalog/collection_options.cpp | 43 ++++------- src/mongo/db/catalog/collection_options.h | 44 ++++++------ src/mongo/db/catalog/collection_options_test.cpp | 39 +++++----- src/mongo/db/catalog/collection_uuid.cpp | 62 ++++++++++++++++ src/mongo/db/catalog/collection_uuid.h | 83 ++++++++++++++++++++++ src/mongo/db/catalog/create_collection.cpp | 8 ++- src/mongo/db/catalog/database.cpp | 6 +- src/mongo/db/catalog/database.h | 1 + src/mongo/db/cloner.cpp | 24 +++++-- src/mongo/db/commands/list_collections.cpp | 12 +++- src/mongo/db/db.h | 1 + src/mongo/db/repl/collection_cloner_test.cpp | 6 +- src/mongo/db/repl/database_cloner.cpp | 19 ++++- src/mongo/db/repl/rs_rollback.cpp | 3 +- src/mongo/db/repl/storage_interface_impl_test.cpp | 2 +- src/mongo/db/s/migration_destination_manager.cpp | 9 ++- .../db/storage/bson_collection_catalog_entry.cpp | 2 +- .../mmap_v1/mmap_v1_database_catalog_entry.cpp | 3 +- src/mongo/db/storage/mmap_v1/repair_database.cpp | 3 +- src/mongo/dbtests/querytests.cpp | 1 + src/mongo/dbtests/rollbacktests.cpp | 61 +++++++++++++--- 23 files changed, 357 insertions(+), 98 deletions(-) create mode 100644 src/mongo/db/catalog/collection_uuid.cpp create mode 100644 src/mongo/db/catalog/collection_uuid.h (limited to 'src/mongo') diff --git a/src/mongo/bson/bsonelement.h b/src/mongo/bson/bsonelement.h index 111cbad442f..3120907b589 100644 --- a/src/mongo/bson/bsonelement.h +++ b/src/mongo/bson/bsonelement.h @@ -579,6 +579,17 @@ public: return Timestamp(); } + const std::array uuid() const { + int len = 0; + const char* data = nullptr; + if (type() == BinData && binDataType() == BinDataType::newUUID) + data = binData(len); + uassert(00000, "uuid must be a 16-byte binary field with UUID (4) subtype", len == 16); + std::array result; + memcpy(&result, data, len); + return result; + } + Date_t timestampTime() const { unsigned long long t = ConstDataView(value() + 4).read>(); return Date_t::fromMillisSinceEpoch(t * 1000); diff --git a/src/mongo/db/catalog/SConscript b/src/mongo/db/catalog/SConscript index a15aa150388..df7d91124c2 100644 --- a/src/mongo/db/catalog/SConscript +++ b/src/mongo/db/catalog/SConscript @@ -4,7 +4,17 @@ Import("env") env = env.Clone() -env.Library('collection_options', ['collection_options.cpp'], LIBDEPS=['$BUILD_DIR/mongo/base']) +env.Library( + target='collection_options', + source=[ + 'collection_options.cpp', + 'collection_uuid.cpp', + ], + LIBDEPS=[ + '$BUILD_DIR/mongo/base', + '$BUILD_DIR/mongo/db/server_parameters', + ], +) env.CppUnitTest('collection_options_test', ['collection_options_test.cpp'], LIBDEPS=['collection_options']) diff --git a/src/mongo/db/catalog/collection_options.cpp b/src/mongo/db/catalog/collection_options.cpp index 0a576d3c5d2..0f5152d138e 100644 --- a/src/mongo/db/catalog/collection_options.cpp +++ b/src/mongo/db/catalog/collection_options.cpp @@ -95,32 +95,6 @@ const std::set collectionOptionsWhitelist{ } // namespace -void CollectionOptions::reset() { - capped = false; - cappedSize = 0; - cappedMaxDocs = 0; - initialNumExtents = 0; - initialExtentSizes.clear(); - autoIndexId = DEFAULT; - // For compatibility with previous versions if the user sets no flags, - // we set Flag_UsePowerOf2Sizes in case the user downgrades. - flags = Flag_UsePowerOf2Sizes; - flagsSet = false; - temp = false; - storageEngine = BSONObj(); - indexOptionDefaults = BSONObj(); - validator = BSONObj(); - validationLevel = ""; - validationAction = ""; - collation = BSONObj(); - viewOn = ""; - pipeline = BSONObj(); -} - -bool CollectionOptions::isValid() const { - return validate().isOK(); -} - bool CollectionOptions::isView() const { return !viewOn.empty(); } @@ -129,8 +103,8 @@ Status CollectionOptions::validate() const { return CollectionOptions().parse(toBSON()); } -Status CollectionOptions::parse(const BSONObj& options) { - reset(); +Status CollectionOptions::parse(const BSONObj& options, ParseKind kind) { + *this = {}; // Versions 2.4 and earlier of the server store "create" inside the collection metadata when the // user issues an explicit collection creation command. These versions also wrote any @@ -151,7 +125,13 @@ Status CollectionOptions::parse(const BSONObj& options) { BSONElement e = i.next(); StringData fieldName = e.fieldName(); - if (fieldName == "capped") { + if (fieldName == "uuid" && kind == parseForStorage) { + try { + uuid.emplace(e); + } catch (const UserException& ex) { + return ex.toStatus(); + } + } else if (fieldName == "capped") { capped = e.trueValue(); } else if (fieldName == "size") { if (!e.isNumber()) { @@ -282,6 +262,11 @@ Status CollectionOptions::parse(const BSONObj& options) { BSONObj CollectionOptions::toBSON() const { BSONObjBuilder b; + + if (uuid) { + b.appendElements(uuid->toBSON()); + } + if (capped) { b.appendBool("capped", true); b.appendNumber("size", cappedSize); diff --git a/src/mongo/db/catalog/collection_options.h b/src/mongo/db/catalog/collection_options.h index 8f8867bcf27..50703874e22 100644 --- a/src/mongo/db/catalog/collection_options.h +++ b/src/mongo/db/catalog/collection_options.h @@ -30,27 +30,26 @@ #include +#include + #include "mongo/base/status.h" +#include "mongo/db/catalog/collection_uuid.h" #include "mongo/db/jsobj.h" namespace mongo { struct CollectionOptions { - CollectionOptions() { - reset(); - } - - void reset(); - /** - * Returns true if collection options validates successfully. + * Returns true if the options indicate the namespace is a view. */ - bool isValid() const; + bool isView() const; /** - * Returns true if the options indicate the namespace is a view. + * The 'uuid' member is a collection property stored in the catalog with user-settable options, + * but is not valid for the user to specify as collection option. So, parsing commands must + * reject the 'uuid' property, but parsing stored options must accept it. */ - bool isView() const; + enum ParseKind { parseForCommand, parseForStorage }; /** * Confirms that collection options can be converted to BSON and back without errors. @@ -60,7 +59,7 @@ struct CollectionOptions { /** * Parses the "options" subfield of the collection info object. */ - Status parse(const BSONObj& obj); + Status parse(const BSONObj& obj, ParseKind kind = parseForCommand); BSONObj toBSON() const; @@ -72,15 +71,18 @@ struct CollectionOptions { // ---- - bool capped; - long long cappedSize; - long long cappedMaxDocs; + // Collection UUID. Will exist if featureCompatibilityVersion >= 3.6. + boost::optional uuid; + + bool capped = false; + long long cappedSize = 0; + long long cappedMaxDocs = 0; - // following 2 are mutually exclusive, can only have one set - long long initialNumExtents; + // (MMAPv1) The following 2 are mutually exclusive, can only have one set. + long long initialNumExtents = 0; std::vector initialExtentSizes; - // behavior of _id index creation when collection created + // The behavior of _id index creation when collection created void setNoIdIndex() { autoIndexId = NO; } @@ -88,17 +90,17 @@ struct CollectionOptions { DEFAULT, // currently yes for most collections, NO for some system ones YES, // create _id index NO // do not create _id index - } autoIndexId; + } autoIndexId = DEFAULT; // user flags enum UserFlags { Flag_UsePowerOf2Sizes = 1 << 0, Flag_NoPadding = 1 << 1, }; - int flags; // a bitvector of UserFlags - bool flagsSet; + int flags = Flag_UsePowerOf2Sizes; // a bitvector of UserFlags + bool flagsSet = false; - bool temp; + bool temp = false; // Storage engine collection options. Always owned or empty. BSONObj storageEngine; diff --git a/src/mongo/db/catalog/collection_options_test.cpp b/src/mongo/db/catalog/collection_options_test.cpp index 71f6b28fa29..cb8cef38182 100644 --- a/src/mongo/db/catalog/collection_options_test.cpp +++ b/src/mongo/db/catalog/collection_options_test.cpp @@ -57,14 +57,6 @@ TEST(CollectionOptions, SimpleRoundTrip) { checkRoundTrip(options); } -TEST(CollectionOptions, IsValid) { - CollectionOptions options; - ASSERT_TRUE(options.isValid()); - - options.storageEngine = fromjson("{storageEngine1: 1}"); - ASSERT_FALSE(options.isValid()); -} - TEST(CollectionOptions, Validate) { CollectionOptions options; ASSERT_OK(options.validate()); @@ -84,9 +76,9 @@ TEST(CollectionOptions, Validator) { options.validator = fromjson("{b: 1}"); ASSERT_BSONOBJ_EQ(options.toBSON()["validator"].Obj(), fromjson("{b: 1}")); - options.reset(); - ASSERT_BSONOBJ_EQ(options.validator, BSONObj()); - ASSERT(!options.toBSON()["validator"]); + CollectionOptions defaultOptions; + ASSERT_BSONOBJ_EQ(defaultOptions.validator, BSONObj()); + ASSERT(!defaultOptions.toBSON()["validator"]); } TEST(CollectionOptions, ErrorBadSize) { @@ -171,9 +163,8 @@ TEST(CollectionOptions, ResetStorageEngineField) { ASSERT_OK(opts.parse(fromjson("{storageEngine: {storageEngine1: {x: 1}}}"))); checkRoundTrip(opts); - opts.reset(); - - ASSERT_TRUE(opts.storageEngine.isEmpty()); + CollectionOptions defaultOpts; + ASSERT_TRUE(defaultOpts.storageEngine.isEmpty()); } TEST(CollectionOptions, ModifyStorageEngineField) { @@ -211,7 +202,6 @@ TEST(CollectionOptions, CollationFieldParsesCorrectly) { CollectionOptions options; ASSERT_OK(options.parse(fromjson("{collation: {locale: 'en'}}"))); ASSERT_BSONOBJ_EQ(options.collation, fromjson("{locale: 'en'}")); - ASSERT_TRUE(options.isValid()); ASSERT_OK(options.validate()); } @@ -224,10 +214,9 @@ TEST(CollectionOptions, ParsedCollationObjShouldBeOwned) { TEST(CollectionOptions, ResetClearsCollationField) { CollectionOptions options; + ASSERT_TRUE(options.collation.isEmpty()); ASSERT_OK(options.parse(fromjson("{collation: {locale: 'en'}}"))); ASSERT_FALSE(options.collation.isEmpty()); - options.reset(); - ASSERT_TRUE(options.collation.isEmpty()); } TEST(CollectionOptions, CollationFieldLeftEmptyWhenOmitted) { @@ -325,4 +314,20 @@ TEST(CollectionOptions, WriteConcernWhitelistedOptionIgnored) { auto status = options.parse(fromjson("{writeConcern: 1}")); ASSERT_OK(status); } + +TEST(CollectionOptions, ParseUUID) { + CollectionOptions options; + CollectionUUID uuid = CollectionUUID::generateSecureRandomUUID(); + + // Check required parse failures + ASSERT_FALSE(options.uuid); + ASSERT_NOT_OK(options.parse(uuid.toBSON())); + ASSERT_NOT_OK(options.parse(BSON("uuid" << 1))); + ASSERT_NOT_OK(options.parse(BSON("uuid" << 1), CollectionOptions::parseForStorage)); + ASSERT_FALSE(options.uuid); + + // Check successful parse and roundtrip. + ASSERT_OK(options.parse(uuid.toBSON(), CollectionOptions::parseForStorage)); + ASSERT(options.uuid.get() == uuid); +} } // namespace mongo diff --git a/src/mongo/db/catalog/collection_uuid.cpp b/src/mongo/db/catalog/collection_uuid.cpp new file mode 100644 index 00000000000..dfe9327705a --- /dev/null +++ b/src/mongo/db/catalog/collection_uuid.cpp @@ -0,0 +1,62 @@ +/** + * Copyright (C) 2017 MongoDB Inc. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License, version 3, + * as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + * + * As a special exception, the copyright holders give permission to link the + * code of portions of this program with the OpenSSL library under certain + * conditions as described in each individual source file and distribute + * linked combinations including the program with the OpenSSL library. You + * must comply with the GNU Affero General Public License in all respects for + * all of the code used other than as permitted herein. If you modify file(s) + * with this exception, you may extend this exception to your version of the + * file(s), but you are not obligated to do so. If you do not wish to do so, + * delete this exception statement from your version. If you delete this + * exception statement from all source files in the program, then also delete + * it in the license file. + */ + +#include "mongo/platform/basic.h" + +#include "collection_uuid.h" + +#include "mongo/db/server_parameters.h" +#include "mongo/platform/random.h" +#include "mongo/stdx/mutex.h" + +namespace mongo { + +bool enableCollectionUUIDs = false; +ExportedServerParameter enableCollectionUUIDsParameter( + ServerParameterSet::getGlobal(), "enableCollectionUUIDs", &enableCollectionUUIDs); + +namespace { +stdx::mutex uuidGenMutex; +auto uuidGen = SecureRandom::create(); +} // namespace + +// static +CollectionUUID CollectionUUID::generateSecureRandomUUID() { + stdx::unique_lock lock(uuidGenMutex); + int64_t randomWords[2] = {uuidGen->nextInt64(), uuidGen->nextInt64()}; + UUID randomBytes; + memcpy(&randomBytes, randomWords, sizeof(randomBytes)); + // Set version in high 4 bits of byte 6 and variant in high 2 bits of byte 8, see RFC 4122, + // section 4.1.1, 4.1.2 and 4.1.3. + randomBytes[6] &= 0x0f; + randomBytes[6] |= 0x40; // v4 + randomBytes[8] &= 0x3f; + randomBytes[8] |= 0x80; // Randomly assigned + return CollectionUUID{randomBytes}; +} +} // namespace mongo diff --git a/src/mongo/db/catalog/collection_uuid.h b/src/mongo/db/catalog/collection_uuid.h new file mode 100644 index 00000000000..23c6deba1d9 --- /dev/null +++ b/src/mongo/db/catalog/collection_uuid.h @@ -0,0 +1,83 @@ +/** + * Copyright (C) 2017 MongoDB Inc. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License, version 3, + * as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + * + * As a special exception, the copyright holders give permission to link the + * code of portions of this program with the OpenSSL library under certain + * conditions as described in each individual source file and distribute + * linked combinations including the program with the OpenSSL library. You + * must comply with the GNU Affero General Public License in all respects for + * all of the code used other than as permitted herein. If you modify file(s) + * with this exception, you may extend this exception to your version of the + * file(s), but you are not obligated to do so. If you do not wish to do so, + * delete this exception statement from your version. If you delete this + * exception statement from all source files in the program, then also delete + * it in the license file. + */ + +#pragma once + +#include + +#include "mongo/db/jsobj.h" + +namespace mongo { + +extern bool enableCollectionUUIDs; // TODO(SERVER-27993) Replace based on upgrade/downgrade state. + +/** + * A CollectionUUID is a 128-bit unique identifier, per RFC 4122, v4. for a database collection. + * Newly created collections are assigned a new randomly generated CollectionUUID. In a replica-set + * or a sharded cluster, all nodes will use the same UUID for a given collection. The UUID stays + * with the collection until it is dropped, so even across renames. A copied collection must have + * own new new unique UUID though. + */ +class CollectionUUID { +public: + using UUID = std::array; + CollectionUUID() = delete; + CollectionUUID(const CollectionUUID& other) = default; + + inline bool operator==(const CollectionUUID& rhs) const { + return !memcmp(&_uuid, &rhs._uuid, sizeof(_uuid)); + } + + inline bool operator!=(const CollectionUUID& rhs) const { + return !(*this == rhs); + } + + /** + * Parse a UUID from the given element. Caller must validate the input. + */ + CollectionUUID(BSONElement from) : _uuid(from.uuid()) {} + + /** + * Generate a new random v4 UUID per RFC 4122. + */ + static CollectionUUID generateSecureRandomUUID(); + + /** + * Return a BSON object of the form { uuid: BinData(4, "...") }. + */ + BSONObj toBSON() const { + BSONObjBuilder builder; + builder.appendBinData("uuid", sizeof(UUID), BinDataType::newUUID, &_uuid); + return builder.obj(); + } + +private: + CollectionUUID(const UUID& uuid) : _uuid(uuid) {} + UUID _uuid; // UUID in network byte order +}; +} diff --git a/src/mongo/db/catalog/create_collection.cpp b/src/mongo/db/catalog/create_collection.cpp index 2007aba76d6..ec963bdf0a8 100644 --- a/src/mongo/db/catalog/create_collection.cpp +++ b/src/mongo/db/catalog/create_collection.cpp @@ -86,7 +86,13 @@ Status createCollection(OperationContext* opCtx, // Create collection. const bool createDefaultIndexes = true; - status = userCreateNS(opCtx, ctx.db(), nss.ns(), options, createDefaultIndexes, idIndex); + status = userCreateNS(opCtx, + ctx.db(), + nss.ns(), + options, + CollectionOptions::parseForCommand, + createDefaultIndexes, + idIndex); if (!status.isOK()) { return status; } diff --git a/src/mongo/db/catalog/database.cpp b/src/mongo/db/catalog/database.cpp index b6c11f4c51f..1f68f3256ee 100644 --- a/src/mongo/db/catalog/database.cpp +++ b/src/mongo/db/catalog/database.cpp @@ -640,6 +640,7 @@ Status userCreateNS(OperationContext* opCtx, Database* db, StringData ns, BSONObj options, + CollectionOptions::ParseKind parseKind, bool createDefaultIndexes, const BSONObj& idIndex) { invariant(db); @@ -660,7 +661,7 @@ Status userCreateNS(OperationContext* opCtx, str::stream() << "a view '" << ns.toString() << "' already exists"); CollectionOptions collectionOptions; - Status status = collectionOptions.parse(options); + Status status = collectionOptions.parse(options, parseKind); if (!status.isOK()) return status; @@ -704,8 +705,11 @@ Status userCreateNS(OperationContext* opCtx, } if (collectionOptions.isView()) { + invariant(parseKind == CollectionOptions::parseForCommand); uassertStatusOK(db->createView(opCtx, ns, collectionOptions)); } else { + if (enableCollectionUUIDs && !collectionOptions.uuid) + collectionOptions.uuid.emplace(CollectionUUID::generateSecureRandomUUID()); invariant( db->createCollection(opCtx, ns, collectionOptions, createDefaultIndexes, idIndex)); } diff --git a/src/mongo/db/catalog/database.h b/src/mongo/db/catalog/database.h index de8e65aa3ce..a41d9dcdffb 100644 --- a/src/mongo/db/catalog/database.h +++ b/src/mongo/db/catalog/database.h @@ -267,6 +267,7 @@ Status userCreateNS(OperationContext* opCtx, Database* db, StringData ns, BSONObj options, + CollectionOptions::ParseKind parseKind = CollectionOptions::parseForCommand, bool createDefaultIndexes = true, const BSONObj& idIndex = BSONObj()); diff --git a/src/mongo/db/cloner.cpp b/src/mongo/db/cloner.cpp index 439d3ac574c..20455ad7c22 100644 --- a/src/mongo/db/cloner.cpp +++ b/src/mongo/db/cloner.cpp @@ -170,11 +170,13 @@ struct Cloner::Fun { opCtx->checkForInterrupt(); WriteUnitOfWork wunit(opCtx); + const bool createDefaultIndexes = true; Status s = userCreateNS(opCtx, db, to_collection.toString(), from_options, - true, + CollectionOptions::parseForCommand, + createDefaultIndexes, fixIndexSpec(to_collection.db().toString(), from_id_index)); verify(s.isOK()); wunit.commit(); @@ -390,12 +392,14 @@ void Cloner::copyIndexes(OperationContext* opCtx, opCtx->checkForInterrupt(); WriteUnitOfWork wunit(opCtx); + const bool createDefaultIndexes = true; Status s = userCreateNS( opCtx, db, to_collection.toString(), from_opts, - true, + CollectionOptions::parseForCommand, + createDefaultIndexes, fixIndexSpec(to_collection.db().toString(), getIdIndexSpec(from_indexes))); invariant(s.isOK()); collection = db->getCollection(to_collection); @@ -490,7 +494,14 @@ bool Cloner::copyCollection(OperationContext* opCtx, opCtx->checkForInterrupt(); WriteUnitOfWork wunit(opCtx); - Status status = userCreateNS(opCtx, db, ns, options, true, idIndexSpec); + const bool createDefaultIndexes = true; + Status status = userCreateNS(opCtx, + db, + ns, + options, + CollectionOptions::parseForCommand, + createDefaultIndexes, + idIndexSpec); if (!status.isOK()) { errmsg = status.toString(); // abort write unit of work @@ -528,7 +539,8 @@ StatusWith> Cloner::filterCollectionsForClone( BSONElement collectionOptions = collection["options"]; if (collectionOptions.isABSONObj()) { - auto parseOptionsStatus = CollectionOptions().parse(collectionOptions.Obj()); + auto parseOptionsStatus = CollectionOptions().parse(collectionOptions.Obj(), + CollectionOptions::parseForCommand); if (!parseOptionsStatus.isOK()) { return parseOptionsStatus; } @@ -578,12 +590,14 @@ Status Cloner::createCollectionsForDb( opCtx->checkForInterrupt(); WriteUnitOfWork wunit(opCtx); + const bool createDefaultIndexes = true; Status createStatus = userCreateNS(opCtx, db, nss.ns(), options, - true, + CollectionOptions::parseForCommand, + createDefaultIndexes, fixIndexSpec(nss.db().toString(), params.idIndexSpec)); if (!createStatus.isOK()) { return createStatus; diff --git a/src/mongo/db/commands/list_collections.cpp b/src/mongo/db/commands/list_collections.cpp index 68a6337f548..a0f998fe346 100644 --- a/src/mongo/db/commands/list_collections.cpp +++ b/src/mongo/db/commands/list_collections.cpp @@ -163,10 +163,18 @@ BSONObj buildCollectionBson(OperationContext* opCtx, const Collection* collectio b.append("type", "collection"); CollectionOptions options = collection->getCatalogEntry()->getCollectionOptions(opCtx); + + // While the UUID is stored as a collection option, from the user's perspective it is an + // unsettable read-only property, so put it in the 'info' section. + auto uuid = options.uuid; + options.uuid.reset(); b.append("options", options.toBSON()); - BSONObj info = BSON("readOnly" << storageGlobalParams.readOnly); - b.append("info", info); + BSONObjBuilder infoBuilder; + infoBuilder.append("readOnly", storageGlobalParams.readOnly); + if (uuid) + infoBuilder.appendElements(uuid->toBSON()); + b.append("info", infoBuilder.obj()); auto idIndex = collection->getIndexCatalog()->findIdIndex(opCtx); if (idIndex) { diff --git a/src/mongo/db/db.h b/src/mongo/db/db.h index 180ad9847aa..e94bb34ccb2 100644 --- a/src/mongo/db/db.h +++ b/src/mongo/db/db.h @@ -1,3 +1,4 @@ + /** * Copyright (C) 2008 10gen Inc. * diff --git a/src/mongo/db/repl/collection_cloner_test.cpp b/src/mongo/db/repl/collection_cloner_test.cpp index 440b8dee232..aac4d047372 100644 --- a/src/mongo/db/repl/collection_cloner_test.cpp +++ b/src/mongo/db/repl/collection_cloner_test.cpp @@ -73,7 +73,7 @@ protected: void CollectionClonerTest::setUp() { BaseClonerTest::setUp(); - options.reset(); + options = {}; collectionCloner.reset(nullptr); collectionCloner = stdx::make_unique( &getExecutor(), @@ -101,7 +101,7 @@ void CollectionClonerTest::tearDown() { BaseClonerTest::tearDown(); // Executor may still invoke collection cloner's callback before shutting down. collectionCloner.reset(nullptr); - options.reset(); + options = {}; } BaseCloner* CollectionClonerTest::getCloner() const { @@ -320,7 +320,7 @@ TEST_F(CollectionClonerTest, } TEST_F(CollectionClonerTest, DoNotCreateIDIndexIfAutoIndexIdUsed) { - options.reset(); + options = {}; options.autoIndexId = CollectionOptions::NO; collectionCloner.reset(new CollectionCloner( &getExecutor(), diff --git a/src/mongo/db/repl/database_cloner.cpp b/src/mongo/db/repl/database_cloner.cpp index ba3f52ed048..f7b4cbbc3f7 100644 --- a/src/mongo/db/repl/database_cloner.cpp +++ b/src/mongo/db/repl/database_cloner.cpp @@ -58,6 +58,8 @@ using UniqueLock = stdx::unique_lock; const char* kNameFieldName = "name"; const char* kOptionsFieldName = "options"; +const char* kInfoFieldName = "info"; +const char* kUUIDFieldName = "uuid"; // The number of attempts for the listCollections commands. MONGO_EXPORT_SERVER_PARAMETER(numInitialSyncListCollectionsAttempts, int, 3); @@ -341,11 +343,26 @@ void DatabaseCloner::_listCollectionsCallback(const StatusWith= "3.6". + seen.insert(collectionName); _collectionNamespaces.emplace_back(_dbname, collectionName); diff --git a/src/mongo/db/repl/rs_rollback.cpp b/src/mongo/db/repl/rs_rollback.cpp index dbfb3a51284..8859ea6fba7 100644 --- a/src/mongo/db/repl/rs_rollback.cpp +++ b/src/mongo/db/repl/rs_rollback.cpp @@ -480,12 +480,13 @@ void syncFixUp(OperationContext* opCtx, << typeName(optionsField.type())); } - auto status = options.parse(optionsField.Obj()); + auto status = options.parse(optionsField.Obj(), CollectionOptions::parseForCommand); if (!status.isOK()) { throw RSFatalException(str::stream() << "Failed to parse options " << info << ": " << status.toString()); } + // TODO(SERVER-27992): Set options.uuid. } else { // Use default options. } diff --git a/src/mongo/db/repl/storage_interface_impl_test.cpp b/src/mongo/db/repl/storage_interface_impl_test.cpp index 2ee2cbf2259..cd8bdd98686 100644 --- a/src/mongo/db/repl/storage_interface_impl_test.cpp +++ b/src/mongo/db/repl/storage_interface_impl_test.cpp @@ -576,7 +576,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest, CreateCollectionThatAlreadyExistsF NamespaceString nss("test.system.indexes"); createCollection(opCtx, nss); - const CollectionOptions opts; + const CollectionOptions opts{}; const std::vector indexes; const auto status = storage.createCollectionForBulkLoading(nss, opts, makeIdIndexSpec(nss), indexes); diff --git a/src/mongo/db/s/migration_destination_manager.cpp b/src/mongo/db/s/migration_destination_manager.cpp index cb46f30b056..470afdd6d02 100644 --- a/src/mongo/db/s/migration_destination_manager.cpp +++ b/src/mongo/db/s/migration_destination_manager.cpp @@ -509,7 +509,14 @@ void MigrationDestinationManager::_migrateDriver(OperationContext* opCtx, } WriteUnitOfWork wuow(opCtx); - Status status = userCreateNS(opCtx, db, _nss.ns(), options, true, idIndexSpec); + const bool createDefaultIndexes = true; + Status status = userCreateNS(opCtx, + db, + _nss.ns(), + options, + CollectionOptions::parseForCommand, + createDefaultIndexes, + idIndexSpec); if (!status.isOK()) { warning() << "failed to create collection [" << _nss << "] " << " with options " << options << ": " << redact(status); diff --git a/src/mongo/db/storage/bson_collection_catalog_entry.cpp b/src/mongo/db/storage/bson_collection_catalog_entry.cpp index f7c3eb3d2e0..9bd57ee6941 100644 --- a/src/mongo/db/storage/bson_collection_catalog_entry.cpp +++ b/src/mongo/db/storage/bson_collection_catalog_entry.cpp @@ -260,7 +260,7 @@ void BSONCollectionCatalogEntry::MetaData::parse(const BSONObj& obj) { ns = obj["ns"].valuestrsafe(); if (obj["options"].isABSONObj()) { - options.parse(obj["options"].Obj()); + options.parse(obj["options"].Obj(), CollectionOptions::parseForStorage); } BSONElement indexList = obj["indexes"]; diff --git a/src/mongo/db/storage/mmap_v1/mmap_v1_database_catalog_entry.cpp b/src/mongo/db/storage/mmap_v1/mmap_v1_database_catalog_entry.cpp index c88ed7545c4..d92f89ca2e3 100644 --- a/src/mongo/db/storage/mmap_v1/mmap_v1_database_catalog_entry.cpp +++ b/src/mongo/db/storage/mmap_v1/mmap_v1_database_catalog_entry.cpp @@ -906,7 +906,8 @@ CollectionOptions MMAPV1DatabaseCatalogEntry::getCollectionOptions(OperationCont invariant(rs->findRecord(opCtx, rid, &data)); if (data.releaseToBson()["options"].isABSONObj()) { - Status status = options.parse(data.releaseToBson()["options"].Obj()); + Status status = options.parse(data.releaseToBson()["options"].Obj(), + CollectionOptions::parseForStorage); fassert(18523, status); } return options; diff --git a/src/mongo/db/storage/mmap_v1/repair_database.cpp b/src/mongo/db/storage/mmap_v1/repair_database.cpp index c321cd5513c..90198cfd214 100644 --- a/src/mongo/db/storage/mmap_v1/repair_database.cpp +++ b/src/mongo/db/storage/mmap_v1/repair_database.cpp @@ -361,7 +361,8 @@ Status MMAPV1Engine::repairDatabase(OperationContext* opCtx, CollectionOptions options; if (obj["options"].isABSONObj()) { - Status status = options.parse(obj["options"].Obj()); + Status status = + options.parse(obj["options"].Obj(), CollectionOptions::parseForCommand); if (!status.isOK()) return status; } diff --git a/src/mongo/dbtests/querytests.cpp b/src/mongo/dbtests/querytests.cpp index b2b5495573e..83765c6ecd4 100644 --- a/src/mongo/dbtests/querytests.cpp +++ b/src/mongo/dbtests/querytests.cpp @@ -1318,6 +1318,7 @@ public: ctx.db(), ns(), fromjson("{ capped : true, size : 2000, max: 10000 }"), + CollectionOptions::parseForCommand, false) .isOK()); wunit.commit(); diff --git a/src/mongo/dbtests/rollbacktests.cpp b/src/mongo/dbtests/rollbacktests.cpp index 27982080d36..d9e70651178 100644 --- a/src/mongo/dbtests/rollbacktests.cpp +++ b/src/mongo/dbtests/rollbacktests.cpp @@ -72,7 +72,8 @@ void createCollection(OperationContext* opCtx, const NamespaceString& nss) { { WriteUnitOfWork uow(opCtx); ASSERT(!collectionExists(&ctx, nss.ns())); - ASSERT_OK(userCreateNS(opCtx, ctx.db(), nss.ns(), BSONObj(), false)); + ASSERT_OK(userCreateNS( + opCtx, ctx.db(), nss.ns(), BSONObj(), CollectionOptions::parseForCommand, false)); ASSERT(collectionExists(&ctx, nss.ns())); uow.commit(); } @@ -161,7 +162,8 @@ public: WriteUnitOfWork uow(&opCtx); ASSERT(!collectionExists(&ctx, ns)); auto options = capped ? BSON("capped" << true << "size" << 1000) : BSONObj(); - ASSERT_OK(userCreateNS(&opCtx, ctx.db(), ns, options, defaultIndexes)); + ASSERT_OK(userCreateNS( + &opCtx, ctx.db(), ns, options, CollectionOptions::parseForCommand, defaultIndexes)); ASSERT(collectionExists(&ctx, ns)); if (!rollback) { uow.commit(); @@ -192,7 +194,8 @@ public: WriteUnitOfWork uow(&opCtx); ASSERT(!collectionExists(&ctx, ns)); auto options = capped ? BSON("capped" << true << "size" << 1000) : BSONObj(); - ASSERT_OK(userCreateNS(&opCtx, ctx.db(), ns, options, defaultIndexes)); + ASSERT_OK(userCreateNS( + &opCtx, ctx.db(), ns, options, CollectionOptions::parseForCommand, defaultIndexes)); uow.commit(); } ASSERT(collectionExists(&ctx, ns)); @@ -236,7 +239,12 @@ public: WriteUnitOfWork uow(&opCtx); ASSERT(!collectionExists(&ctx, source.ns())); ASSERT(!collectionExists(&ctx, target.ns())); - ASSERT_OK(userCreateNS(&opCtx, ctx.db(), source.ns(), BSONObj(), defaultIndexes)); + ASSERT_OK(userCreateNS(&opCtx, + ctx.db(), + source.ns(), + BSONObj(), + CollectionOptions::parseForCommand, + defaultIndexes)); uow.commit(); } ASSERT(collectionExists(&ctx, source.ns())); @@ -288,8 +296,18 @@ public: WriteUnitOfWork uow(&opCtx); ASSERT(!collectionExists(&ctx, source.ns())); ASSERT(!collectionExists(&ctx, target.ns())); - ASSERT_OK(userCreateNS(&opCtx, ctx.db(), source.ns(), BSONObj(), defaultIndexes)); - ASSERT_OK(userCreateNS(&opCtx, ctx.db(), target.ns(), BSONObj(), defaultIndexes)); + ASSERT_OK(userCreateNS(&opCtx, + ctx.db(), + source.ns(), + BSONObj(), + CollectionOptions::parseForCommand, + defaultIndexes)); + ASSERT_OK(userCreateNS(&opCtx, + ctx.db(), + target.ns(), + BSONObj(), + CollectionOptions::parseForCommand, + defaultIndexes)); insertRecord(&opCtx, source, sourceDoc); insertRecord(&opCtx, target, targetDoc); @@ -348,7 +366,12 @@ public: { WriteUnitOfWork uow(&opCtx); ASSERT(!collectionExists(&ctx, nss.ns())); - ASSERT_OK(userCreateNS(&opCtx, ctx.db(), nss.ns(), BSONObj(), defaultIndexes)); + ASSERT_OK(userCreateNS(&opCtx, + ctx.db(), + nss.ns(), + BSONObj(), + CollectionOptions::parseForCommand, + defaultIndexes)); insertRecord(&opCtx, nss, oldDoc); uow.commit(); } @@ -361,7 +384,12 @@ public: WriteUnitOfWork uow(&opCtx); ASSERT_OK(ctx.db()->dropCollection(&opCtx, nss.ns())); ASSERT(!collectionExists(&ctx, nss.ns())); - ASSERT_OK(userCreateNS(&opCtx, ctx.db(), nss.ns(), BSONObj(), defaultIndexes)); + ASSERT_OK(userCreateNS(&opCtx, + ctx.db(), + nss.ns(), + BSONObj(), + CollectionOptions::parseForCommand, + defaultIndexes)); ASSERT(collectionExists(&ctx, nss.ns())); insertRecord(&opCtx, nss, newDoc); assertOnlyRecord(&opCtx, nss, newDoc); @@ -398,7 +426,12 @@ public: { WriteUnitOfWork uow(&opCtx); - ASSERT_OK(userCreateNS(&opCtx, ctx.db(), nss.ns(), BSONObj(), defaultIndexes)); + ASSERT_OK(userCreateNS(&opCtx, + ctx.db(), + nss.ns(), + BSONObj(), + CollectionOptions::parseForCommand, + defaultIndexes)); ASSERT(collectionExists(&ctx, nss.ns())); insertRecord(&opCtx, nss, doc); assertOnlyRecord(&opCtx, nss, doc); @@ -434,7 +467,12 @@ public: { WriteUnitOfWork uow(&opCtx); - ASSERT_OK(userCreateNS(&opCtx, ctx.db(), nss.ns(), BSONObj(), defaultIndexes)); + ASSERT_OK(userCreateNS(&opCtx, + ctx.db(), + nss.ns(), + BSONObj(), + CollectionOptions::parseForCommand, + defaultIndexes)); ASSERT(collectionExists(&ctx, nss.ns())); insertRecord(&opCtx, nss, doc); assertOnlyRecord(&opCtx, nss, doc); @@ -698,7 +736,8 @@ public: { WriteUnitOfWork uow(&opCtx); ASSERT(!collectionExists(&ctx, nss.ns())); - ASSERT_OK(userCreateNS(&opCtx, ctx.db(), nss.ns(), BSONObj(), false)); + ASSERT_OK(userCreateNS( + &opCtx, ctx.db(), nss.ns(), BSONObj(), CollectionOptions::parseForCommand, false)); ASSERT(collectionExists(&ctx, nss.ns())); Collection* coll = ctx.db()->getCollection(ns); IndexCatalog* catalog = coll->getIndexCatalog(); -- cgit v1.2.1