MB-35133: Cleanup old SyncWrite rollback code

Previously we attempted to rollback SyncWrites individually
by setting the correct state in the HashTable and PDM
post-rollback. With the new, simpler, approach to rollback where
we re-use the warmup code to load prepares we can remove the code
added to pass various state through to the PDM and the PDM rollback
function.

Change-Id: Ia605f04bbb5d32071a669564e58d4990809629ba
Reviewed-on: http://review.couchbase.org/113028
Tested-by: Build Bot <[email protected]>
Reviewed-by: Dave Rigby <[email protected]>

Author: BenHuddleston

engines/ep/src/couch-kvstore/couch-kvstore.cc

@@ -2869,9 +2869,7 @@ RollbackResult CouchKVStore::rollback(Vbid vbid,
     return RollbackResult(true,
                           vb_state->highSeqno,
                           vb_state->lastSnapStart,
-                          vb_state->lastSnapEnd,
-                          vb_state->highCompletedSeqno,
-                          vb_state->highPreparedSeqno);
+                          vb_state->lastSnapEnd);
 }
 
 int populateAllKeys(Db *db, DocInfo *docinfo, void *ctx) {

engines/ep/src/durability/passive_durability_monitor.cc

@@ -360,62 +360,6 @@ void PassiveDurabilityMonitor::completeSyncWrite(
     folly::assume_unreachable();
 }
 
-void PassiveDurabilityMonitor::postProcessRollback(
-        const RollbackResult& rollbackResult) {
-    // Sanity check that new HCS <= new HPS <= new high seqno
-    Expects(rollbackResult.highCompletedSeqno <=
-            rollbackResult.highPreparedSeqno);
-    Expects(rollbackResult.highPreparedSeqno <= rollbackResult.highSeqno);
-
-    auto s = state.wlock();
-
-    // If we rolled back any commits or aborts then we will have put the
-    // original prepare into the rollbackResult.preparesToAdd container. This
-    // container should be in seqno order. To maintain the seqno ordering of the
-    // trackedWrites container, we need to iterate on
-    // rollbackResult.preparesToAdd in reverse order and push the items to the
-    // front of trackedWrites.
-    std::chrono::milliseconds dummy{};
-    for (const auto& item :
-         boost::adaptors::reverse(rollbackResult.preparesToAdd)) {
-        if (static_cast<uint64_t>(item->getBySeqno()) >
-            rollbackResult.highCompletedSeqno) {
-            // Need to specify defaultTimeout for SyncWrite ctor, but we don't
-            // care about the values on replica and have read from disk so give
-            // it a dummy timeout.
-            s->trackedWrites.emplace_front(nullptr /*cookie*/,
-                                           std::move(item),
-                                           dummy,
-                                           nullptr /*firstChain*/,
-                                           nullptr /*secondChain*/);
-        }
-    }
-
-    // Remove everything with seqno > rollback point from trackedWrites
-    auto itr =
-            std::find_if(s->trackedWrites.begin(),
-                         s->trackedWrites.end(),
-                         [&rollbackResult](const auto& write) {
-                             return static_cast<uint64_t>(write.getBySeqno()) >
-                                    rollbackResult.highSeqno;
-                         });
-    s->trackedWrites.erase(itr, s->trackedWrites.end());
-
-    // Post-rollback we should not have any prepares in the PDM that have not
-    // been completed.
-    s->highCompletedSeqno.it = s->trackedWrites.end();
-    s->highCompletedSeqno.lastWriteSeqno.reset(
-            rollbackResult.highCompletedSeqno);
-
-    // The highPreparedSeqno should always point at the last item in
-    // trackedWrites. Every in-flight prepare should be satisfied locally as it
-    // will be on disk.
-    if (!s->trackedWrites.empty()) {
-        s->highPreparedSeqno.it = --s->trackedWrites.end();
-    }
-    s->highPreparedSeqno.lastWriteSeqno.reset(rollbackResult.highPreparedSeqno);
-}
-
 int64_t PassiveDurabilityMonitor::getHighestTrackedSeqno() const {
     auto s = state.rlock();
     if (!s->trackedWrites.empty()) {

engines/ep/src/durability/passive_durability_monitor.h

@@ -148,14 +148,6 @@ class PassiveDurabilityMonitor : public DurabilityMonitor {
      */
     void notifyLocalPersistence() override;
 
-    /**
-     * Remove all in-flight prepares after the new high seqno and add any new
-     * prepares for completions that we may be rolling back.
-     *
-     * @param rollbackResult the information required to rollback
-     */
-    void postProcessRollback(const RollbackResult& rollbackResult);
-
     /**
      * Get the highest seqno for which there is a SyncWrite in trackedWrites.
      * Returns 0 if trackedWrites is empty.

engines/ep/src/magma-kvstore/magma-kvstore.cc

@@ -2084,7 +2084,5 @@ RollbackResult MagmaKVStore::rollback(Vbid vbid,
     return RollbackResult(true,
                           vbstate->highSeqno,
                           vbstate->lastSnapStart,
-                          vbstate->lastSnapEnd,
-                          vbstate->highCompletedSeqno,
-                          vbstate->highPreparedSeqno);
+                          vbstate->lastSnapEnd);
 }

engines/ep/src/rollback_result.cc

@@ -19,25 +19,16 @@
 #include <gsl.h>
 
 RollbackResult::RollbackResult(bool success)
-    : success(success),
-      highSeqno(0),
-      snapStartSeqno(0),
-      snapEndSeqno(0),
-      highCompletedSeqno(0),
-      highPreparedSeqno(0) {
+    : success(success), highSeqno(0), snapStartSeqno(0), snapEndSeqno(0) {
     Expects(!success);
 }
 
 RollbackResult::RollbackResult(bool success,
                                uint64_t highSeqno,
                                uint64_t snapStartSeqno,
-                               uint64_t snapEndSeqno,
-                               uint64_t highCompletedSeqno,
-                               uint64_t highPreparedSeqno)
+                               uint64_t snapEndSeqno)
     : success(success),
       highSeqno(highSeqno),
       snapStartSeqno(snapStartSeqno),
-      snapEndSeqno(snapEndSeqno),
-      highCompletedSeqno(highCompletedSeqno),
-      highPreparedSeqno(highPreparedSeqno) {
+      snapEndSeqno(snapEndSeqno) {
 }

engines/ep/src/rollback_result.h

@@ -39,17 +39,10 @@ class RollbackResult {
     RollbackResult(bool success,
                    uint64_t highSeqno,
                    uint64_t snapStartSeqno,
-                   uint64_t snapEndSeqno,
-                   uint64_t highCompletedSeqno,
-                   uint64_t highPreparedSeqno);
+                   uint64_t snapEndSeqno);
 
     bool success;
     uint64_t highSeqno;
     uint64_t snapStartSeqno;
     uint64_t snapEndSeqno;
-    uint64_t highCompletedSeqno;
-    uint64_t highPreparedSeqno;
-
-    // Container of prepares that need to be added back to the Passive DM
-    std::vector<queued_item> preparesToAdd;
 };

engines/ep/src/vbucket.cc

@@ -2858,7 +2858,6 @@ void VBucket::postProcessRollback(const RollbackResult& rollbackResult,
     incrRollbackItemCount(prevHighSeqno - rollbackResult.highSeqno);
     checkpointManager->setOpenCheckpointId(1);
     setReceivingInitialDiskSnapshot(false);
-    getPassiveDM().postProcessRollback(rollbackResult);
 }
 
 void VBucket::collectionsRolledBack(KVStore& kvstore) {