MB-33332: Add PrepareAborted and PrepareCompleted committed states

For Ephemeral we need to keep completed prepares in the HashTable for
DCP snapshot/seqlist consistency. We need to be able to determine if any
given prepare has been completed. We could do this using a
HighCompletedSeqno, however, this does not work for the abort case as
we modify the aborted prepare to give it a new seqno higher than the
original prepare on replicas. We also need to be able to distinguish
between committed and aborted completed StoredValues so that we can send
DCP_ABORT as required.

The PrepareAborted state will also be used to
simplify the queueAbort path so we should add the new state required to
StoredValue instead of OrderedStoredValue.

Add new PrepareAborted and PrepareCommitted states to CommittedState in
StoredValue.

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

Author: BenHuddleston

engines/ep/src/hash_table.cc

@@ -345,7 +345,12 @@ HashTable::UpdateResult HashTable::unlocked_updateStoredValue(
     case CommittedState::PreparedMaybeVisible:
         // Cannot update a SV if it's a Pending item.
         return {MutationStatus::IsPendingSyncWrite, nullptr};
-
+    case CommittedState::PrepareAborted:
+    case CommittedState::PrepareCommitted:
+        // We shouldn't be trying to use PrepareCompleted states yet
+        throw std::logic_error(
+                "HashTable::unlocked_updateStoredValue"
+                " attempting to update a completed prepare");
     case CommittedState::CommittedViaMutation:
     case CommittedState::CommittedViaPrepare:
         // Logically /can/ update a non-Pending StoredValue with a Pending Item;
@@ -550,7 +555,12 @@ HashTable::DeleteResult HashTable::unlocked_softDelete(
     case CommittedState::PreparedMaybeVisible:
         // Cannot update a SV if it's a Pending item.
         return {DeletionStatus::IsPendingSyncWrite, nullptr};
-
+    case CommittedState::PrepareAborted:
+    case CommittedState::PrepareCommitted:
+        // We shouldn't be trying to use PrepareCompleted states yet
+        throw std::logic_error(
+                "HashTable::unlocked_softDelete attempting"
+                " to delete a completed prepare");
     case CommittedState::CommittedViaMutation:
     case CommittedState::CommittedViaPrepare:
         const auto preProps = valueStats.prologue(&v);

engines/ep/src/stored-value.cc

@@ -249,6 +249,13 @@ std::unique_ptr<Item> StoredValue::toItem(
     case CommittedState::CommittedViaMutation:
         // nothing do to.
         break;
+    case CommittedState::PrepareAborted:
+    case CommittedState::PrepareCommitted:
+        // We shouldn't be trying to create Item's out of these (for now)
+        throw std::logic_error(
+                "StoredValue::toItemImpl: attempt to create"
+                "Item from completed prepare");
+        break;
     }
 
     return item;
@@ -494,6 +501,12 @@ std::ostream& operator<<(std::ostream& os, const StoredValue& sv) {
     case CommittedState::PreparedMaybeVisible:
         os << "Pv";
         break;
+    case CommittedState::PrepareAborted:
+        os << "Pa";
+        break;
+    case CommittedState::PrepareCommitted:
+        os << "Pc";
+        break;
     }
 
     if (sv.isOrdered()) {

engines/ep/src/stored-value.h

@@ -1032,8 +1032,8 @@ class StoredValue {
 
     /// If the stored value is deleted, this stores the source of its deletion.
     uint8_t deletionSource : 1;
-    /// 2-bit value which encodes the CommittedState of the StoredValue
-    uint8_t committed : 2;
+    /// 3-bit value which encodes the CommittedState of the StoredValue
+    uint8_t committed : 3;
 
     friend std::ostream& operator<<(std::ostream& os, const StoredValue& sv);
 };

include/memcached/types.h

@@ -210,4 +210,13 @@ enum class CommittedState : char {
     /// Same semantics as 'Pending, with the addition of blocking reads to any
     /// existing value.
     PreparedMaybeVisible = 3,
+    /// Item is prepared but has been aborted. This is required mainly for
+    /// Ephemeral where we need to keep completed prepares in the HashTable and
+    /// need to be able to distinguish if a prepare is in-flight or completed.
+    /// We also need to be able to distinguish between aborted and committed
+    /// items for DCP backfill.
+    PrepareAborted = 4,
+    /// Item is prepared but has been committed. See also comment for
+    /// PrepareAborted.
+    PrepareCommitted = 5,
 };