SERVER-41745 Collections with names longer than 120 characters will be gated to FCV v4.4

Author: GWlodarek

jstests/multiVersion/long_collection_names.js

@@ -0,0 +1,124 @@
+/**
+ * Tests the FCV for long collection names.
+ *
+ * On 4.2 and below, the maximum fully qualified collection name is 120 characters or less
+ * (which includes the database name).
+ *
+ * In this multi version test, we ensure that we can create long collection names on the 4.4 binary
+ * while the FCV document is set to 4.4. Restarting with long collection names present on a 4.2
+ * binary should not crash the server. Users would need to manually remove or rename the long
+ * collection names prior to downgrading. Additionally, we should be prevented from creating long
+ * collection names when using FCV 4.2 on a 4.4 binary.
+ */
+(function() {
+'use strict';
+load('jstests/libs/feature_compatibility_version.js');
+
+const dbName = 'test';
+const renameDbName = 'rename_test';
+const shortCollName = 'short_collection';
+const longCollName = 'long_collection' +
+    'a'.repeat(8192);
+const longCollNameRename = 'long_collection' +
+    'b'.repeat(8192);
+
+const dbpath = MongoRunner.dataPath + 'long_collection_names';
+resetDbpath(dbpath);
+
+const mongodOptions42 =
+    Object.extend({binVersion: 'last-stable'}, {dbpath: dbpath, cleanData: false});
+const mongodOptions44 = Object.extend({binVersion: 'latest'}, {dbpath: dbpath, cleanData: false});
+
+/**
+ * Start up with the latest binary and ensure that long collection names can be created while
+ * using FCV 4.4.
+ */
+let conn = MongoRunner.runMongod(mongodOptions44);
+assert.neq(null, conn, 'mongod was unable to start with version ' + tojson(mongodOptions44));
+
+let testDb = conn.getDB(dbName);
+
+assert.commandWorked(testDb.adminCommand({setFeatureCompatibilityVersion: latestFCV}));
+
+// Create two collections, one with a short name and the other with a long name.
+assert.commandWorked(testDb.createCollection(shortCollName));
+assert.commandWorked(testDb.createCollection(longCollName));
+
+// Rename a short collection name to a long collection name within the same database.
+assert.commandWorked(testDb.adminCommand(
+    {renameCollection: dbName + '.' + shortCollName, to: dbName + '.' + longCollNameRename}));
+
+assert.eq(true, testDb.getCollection(longCollNameRename).drop());
+assert.commandWorked(testDb.createCollection(shortCollName));
+
+// Rename a short collection name to a long collection name in a different database.
+assert.commandWorked(testDb.adminCommand(
+    {renameCollection: dbName + '.' + shortCollName, to: renameDbName + '.' + longCollNameRename}));
+
+assert.eq(true, testDb.getSiblingDB(renameDbName).getCollection(longCollNameRename).drop());
+assert.commandWorked(testDb.createCollection(shortCollName));
+
+MongoRunner.stopMongod(conn);
+
+/**
+ * Restarting with a 4.2 binary with FCV 4.4 shouldn't startup nor crash.
+ */
+let restartOpts42 = Object.extend(mongodOptions42, {restart: true});
+conn = MongoRunner.runMongod(restartOpts42);
+assert.eq(null, conn, 'mongod was able to start with version ' + tojson(restartOpts42));
+
+/**
+ * Restart with the 4.4 binary to set the FCV to 4.2.
+ */
+let restartOpts44 = Object.extend(mongodOptions44, {restart: true});
+conn = MongoRunner.runMongod(restartOpts44);
+assert.neq(null, conn, 'mongod was unable to start with version ' + tojson(restartOpts44));
+
+testDb = conn.getDB(dbName);
+assert.commandWorked(testDb.adminCommand({setFeatureCompatibilityVersion: lastStableFCV}));
+MongoRunner.stopMongod(conn);
+
+/**
+ * Restart with the 4.2 binary while in FCV 4.2 with long collection names present. This shouldn't
+ * crash the server.
+ */
+conn = MongoRunner.runMongod(restartOpts42);
+assert.neq(null, conn, 'mongod was unable to start with version ' + tojson(restartOpts42));
+
+testDb = conn.getDB(dbName);
+
+// Ensure we have the proper collections.
+let collNames = testDb.getCollectionNames();
+
+assert.eq(true, collNames.includes(shortCollName));
+assert.eq(true, collNames.includes(longCollName));
+
+MongoRunner.stopMongod(conn);
+
+/**
+ * Restart with the 4.4 binary while in FCV 4.2. We shouldn't be able to create any collections with
+ * long names.
+ */
+conn = MongoRunner.runMongod(restartOpts44);
+assert.neq(null, conn, 'mongod was unable to start with version ' + tojson(restartOpts44));
+
+testDb = conn.getDB(dbName);
+
+// Creating a long collection name on a 4.4 binary with FCV 4.2 should fail.
+assert.commandFailedWithCode(testDb.createCollection('c'.repeat(8192)),
+                             ErrorCodes.IncompatibleServerVersion);
+
+// Running rename within the same database or across two databases should fail for long collection
+// names.
+assert.commandFailedWithCode(
+    testDb.adminCommand(
+        {renameCollection: dbName + '.' + shortCollName, to: dbName + '.' + longCollNameRename}),
+    ErrorCodes.IllegalOperation);
+assert.commandFailedWithCode(testDb.adminCommand({
+    renameCollection: dbName + '.' + shortCollName,
+    to: renameDbName + '.' + longCollNameRename
+}),
+                             ErrorCodes.IllegalOperation);
+
+MongoRunner.stopMongod(conn);
+})();

