MB-64001: Rename Response::isMetaEvent

This function is used in one place just for stat accounting
when processing the readyQueue in backfills. The function
only needs to determine what events can from a backfill
scan.

New things like CachedValue incorrectly in the wrong part of
the switch as the function wasn't so clear.

Change-Id: I349147624f10bcc491a77cdfd9b9629735efce0f
Reviewed-on: https://review.couchbase.org/c/kv_engine/+/235489
Reviewed-by: Trond Norbye <[email protected]>
Tested-by: Build Bot <[email protected]>

Author: jimwwalker

engines/ep/src/dcp/active_stream.cc

@@ -798,7 +798,7 @@ std::unique_ptr<DcpResponse> ActiveStream::backfillPhase(
     if (resp) {
         producer.recordBackfillManagerBytesSent(resp->getApproximateSize());
         bufferedBackfill.bytes.fetch_sub(resp->getApproximateSize());
-        if (!resp->isMetaEvent() || resp->isSystemEvent()) {
+        if (resp->isPersistedEvent()) {
             bufferedBackfill.items--;
         }
 

engines/ep/src/dcp/response.h

@@ -81,44 +81,40 @@ class DcpResponse {
         return OptionalSeqno{/*no-seqno*/};
     }
 
-    /* Returns true if this response is a meta event (i.e. not an operation on
-     * an actual user document.
+    /**
+     * Function used in backfill code to determine if the current queued item
+     * represents a persisted item, e.g. a mutation or delete
+     *
+     * @return true if this event is persisted (something which has been
+     * recombobulated from the KVStore )
      */
-    bool isMetaEvent() const {
+    bool isPersistedEvent() const {
         switch (event_) {
         case Event::Mutation:
         case Event::Deletion:
         case Event::Expiration:
         case Event::Prepare:
         case Event::Commit:
         case Event::Abort:
-        case Event::CachedValue:
-            return false;
-
+        case Event::SystemEvent:
+            return true;
         case Event::SetVbucket:
         case Event::StreamReq:
         case Event::StreamEnd:
         case Event::SnapshotMarker:
         case Event::AddStream:
-        case Event::SystemEvent:
         case Event::SeqnoAcknowledgement:
         case Event::OSOSnapshot:
         case Event::SeqnoAdvanced:
+        case Event::CachedValue:
         case Event::CacheTransferToActiveStream:
-            return true;
+            return false;
         }
         throw std::invalid_argument(
-                "DcpResponse::isMetaEvent: Invalid event_ " +
+                "DcpResponse::isPersistedEvent: Invalid event_ " +
                 std::to_string(int(event_)));
     }
 
-    /**
-     * Returns if the response is a system event
-     */
-    bool isSystemEvent() const {
-        return (event_ == Event::SystemEvent);
-    }
-
     virtual size_t getMessageSize() const = 0;
 
     /**

engines/ep/tests/module_tests/dcp_stream_test.cc

@@ -768,11 +768,13 @@ TEST_P(StreamTest, MB17653_ItemsRemaining) {
     std::unique_ptr<DcpResponse> response(
             stream->public_nextQueuedItem(*producer));
     ASSERT_NE(nullptr, response);
-    EXPECT_TRUE(response->isMetaEvent()) << "Expected 1st item to be meta";
+    EXPECT_FALSE(response->isPersistedEvent())
+            << "Expected 1st item to not be a persisted event";
 
     response = stream->public_nextQueuedItem(*producer);
     ASSERT_NE(nullptr, response);
-    EXPECT_FALSE(response->isMetaEvent()) << "Expected 2nd item to be non-meta";
+    EXPECT_TRUE(response->isPersistedEvent())
+            << "Expected 2nd item to be from persistence";
 
     response = stream->public_nextQueuedItem(*producer);
     EXPECT_EQ(nullptr, response) << "Expected there to not be a 3rd item.";