SERVER-65530 Get rid of the legacy ChunkVersion format (except for moveChunk)

8 files changed, 45 insertions, 236 deletions

diff --git a/jstests/sharding/version1.js b/jstests/sharding/version1.js
index 7ec746537d4..dfe9a733156 100644
--- a/jstests/sharding/version1.js
+++ b/jstests/sharding/version1.js
@@ -26,7 +26,7 @@ assert.commandFailed(
 assert.commandFailed(a.runCommand({
     setShardVersion: "alleyinsider.foo",
     configdb: s._configDB,
-    version: new Timestamp(2, 0),
+    version: {e: epoch, t: timestamp, v: new Timestamp(2, 0)},
     authoritative: true
 }),
                      "should have failed because first setShardVersion needs shard info");
@@ -34,7 +34,7 @@ assert.commandFailed(a.runCommand({
 assert.commandFailed(a.runCommand({
     setShardVersion: "alleyinsider.foo",
     configdb: s._configDB,
-    version: new Timestamp(2, 0),
+    version: {e: epoch, t: timestamp, v: new Timestamp(2, 0)},
     authoritative: true,
     shard: "s.shard0.shardName",
     shardHost: s.s.host
@@ -46,9 +46,7 @@ var timestamp = s.getDB('config').collections.findOne({_id: "alleyinsider.foo"})
 assert.commandWorked(a.runCommand({
     setShardVersion: "alleyinsider.foo",
     configdb: s._configDB,
-    version: new Timestamp(1, 0),
-    versionEpoch: epoch,
-    versionTimestamp: timestamp,
+    version: {e: epoch, t: timestamp, v: new Timestamp(1, 0)},
     authoritative: true,
     shard: s.shard0.shardName,
     shardHost: s.s.host
@@ -58,35 +56,20 @@ assert.commandWorked(a.runCommand({
 assert.commandFailed(a.runCommand({
     setShardVersion: "alleyinsider.foo",
     configdb: "a",
-    version: new Timestamp(0, 2),
-    versionEpoch: epoch,
-    versionTimestamp: timestamp
+    version: {e: epoch, t: timestamp, v: new Timestamp(0, 2)},
 }));
 
 assert.commandFailed(a.runCommand({
     setShardVersion: "alleyinsider.foo",
     configdb: s._configDB,
-    version: new Timestamp(0, 2),
-    versionEpoch: epoch,
-    versionTimestamp: timestamp
+    version: {e: epoch, t: timestamp, v: new Timestamp(0, 2)},
 }));
 
 assert.commandFailed(a.runCommand({
     setShardVersion: "alleyinsider.foo",
     configdb: s._configDB,
-    version: new Timestamp(0, 1),
-    versionEpoch: epoch,
-    versionTimestamp: timestamp
+    version: {e: epoch, t: timestamp, v: new Timestamp(0, 1)},
 }));
 
-// the only way that setSharVersion passes is if the shard agrees with the version
-// the shard takes its version from config directly
-// TODO bump timestamps in config
-// assert.eq( a.runCommand( { "setShardVersion" : "alleyinsider.foo" , configdb : s._configDB ,
-// version : 3 } ).oldVersion.i , 2 , "oldVersion" );
-
-// assert.eq( a.runCommand( { "getShardVersion" : "alleyinsider.foo" } ).global.i , 3 , "my get
-// version B" );
-
 s.stop();
 })();
diff --git a/jstests/sharding/version2.js b/jstests/sharding/version2.js
index c52169053c5..80e00dd74db 100644
--- a/jstests/sharding/version2.js
+++ b/jstests/sharding/version2.js
@@ -24,9 +24,7 @@ assert.commandWorked(a.runCommand({
     setShardVersion: "alleyinsider.foo",
     configdb: s._configDB,
     authoritative: true,
-    version: new Timestamp(1, 0),
-    versionEpoch: fooEpoch,
-    versionTimestamp: fooTimestamp,
+    version: {e: fooEpoch, t: fooTimestamp, v: new Timestamp(1, 0)},
     shard: s.shard0.shardName,
     shardHost: s.s.host,
 }));
diff --git a/src/mongo/db/s/set_shard_version_command.cpp b/src/mongo/db/s/set_shard_version_command.cpp
index 006850f9e1c..0c8e2da5037 100644
--- a/src/mongo/db/s/set_shard_version_command.cpp
+++ b/src/mongo/db/s/set_shard_version_command.cpp
@@ -128,8 +128,7 @@ public:
                 nss.isValid());
 
         // Validate chunk version parameter.
-        const ChunkVersion requestedVersion =
-            ChunkVersion::fromBSONLegacyOrNewerFormat(cmdObj, SetShardVersionRequest::kVersion);
+        auto requestedVersion = ChunkVersion::parse(cmdObj[SetShardVersionRequest::kVersion]);
 
         // Step 3
 
diff --git a/src/mongo/s/chunk_version_test.cpp b/src/mongo/s/chunk_version_test.cpp
index 3962588b52b..f735bfd7ef0 100644
--- a/src/mongo/s/chunk_version_test.cpp
+++ b/src/mongo/s/chunk_version_test.cpp
@@ -36,154 +36,6 @@
 namespace mongo {
 namespace {
 
-TEST(ChunkVersionTest, Parsing60Format) {
-    const Timestamp majorMinor = Timestamp(Seconds(1), 2);
-    const OID epoch = OID::gen();
-    const Timestamp timestamp(42);
-
-    ChunkVersion chunkVersion(1, 2, epoch, timestamp);
-    // Check future format in fromBSONLegacyOrNewerFormat.
-    ChunkVersion futureFormatChunkVersion = ChunkVersion::fromBSONLegacyOrNewerFormat(
-        BSON("chunkVersion" << BSON(ChunkVersion60Format::kVersionFieldName
-                                    << majorMinor << ChunkVersion60Format::kEpochFieldName << epoch
-                                    << ChunkVersion60Format::kTimestampFieldName << timestamp)),
-        "chunkVersion");
-
-    ASSERT_EQ(1, futureFormatChunkVersion.majorVersion());
-    ASSERT_EQ(2, futureFormatChunkVersion.minorVersion());
-    ASSERT_EQ(epoch, futureFormatChunkVersion.epoch());
-    ASSERT_EQ(timestamp, futureFormatChunkVersion.getTimestamp());
-
-    // Check future format in fromBSONPositionalOrNewerFormat.
-    ChunkVersion futureFormatChunkVersion2 = ChunkVersion::fromBSONPositionalOrNewerFormat(
-        BSON("chunkVersion" << BSON(ChunkVersion60Format::kVersionFieldName
-                                    << majorMinor << ChunkVersion60Format::kEpochFieldName << epoch
-                                    << ChunkVersion60Format::kTimestampFieldName
-                                    << timestamp))["chunkVersion"]);
-
-    ASSERT_EQ(1, futureFormatChunkVersion2.majorVersion());
-    ASSERT_EQ(2, futureFormatChunkVersion2.minorVersion());
-    ASSERT_EQ(epoch, futureFormatChunkVersion2.epoch());
-    ASSERT_EQ(timestamp, futureFormatChunkVersion2.getTimestamp());
-}
-
-TEST(ChunkVersionTest, ToFromBSONRoundtrip) {
-    ChunkVersion version(1, 2, OID::gen(), Timestamp(42));
-    const auto roundTripVersion = ChunkVersion::fromBSONPositionalOrNewerFormat([&] {
-        BSONObjBuilder builder;
-        version.serializeToBSON("testVersionField", &builder);
-        return builder.obj();
-    }()["testVersionField"]);
-
-    ASSERT_EQ(version, roundTripVersion);
-}
-
-TEST(ChunkVersionTest, ToFromBSONLegacyRoundtrip) {
-    ChunkVersion version(1, 2, OID::gen(), Timestamp(42));
-    const auto roundTripVersion = ChunkVersion::fromBSONLegacyOrNewerFormat(
-        [&] {
-            BSONObjBuilder builder;
-            version.appendLegacyWithField(&builder, "testVersionField");
-            return builder.obj();
-        }(),
-        "testVersionField");
-
-    ASSERT_EQ(version, roundTripVersion);
-}
-
-TEST(ChunkVersionTest, FromBSONMissingTimestamp) {
-    ASSERT_THROWS_CODE(ChunkVersion::fromBSONPositionalOrNewerFormat(
-                           BSON("testVersionField" << BSON_ARRAY(
-                                    Timestamp(Seconds(2), 3) << OID::gen()))["testVersionField"]),
-                       DBException,
-                       ErrorCodes::TypeMismatch);
-}
-
-TEST(ChunkVersionTest, FromBSON) {
-    const OID oid = OID::gen();
-    const Timestamp timestamp(42);
-    ChunkVersion chunkVersionComplete = ChunkVersion::fromBSONPositionalOrNewerFormat(
-        BSON("testVersionField" << BSON_ARRAY(Timestamp(Seconds(2), 3)
-                                              << oid << timestamp))["testVersionField"]);
-
-    ASSERT(chunkVersionComplete.epoch().isSet());
-    ASSERT_EQ(oid, chunkVersionComplete.epoch());
-    ASSERT_EQ(2u, chunkVersionComplete.majorVersion());
-    ASSERT_EQ(3u, chunkVersionComplete.minorVersion());
-    ASSERT_EQ(timestamp, chunkVersionComplete.getTimestamp());
-}
-
-TEST(ChunkVersionTest, FromBSONMissingEpoch) {
-    ASSERT_THROWS_CODE(
-        ChunkVersion::fromBSONPositionalOrNewerFormat(
-            BSON("testVersionField" << BSON_ARRAY(Timestamp(Seconds(2), 3)))["testVersionField"]),
-        DBException,
-        ErrorCodes::TypeMismatch);
-}
-
-TEST(ChunkVersionTest, FromBSONMissingMajorAndMinor) {
-    ASSERT_THROWS_CODE(ChunkVersion::fromBSONPositionalOrNewerFormat(
-                           BSON("testVersionField" << BSON_ARRAY(OID::gen()))["testVersionField"]),
-                       DBException,
-                       ErrorCodes::TypeMismatch);
-}
-
-TEST(ChunkVersionTest, FromBSONLegacy_WithTimestamp_WithEpoch) {
-    const OID oid = OID::gen();
-    ChunkVersion chunkVersionComplete = ChunkVersion::fromBSONLegacyOrNewerFormat(
-        BSON("lastmod" << Timestamp(Seconds(2), 3) << "lastmodEpoch" << oid << "lastmodTimestamp"
-                       << Timestamp(42)),
-        "lastmod");
-    ASSERT_EQ(Timestamp(42), chunkVersionComplete.getTimestamp());
-    ASSERT_EQ(oid, chunkVersionComplete.epoch());
-    ASSERT_EQ(2u, chunkVersionComplete.majorVersion());
-    ASSERT_EQ(3u, chunkVersionComplete.minorVersion());
-}
-
-TEST(ChunkVersionTest, FromBSONLegacy_NoTimestamp_WithUnshardedEpoch) {
-    ChunkVersion chunkVersion = ChunkVersion::fromBSONLegacyOrNewerFormat(
-        BSON("lastmod" << Timestamp() << "lastmodEpoch" << ChunkVersion::UNSHARDED().epoch()),
-        "lastmod");
-    ASSERT_EQ(ChunkVersion::UNSHARDED().getTimestamp(), chunkVersion.getTimestamp());
-    ASSERT_EQ(ChunkVersion::UNSHARDED().epoch(), chunkVersion.epoch());
-    ASSERT_EQ(0u, chunkVersion.majorVersion());
-    ASSERT_EQ(0u, chunkVersion.minorVersion());
-}
-
-TEST(ChunkVersionTest, FromBSONLegacy_NoTimestamp_WithIgnoredEpoch) {
-    ChunkVersion chunkVersion = ChunkVersion::fromBSONLegacyOrNewerFormat(
-        BSON("lastmod" << Timestamp() << "lastmodEpoch" << ChunkVersion::IGNORED().epoch()),
-        "lastmod");
-    ASSERT_EQ(ChunkVersion::IGNORED().getTimestamp(), chunkVersion.getTimestamp());
-    ASSERT_EQ(ChunkVersion::IGNORED().epoch(), chunkVersion.epoch());
-    ASSERT_EQ(0u, chunkVersion.majorVersion());
-    ASSERT_EQ(0u, chunkVersion.minorVersion());
-}
-
-TEST(ChunkVersionTest, FromBSONLegacy_NoTimestamp_WithShardedEpoch_Throws) {
-    ASSERT_THROWS(
-        ChunkVersion::fromBSONLegacyOrNewerFormat(
-            BSON("lastmod" << Timestamp(Seconds(3), 4) << "lastmodEpoch" << OID::gen()), "lastmod"),
-        DBException);
-}
-
-TEST(ChunkVersionTest, FromBSONLegacy_WithTimestamp_NoEpoch_Throws) {
-    ASSERT_THROWS(
-        ChunkVersion::fromBSONLegacyOrNewerFormat(
-            BSON("lastmod" << Timestamp(Seconds(3), 4) << "lastmodTimestamp" << Timestamp(42)),
-            "lastmod"),
-        DBException);
-}
-
-TEST(ChunkVersionTest, FromBSONLegacy_NoTimestamp_NoEpoch_Throws) {
-    ChunkVersion chunkVersion = ChunkVersion::fromBSONLegacyOrNewerFormat(
-        BSON("lastmod" << Timestamp(Seconds(3), 4)), "lastmod");
-    ASSERT_EQ(Timestamp(), chunkVersion.getTimestamp());
-    ASSERT(!chunkVersion.epoch().isSet());
-    ASSERT_EQ(3u, chunkVersion.majorVersion());
-    ASSERT_EQ(4u, chunkVersion.minorVersion());
-}
-
 TEST(ChunkVersionTest, EqualityOperators) {
     OID epoch = OID::gen();
     Timestamp timestamp = Timestamp(1);
diff --git a/src/mongo/s/request_types/commit_chunk_migration_request_type.cpp b/src/mongo/s/request_types/commit_chunk_migration_request_type.cpp
index 48ade6db9e8..00c2f90f65b 100644
--- a/src/mongo/s/request_types/commit_chunk_migration_request_type.cpp
+++ b/src/mongo/s/request_types/commit_chunk_migration_request_type.cpp
@@ -60,7 +60,7 @@ StatusWith<ChunkType> extractChunk(const BSONObj& source, StringData field) {
 
     ChunkVersion version;
     try {
-        version = ChunkVersion::fromBSONLegacyOrNewerFormat(fieldObj, ChunkType::lastmod());
+        version = ChunkVersion::parse(fieldObj[ChunkType::lastmod()]);
         uassert(644490, "Version must be set", version.isSet());
     } catch (const DBException& ex) {
         return ex.toStatus();
diff --git a/src/mongo/s/request_types/set_shard_version_request.cpp b/src/mongo/s/request_types/set_shard_version_request.cpp
index d6b7a463129..f342c5c8da7 100644
--- a/src/mongo/s/request_types/set_shard_version_request.cpp
+++ b/src/mongo/s/request_types/set_shard_version_request.cpp
@@ -97,7 +97,7 @@ StatusWith<SetShardVersionRequest> SetShardVersionRequest::parseFromBSON(const B
 
     {
         try {
-            request._version = ChunkVersion::fromBSONLegacyOrNewerFormat(cmdObj, kVersion);
+            request._version = ChunkVersion::parse(cmdObj[kVersion]);
         } catch (const DBException& ex) {
             return ex.toStatus();
         }
diff --git a/src/mongo/s/request_types/set_shard_version_request_test.cpp b/src/mongo/s/request_types/set_shard_version_request_test.cpp
index a689e804001..59ece1174cf 100644
--- a/src/mongo/s/request_types/set_shard_version_request_test.cpp
+++ b/src/mongo/s/request_types/set_shard_version_request_test.cpp
@@ -42,28 +42,10 @@ using unittest::assertGet;
 TEST(SetShardVersionRequestTest, ParseFull) {
     const ChunkVersion chunkVersion(1, 2, OID::gen(), Timestamp(1, 1));
 
-    SetShardVersionRequest request =
-        assertGet(SetShardVersionRequest::parseFromBSON(
-            BSON("setShardVersion"
-                 << "db.coll"
-                 << "version" << Timestamp(chunkVersion.toLong()) << "versionEpoch"
-                 << chunkVersion.epoch() << "versionTimestamp" << chunkVersion.getTimestamp())));
-
-    ASSERT(!request.shouldForceRefresh());
-    ASSERT(!request.isAuthoritative());
-    ASSERT_EQ(request.getNS().toString(), "db.coll");
-    ASSERT_EQ(request.getNSVersion().majorVersion(), chunkVersion.majorVersion());
-    ASSERT_EQ(request.getNSVersion().minorVersion(), chunkVersion.minorVersion());
-    ASSERT_EQ(request.getNSVersion().epoch(), chunkVersion.epoch());
-}
-
-TEST(SetShardVersionRequestTest, ParseFullNewFormat) {
-    const ChunkVersion chunkVersion(1, 2, OID::gen(), Timestamp(1, 1));
-
     SetShardVersionRequest request = assertGet(SetShardVersionRequest::parseFromBSON([&] {
         BSONObjBuilder builder(BSON("setShardVersion"
                                     << "db.coll"));
-        chunkVersion.appendLegacyWithField(&builder, "version");
+        chunkVersion.serializeToBSON("version", &builder);
         return builder.obj();
     }()));
 
@@ -78,13 +60,13 @@ TEST(SetShardVersionRequestTest, ParseFullNewFormat) {
 TEST(SetShardVersionRequestTest, ParseFullWithAuthoritative) {
     const ChunkVersion chunkVersion(1, 2, OID::gen(), Timestamp(1, 1));
 
-    SetShardVersionRequest request =
-        assertGet(SetShardVersionRequest::parseFromBSON(
-            BSON("setShardVersion"
-                 << "db.coll"
-                 << "version" << Timestamp(chunkVersion.toLong()) << "versionEpoch"
-                 << chunkVersion.epoch() << "versionTimestamp" << chunkVersion.getTimestamp()
-                 << "authoritative" << true)));
+    SetShardVersionRequest request = assertGet(SetShardVersionRequest::parseFromBSON([&] {
+        BSONObjBuilder builder(BSON("setShardVersion"
+                                    << "db.coll"
+                                    << "authoritative" << true));
+        chunkVersion.serializeToBSON("version", &builder);
+        return builder.obj();
+    }()));
 
     ASSERT(!request.shouldForceRefresh());
     ASSERT(request.isAuthoritative());
@@ -97,11 +79,13 @@ TEST(SetShardVersionRequestTest, ParseFullWithAuthoritative) {
 TEST(SetShardVersionRequestTest, ParseFullNoNS) {
     const ChunkVersion chunkVersion(1, 2, OID::gen(), Timestamp(1, 1));
 
-    auto ssvStatus =
-        SetShardVersionRequest::parseFromBSON(BSON("setShardVersion"
-                                                   << ""
-                                                   << "version" << Timestamp(chunkVersion.toLong())
-                                                   << "versionEpoch" << chunkVersion.epoch()));
+    auto ssvStatus = SetShardVersionRequest::parseFromBSON([&] {
+        BSONObjBuilder builder(BSON("setShardVersion"
+                                    << ""
+                                    << "authoritative" << true));
+        chunkVersion.serializeToBSON("version", &builder);
+        return builder.obj();
+    }());
 
     ASSERT_EQ(ErrorCodes::InvalidNamespace, ssvStatus.getStatus().code());
 }
@@ -109,11 +93,13 @@ TEST(SetShardVersionRequestTest, ParseFullNoNS) {
 TEST(SetShardVersionRequestTest, ParseFullNSContainsDBOnly) {
     const ChunkVersion chunkVersion(1, 2, OID::gen(), Timestamp(1, 1));
 
-    auto ssvStatus =
-        SetShardVersionRequest::parseFromBSON(BSON("setShardVersion"
-                                                   << "dbOnly"
-                                                   << "version" << Timestamp(chunkVersion.toLong())
-                                                   << "versionEpoch" << chunkVersion.epoch()));
+    auto ssvStatus = SetShardVersionRequest::parseFromBSON([&] {
+        BSONObjBuilder builder(BSON("setShardVersion"
+                                    << "DBOnly"
+                                    << "authoritative" << true));
+        chunkVersion.serializeToBSON("version", &builder);
+        return builder.obj();
+    }());
 
     ASSERT_EQ(ErrorCodes::InvalidNamespace, ssvStatus.getStatus().code());
 }
diff --git a/src/mongo/s/stale_exception.cpp b/src/mongo/s/stale_exception.cpp
index ac026a45ea2..c88504b7df4 100644
--- a/src/mongo/s/stale_exception.cpp
+++ b/src/mongo/s/stale_exception.cpp
@@ -43,36 +43,27 @@ MONGO_INIT_REGISTER_ERROR_EXTRA_INFO(StaleDbRoutingVersion);
 
 void StaleConfigInfo::serialize(BSONObjBuilder* bob) const {
     bob->append("ns", _nss.ns());
-    _received.appendLegacyWithField(bob, "vReceived");
-    if (_wanted) {
-        _wanted->appendLegacyWithField(bob, "vWanted");
-    }
+    _received.serializeToBSON("vReceived", bob);
+    if (_wanted)
+        _wanted->serializeToBSON("vWanted", bob);
 
     invariant(_shardId != "");
     bob->append("shardId", _shardId.toString());
 }
 
 std::shared_ptr<const ErrorExtraInfo> StaleConfigInfo::parse(const BSONObj& obj) {
-    const auto shardId = obj["shardId"].String();
+    auto shardId = obj["shardId"].String();
     uassert(ErrorCodes::NoSuchKey, "The shardId field is missing", !shardId.empty());
 
-    auto extractOptionalChunkVersion = [&obj](StringData field) -> boost::optional<ChunkVersion> {
-        try {
-            return ChunkVersion::fromBSONLegacyOrNewerFormat(obj, field);
-        } catch (const DBException& ex) {
-            auto status = ex.toStatus();
-            if (status != ErrorCodes::NoSuchKey) {
-                throw;
-            }
-        }
-        return boost::none;
-    };
-
-    return std::make_shared<StaleConfigInfo>(
-        NamespaceString(obj["ns"].String()),
-        ChunkVersion::fromBSONLegacyOrNewerFormat(obj, "vReceived"),
-        extractOptionalChunkVersion("vWanted"),
-        ShardId(shardId));
+    return std::make_shared<StaleConfigInfo>(NamespaceString(obj["ns"].String()),
+                                             ChunkVersion::parse(obj["vReceived"]),
+                                             [&] {
+                                                 if (auto vWantedElem = obj["vWanted"])
+                                                     return boost::make_optional(
+                                                         ChunkVersion::parse(vWantedElem));
+                                                 return boost::optional<ChunkVersion>();
+                                             }(),
+                                             ShardId(std::move(shardId)));
 }
 
 void StaleEpochInfo::serialize(BSONObjBuilder* bob) const {