src/mongo/db/SConscript

@@ -183,6 +183,9 @@ env.Library(
         '$BUILD_DIR/mongo/base',
         '$BUILD_DIR/mongo/db/repl/optime',
     ],
+    LIBDEPS_PRIVATE=[
+        'server_options_core',
+    ],
 )
 
 env.Library(

src/mongo/db/catalog/database_impl.cpp

@@ -50,6 +50,7 @@
 #include "mongo/db/catalog/drop_indexes.h"
 #include "mongo/db/catalog/index_catalog.h"
 #include "mongo/db/clientcursor.h"
+#include "mongo/db/commands/feature_compatibility_version_parser.h"
 #include "mongo/db/concurrency/d_concurrency.h"
 #include "mongo/db/concurrency/write_conflict_exception.h"
 #include "mongo/db/curop.h"
@@ -559,6 +560,13 @@ void DatabaseImpl::_checkCanCreateCollection(OperationContext* opCtx,
             str::stream() << "Cannot create collection " << nss
                           << " - database is in the process of being dropped.",
             !_dropPending.load());
+
+    uassert(ErrorCodes::IncompatibleServerVersion,
+            str::stream() << "Cannot create collection with a long name " << nss
+                          << " - upgrade to feature compatibility version "
+                          << FeatureCompatibilityVersionParser::kVersion44
+                          << " to be able to do so.",
+            nss.checkLengthForFCV());
 }
 
 Status DatabaseImpl::createView(OperationContext* opCtx,

src/mongo/db/namespace_string.cpp

@@ -34,6 +34,7 @@
 #include <ostream>
 
 #include "mongo/base/parse_number.h"
+#include "mongo/db/server_options.h"
 #include "mongo/util/str.h"
 
 namespace mongo {
@@ -141,6 +142,25 @@ bool NamespaceString::isDropPendingNamespace() const {
     return coll().startsWith(dropPendingNSPrefix);
 }
 
+bool NamespaceString::checkLengthForFCV() const {
+    // Prior to longer collection names, the limit in older versions was 120 characters.
+    const size_t previousMaxNSLength = 120U;
+    if (size() <= previousMaxNSLength) {
+        return true;
+    }
+
+    if (!serverGlobalParams.featureCompatibility.isVersionInitialized()) {
+        return false;
+    }
+
+    if (serverGlobalParams.featureCompatibility.getVersion() ==
+        ServerGlobalParams::FeatureCompatibility::Version::kFullyUpgradedTo44) {
+        return true;
+    }
+
+    return false;
+}
+
 NamespaceString NamespaceString::makeDropPendingNamespace(const repl::OpTime& opTime) const {
     StringBuilder ss;
     ss << db() << "." << dropPendingNSPrefix;

src/mongo/db/namespace_string.h

@@ -283,6 +283,11 @@ class NamespaceString {
      */
     bool isDropPendingNamespace() const;
 
+    /**
+     * Returns true if the namespace length is valid based on the FCV setting.
+     */
+    bool checkLengthForFCV() const;
+
     /**
      * Returns the drop-pending namespace name for this namespace, provided the given optime.
      *

src/mongo/db/ops/insert.cpp

@@ -33,6 +33,7 @@
 #include <vector>
 
 #include "mongo/bson/bson_depth.h"
+#include "mongo/db/commands/feature_compatibility_version_parser.h"
 #include "mongo/db/logical_clock.h"
 #include "mongo/db/logical_time.h"
 #include "mongo/db/views/durable_view_catalog.h"
@@ -202,7 +203,14 @@ Status userAllowedCreateNS(StringData db, StringData coll) {
     if (!NamespaceString::validCollectionName(coll))
         return Status(ErrorCodes::InvalidNamespace, "invalid collection name");
 
-    // check spceial areas
+    if (!NamespaceString(db, coll).checkLengthForFCV())
+        return Status(ErrorCodes::IncompatibleServerVersion,
+                      str::stream() << "Cannot create collection with a long name " << db << "."
+                                    << coll << " - upgrade to feature compatibility version "
+                                    << FeatureCompatibilityVersionParser::kVersion44
+                                    << " to be able to do so.");
+
+    // check special areas
 
     if (db == "system")
         return Status(ErrorCodes::InvalidNamespace, "cannot use 'system' database");