SERVER-36815 Remove references to oplog entry's hash field

1 files changed, 40 insertions, 151 deletions

diff --git a/src/mongo/db/repl/roll_back_local_operations_test.cpp b/src/mongo/db/repl/roll_back_local_operations_test.cpp
index 9ec88d7cf93..0a7d53702d1 100644
--- a/src/mongo/db/repl/roll_back_local_operations_test.cpp
+++ b/src/mongo/db/repl/roll_back_local_operations_test.cpp
@@ -47,9 +47,9 @@ namespace {
 using namespace mongo;
 using namespace mongo::repl;
 
-BSONObj makeOp(long long seconds, long long hash) {
+BSONObj makeOp(long long seconds, long long term = 1LL) {
     auto uuid = unittest::assertGet(UUID::parse("b4c66a44-c1ca-4d86-8d25-12e82fa2de5b"));
-    return BSON("ts" << Timestamp(seconds, seconds) << "h" << hash << "t" << seconds << "op"
+    return BSON("ts" << Timestamp(seconds, seconds) << "t" << term << "op"
                      << "n"
                      << "o"
                      << BSONObj()
@@ -60,8 +60,8 @@ BSONObj makeOp(long long seconds, long long hash) {
 }
 
 int recordId = 0;
-OplogInterfaceMock::Operation makeOpAndRecordId(long long seconds, long long hash) {
-    return std::make_pair(makeOp(seconds, hash), RecordId(++recordId));
+OplogInterfaceMock::Operation makeOpAndRecordId(long long seconds, long long term = 1LL) {
+    return std::make_pair(makeOp(seconds), RecordId(++recordId));
 }
 
 TEST(RollBackLocalOperationsTest, InvalidLocalOplogIterator) {
@@ -84,7 +84,7 @@ TEST(RollBackLocalOperationsTest, InvalidLocalOplogIterator) {
 }
 
 TEST(RollBackLocalOperationsTest, InvalidRollbackOperationFunction) {
-    ASSERT_THROWS_CODE(RollBackLocalOperations(OplogInterfaceMock({makeOpAndRecordId(1, 0)}),
+    ASSERT_THROWS_CODE(RollBackLocalOperations(OplogInterfaceMock({makeOpAndRecordId(1)}),
                                                RollBackLocalOperations::RollbackOperationFn()),
                        AssertionException,
                        ErrorCodes::BadValue);
@@ -93,17 +93,17 @@ TEST(RollBackLocalOperationsTest, InvalidRollbackOperationFunction) {
 TEST(RollBackLocalOperationsTest, EmptyLocalOplog) {
     OplogInterfaceMock localOplog;
     RollBackLocalOperations finder(localOplog, [](const BSONObj&) { return Status::OK(); });
-    auto result = finder.onRemoteOperation(makeOp(1, 0));
+    auto result = finder.onRemoteOperation(makeOp(1));
     ASSERT_EQUALS(ErrorCodes::OplogStartMissing, result.getStatus().code());
 }
 
 TEST(RollBackLocalOperationsTest, RollbackMultipleLocalOperations) {
-    auto commonOperation = makeOpAndRecordId(1, 1);
+    auto commonOperation = makeOpAndRecordId(1);
     OplogInterfaceMock::Operations localOperations({
-        makeOpAndRecordId(5, 1),
-        makeOpAndRecordId(4, 1),
-        makeOpAndRecordId(3, 1),
-        makeOpAndRecordId(2, 1),
+        makeOpAndRecordId(5),
+        makeOpAndRecordId(4),
+        makeOpAndRecordId(3),
+        makeOpAndRecordId(2),
         commonOperation,
     });
     OplogInterfaceMock localOplog(localOperations);
@@ -126,9 +126,9 @@ TEST(RollBackLocalOperationsTest, RollbackMultipleLocalOperations) {
 }
 
 TEST(RollBackLocalOperationsTest, RollbackOperationFailed) {
-    auto commonOperation = makeOpAndRecordId(1, 1);
+    auto commonOperation = makeOpAndRecordId(1);
     OplogInterfaceMock::Operations localOperations({
-        makeOpAndRecordId(2, 1), commonOperation,
+        makeOpAndRecordId(2), commonOperation,
     });
     OplogInterfaceMock localOplog(localOperations);
     auto rollbackOperation = [&](const BSONObj& operation) {
@@ -140,9 +140,9 @@ TEST(RollBackLocalOperationsTest, RollbackOperationFailed) {
 }
 
 TEST(RollBackLocalOperationsTest, EndOfLocalOplog) {
-    auto commonOperation = makeOpAndRecordId(1, 1);
+    auto commonOperation = makeOpAndRecordId(1);
     OplogInterfaceMock::Operations localOperations({
-        makeOpAndRecordId(2, 1),
+        makeOpAndRecordId(2),
     });
     OplogInterfaceMock localOplog(localOperations);
     RollBackLocalOperations finder(localOplog, [](const BSONObj&) { return Status::OK(); });
@@ -151,9 +151,9 @@ TEST(RollBackLocalOperationsTest, EndOfLocalOplog) {
 }
 
 TEST(RollBackLocalOperationsTest, SkipRemoteOperations) {
-    auto commonOperation = makeOpAndRecordId(1, 1);
+    auto commonOperation = makeOpAndRecordId(1);
     OplogInterfaceMock::Operations localOperations({
-        makeOpAndRecordId(5, 1), makeOpAndRecordId(4, 1), makeOpAndRecordId(2, 1), commonOperation,
+        makeOpAndRecordId(5), makeOpAndRecordId(4), makeOpAndRecordId(2), commonOperation,
     });
     OplogInterfaceMock localOplog(localOperations);
     auto i = localOperations.cbegin();
@@ -164,46 +164,12 @@ TEST(RollBackLocalOperationsTest, SkipRemoteOperations) {
     };
     RollBackLocalOperations finder(localOplog, rollbackOperation);
     {
-        auto result = finder.onRemoteOperation(makeOp(6, 1));
+        auto result = finder.onRemoteOperation(makeOp(6));
         ASSERT_EQUALS(ErrorCodes::NoSuchKey, result.getStatus().code());
         ASSERT_TRUE(i == localOperations.cbegin());
     }
     {
-        auto result = finder.onRemoteOperation(makeOp(3, 1));
-        ASSERT_EQUALS(ErrorCodes::NoSuchKey, result.getStatus().code());
-        ASSERT_TRUE(std::distance(localOperations.cbegin(), i) == 2);
-    }
-    auto result = finder.onRemoteOperation(commonOperation.first);
-    ASSERT_OK(result.getStatus());
-    ASSERT_EQUALS(OpTime::parseFromOplogEntry(commonOperation.first),
-                  result.getValue().getOpTime());
-    ASSERT_EQUALS(commonOperation.second, result.getValue().getRecordId());
-    ASSERT_FALSE(i == localOperations.cend());
-    ASSERT_BSONOBJ_EQ(commonOperation.first, i->first);
-    i++;
-    ASSERT_TRUE(i == localOperations.cend());
-}
-
-TEST(RollBackLocalOperationsTest, SameTimestampDifferentHashess) {
-    auto commonOperation = makeOpAndRecordId(1, 1);
-    OplogInterfaceMock::Operations localOperations({
-        makeOpAndRecordId(1, 5), makeOpAndRecordId(1, 3), commonOperation,
-    });
-    OplogInterfaceMock localOplog(localOperations);
-    auto i = localOperations.cbegin();
-    auto rollbackOperation = [&](const BSONObj& operation) {
-        ASSERT_BSONOBJ_EQ(i->first, operation);
-        i++;
-        return Status::OK();
-    };
-    RollBackLocalOperations finder(localOplog, rollbackOperation);
-    {
-        auto result = finder.onRemoteOperation(makeOp(1, 4));
-        ASSERT_EQUALS(ErrorCodes::NoSuchKey, result.getStatus().code());
-        ASSERT_TRUE(std::distance(localOperations.cbegin(), i) == 1);
-    }
-    {
-        auto result = finder.onRemoteOperation(makeOp(1, 2));
+        auto result = finder.onRemoteOperation(makeOp(3));
         ASSERT_EQUALS(ErrorCodes::NoSuchKey, result.getStatus().code());
         ASSERT_TRUE(std::distance(localOperations.cbegin(), i) == 2);
     }
@@ -218,34 +184,24 @@ TEST(RollBackLocalOperationsTest, SameTimestampDifferentHashess) {
     ASSERT_TRUE(i == localOperations.cend());
 }
 
-TEST(RollBackLocalOperationsTest, SameTimestampDifferentHashesRollbackOperationFailed) {
+TEST(RollBackLocalOperationsTest, SameTimestampDifferentTermsRollbackNoSuchKey) {
     auto commonOperation = makeOpAndRecordId(1, 1);
     OplogInterfaceMock::Operations localOperations({
-        makeOpAndRecordId(1, 3), commonOperation,
+        makeOpAndRecordId(2, 3), commonOperation,
     });
     OplogInterfaceMock localOplog(localOperations);
     auto rollbackOperation = [&](const BSONObj& operation) {
         return Status(ErrorCodes::OperationFailed, "");
     };
     RollBackLocalOperations finder(localOplog, rollbackOperation);
-    auto result = finder.onRemoteOperation(makeOp(1, 2));
-    ASSERT_EQUALS(ErrorCodes::OperationFailed, result.getStatus().code());
-}
-
-TEST(RollBackLocalOperationsTest, SameTimestampDifferentHashesEndOfLocalOplog) {
-    OplogInterfaceMock::Operations localOperations({
-        makeOpAndRecordId(1, 3),
-    });
-    OplogInterfaceMock localOplog(localOperations);
-    RollBackLocalOperations finder(localOplog, [](const BSONObj&) { return Status::OK(); });
-    auto result = finder.onRemoteOperation(makeOp(1, 2));
-    ASSERT_EQUALS(ErrorCodes::NoMatchingDocument, result.getStatus().code());
+    auto result = finder.onRemoteOperation(makeOp(2, 2));
+    ASSERT_EQUALS(ErrorCodes::NoSuchKey, result.getStatus().code());
 }
 
 TEST(SyncRollBackLocalOperationsTest, OplogStartMissing) {
     ASSERT_EQUALS(ErrorCodes::OplogStartMissing,
                   syncRollBackLocalOperations(OplogInterfaceMock(),
-                                              OplogInterfaceMock({makeOpAndRecordId(1, 0)}),
+                                              OplogInterfaceMock({makeOpAndRecordId(1)}),
                                               [](const BSONObj&) { return Status::OK(); })
                       .getStatus()
                       .code());
@@ -253,7 +209,7 @@ TEST(SyncRollBackLocalOperationsTest, OplogStartMissing) {
 
 TEST(SyncRollBackLocalOperationsTest, RemoteOplogMissing) {
     ASSERT_EQUALS(ErrorCodes::InvalidSyncSource,
-                  syncRollBackLocalOperations(OplogInterfaceMock({makeOpAndRecordId(1, 0)}),
+                  syncRollBackLocalOperations(OplogInterfaceMock({makeOpAndRecordId(1)}),
                                               OplogInterfaceMock(),
                                               [](const BSONObj&) { return Status::OK(); })
                       .getStatus()
@@ -261,9 +217,9 @@ TEST(SyncRollBackLocalOperationsTest, RemoteOplogMissing) {
 }
 
 TEST(SyncRollBackLocalOperationsTest, RollbackTwoOperations) {
-    auto commonOperation = makeOpAndRecordId(1, 1);
+    auto commonOperation = makeOpAndRecordId(1);
     OplogInterfaceMock::Operations localOperations({
-        makeOpAndRecordId(3, 1), makeOpAndRecordId(2, 1), commonOperation,
+        makeOpAndRecordId(3), makeOpAndRecordId(2), commonOperation,
     });
     auto i = localOperations.cbegin();
     auto result = syncRollBackLocalOperations(OplogInterfaceMock(localOperations),
@@ -284,8 +240,8 @@ TEST(SyncRollBackLocalOperationsTest, RollbackTwoOperations) {
 }
 
 TEST(SyncRollBackLocalOperationsTest, SkipOneRemoteOperation) {
-    auto commonOperation = makeOpAndRecordId(1, 1);
-    auto remoteOperation = makeOpAndRecordId(2, 1);
+    auto commonOperation = makeOpAndRecordId(1);
+    auto remoteOperation = makeOpAndRecordId(2);
     auto result =
         syncRollBackLocalOperations(OplogInterfaceMock({commonOperation}),
                                     OplogInterfaceMock({remoteOperation, commonOperation}),
@@ -299,77 +255,10 @@ TEST(SyncRollBackLocalOperationsTest, SkipOneRemoteOperation) {
     ASSERT_EQUALS(commonOperation.second, result.getValue().getRecordId());
 }
 
-TEST(SyncRollBackLocalOperationsTest, SameTimestampDifferentHashes) {
-    auto commonOperation = makeOpAndRecordId(1, 1);
-    auto localOperation = makeOpAndRecordId(1, 2);
-    auto remoteOperation = makeOpAndRecordId(1, 3);
-    bool called = false;
-    auto result =
-        syncRollBackLocalOperations(OplogInterfaceMock({localOperation, commonOperation}),
-                                    OplogInterfaceMock({remoteOperation, commonOperation}),
-                                    [&](const BSONObj& operation) {
-                                        ASSERT_BSONOBJ_EQ(localOperation.first, operation);
-                                        called = true;
-                                        return Status::OK();
-                                    });
-    ASSERT_OK(result.getStatus());
-    ASSERT_EQUALS(OpTime::parseFromOplogEntry(commonOperation.first),
-                  result.getValue().getOpTime());
-    ASSERT_EQUALS(commonOperation.second, result.getValue().getRecordId());
-    ASSERT_TRUE(called);
-}
-
-TEST(SyncRollBackLocalOperationsTest, SameTimestampEndOfLocalOplog) {
-    auto commonOperation = makeOpAndRecordId(1, 1);
-    auto localOperation = makeOpAndRecordId(1, 2);
-    auto remoteOperation = makeOpAndRecordId(1, 3);
-    bool called = false;
-    auto result =
-        syncRollBackLocalOperations(OplogInterfaceMock({localOperation}),
-                                    OplogInterfaceMock({remoteOperation, commonOperation}),
-                                    [&](const BSONObj& operation) {
-                                        ASSERT_BSONOBJ_EQ(localOperation.first, operation);
-                                        called = true;
-                                        return Status::OK();
-                                    });
-    ASSERT_EQUALS(ErrorCodes::NoMatchingDocument, result.getStatus().code());
-    ASSERT_STRING_CONTAINS(result.getStatus().reason(), "reached beginning of local oplog");
-    ASSERT_TRUE(called);
-}
-
-TEST(SyncRollBackLocalOperationsTest, SameTimestampRollbackOperationFailed) {
-    auto commonOperation = makeOpAndRecordId(1, 1);
-    auto localOperation = makeOpAndRecordId(1, 2);
-    auto remoteOperation = makeOpAndRecordId(1, 3);
-    auto result = syncRollBackLocalOperations(
-        OplogInterfaceMock({localOperation, commonOperation}),
-        OplogInterfaceMock({remoteOperation, commonOperation}),
-        [&](const BSONObj& operation) { return Status(ErrorCodes::OperationFailed, ""); });
-    ASSERT_EQUALS(ErrorCodes::OperationFailed, result.getStatus().code());
-}
-
-TEST(SyncRollBackLocalOperationsTest, SameTimestampEndOfRemoteOplog) {
-    auto commonOperation = makeOpAndRecordId(1, 1);
-    auto localOperation = makeOpAndRecordId(1, 2);
-    auto remoteOperation = makeOpAndRecordId(1, 3);
-    bool called = false;
-    auto result =
-        syncRollBackLocalOperations(OplogInterfaceMock({localOperation, commonOperation}),
-                                    OplogInterfaceMock({remoteOperation}),
-                                    [&](const BSONObj& operation) {
-                                        ASSERT_BSONOBJ_EQ(localOperation.first, operation);
-                                        called = true;
-                                        return Status::OK();
-                                    });
-    ASSERT_EQUALS(ErrorCodes::NoMatchingDocument, result.getStatus().code());
-    ASSERT_STRING_CONTAINS(result.getStatus().reason(), "reached beginning of remote oplog");
-    ASSERT_TRUE(called);
-}
-
 TEST(SyncRollBackLocalOperationsTest, DifferentTimestampEndOfLocalOplog) {
-    auto commonOperation = makeOpAndRecordId(1, 1);
-    auto localOperation = makeOpAndRecordId(3, 1);
-    auto remoteOperation = makeOpAndRecordId(2, 1);
+    auto commonOperation = makeOpAndRecordId(1);
+    auto localOperation = makeOpAndRecordId(3);
+    auto remoteOperation = makeOpAndRecordId(2);
     bool called = false;
     auto result =
         syncRollBackLocalOperations(OplogInterfaceMock({localOperation}),
@@ -385,8 +274,8 @@ TEST(SyncRollBackLocalOperationsTest, DifferentTimestampEndOfLocalOplog) {
 }
 
 TEST(SyncRollBackLocalOperationsTest, DifferentTimestampRollbackOperationFailed) {
-    auto localOperation = makeOpAndRecordId(3, 1);
-    auto remoteOperation = makeOpAndRecordId(2, 1);
+    auto localOperation = makeOpAndRecordId(3);
+    auto remoteOperation = makeOpAndRecordId(2);
     auto result = syncRollBackLocalOperations(
         OplogInterfaceMock({localOperation}),
         OplogInterfaceMock({remoteOperation}),
@@ -395,9 +284,9 @@ TEST(SyncRollBackLocalOperationsTest, DifferentTimestampRollbackOperationFailed)
 }
 
 TEST(SyncRollBackLocalOperationsTest, DifferentTimestampEndOfRemoteOplog) {
-    auto commonOperation = makeOpAndRecordId(1, 1);
-    auto localOperation = makeOpAndRecordId(2, 1);
-    auto remoteOperation = makeOpAndRecordId(3, 1);
+    auto commonOperation = makeOpAndRecordId(1);
+    auto localOperation = makeOpAndRecordId(2);
+    auto remoteOperation = makeOpAndRecordId(3);
     auto result = syncRollBackLocalOperations(OplogInterfaceMock({localOperation, commonOperation}),
                                               OplogInterfaceMock({remoteOperation}),
                                               [&](const BSONObj& operation) {
@@ -433,8 +322,8 @@ public:
         unittest::log() << "Returning success on DBClientCursorForTest::query()";
 
         BSONArrayBuilder builder;
-        builder.append(makeOp(1, 1));
-        builder.append(makeOp(2, 2));
+        builder.append(makeOp(1));
+        builder.append(makeOp(2));
         return std::make_unique<DBClientMockCursor>(this, builder.arr());
     }
 
@@ -447,7 +336,7 @@ void checkRemoteIterator(int numNetworkFailures, bool expectedToSucceed) {
     DBClientConnectionForTest conn(numNetworkFailures);
     auto getConnection = [&]() -> DBClientBase* { return &conn; };
 
-    auto localOperation = makeOpAndRecordId(1, 1);
+    auto localOperation = makeOpAndRecordId(1);
     OplogInterfaceRemote remoteOplogMock(
         HostAndPort("229w43rd", 10036), getConnection, "somecollection", 0);