KVStore: move impl-only types to kvstore_priv.h

kvstore.h currently contains two classes of code - (1) the interface
for using KVStore subclasses, and (2) types and code used by
subclasses and to implement KVStore. This results in unnecessary code
being pulled in to files which just want to /use/ KVStore, and don't
need to implement it.

As such, create a new private header - kvstore_priv.h - to contain the
implementation details and move implementaiton code to this file.

Change-Id: Icfd721ffbb39005d7392f27806882d4b4ab97bc1
Reviewed-on: http://review.couchbase.org/82683
Reviewed-by: Manu Dhundi <[email protected]>
Tested-by: Build Bot <[email protected]>

Author: daverigby

engines/ep/src/atomicqueue.h

@@ -70,6 +70,8 @@ class AtomicQueue {
 #include <queue>
 
 #include <atomic>
+
+#include "atomic.h"
 #include "threadlocal.h"
 #include "utility.h"
 

engines/ep/src/bgfetcher.h

@@ -25,7 +25,6 @@
 #include <string>
 
 #include "item.h"
-#include "kvstore.h"
 #include "stats.h"
 #include "vbucket.h"
 

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

@@ -19,6 +19,8 @@
 
 #include "common.h"
 #include "couch-kvstore/couch-fs-stats.h"
+#include "kvstore.h"
+
 #include <platform/histogram.h>
 
 std::unique_ptr<FileOpsInterface> getCouchstoreStatsOps(

engines/ep/src/couch-kvstore/couch-fs-stats.h

@@ -15,8 +15,7 @@
  *   limitations under the License.
  */
 
-#ifndef SRC_COUCH_KVSTORE_COUCH_FS_STATS_H_
-#define SRC_COUCH_KVSTORE_COUCH_FS_STATS_H_ 1
+#pragma once
 
 #include "config.h"
 
@@ -25,7 +24,8 @@
 
 #include <libcouchstore/couch_db.h>
 #include <platform/histogram.h>
-#include "kvstore.h"
+
+struct FileStats;
 
 /**
  * Returns an instance of StatsOps from a FileStats reference and
@@ -91,5 +91,3 @@ class StatsOps : public FileOpsInterface {
         size_t write_count_since_open;
     };
 };
-
-#endif  // SRC_COUCH_KVSTORE_COUCH_FS_STATS_H_

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

@@ -19,23 +19,26 @@
 #define SRC_COUCH_KVSTORE_COUCH_KVSTORE_H_ 1
 
 #include "config.h"
+
+#include "atomicqueue.h"
+#include "configuration.h"
+#include "couch-kvstore/couch-fs-stats.h"
+#include "couch-kvstore/couch-kvstore-metadata.h"
+#include "item.h"
+#include "kvstore.h"
+#include "kvstore_priv.h"
 #include "libcouchstore/couch_db.h"
+#include "logger.h"
+
+#include <platform/histogram.h>
+#include <platform/strerror.h>
 #include <relaxed_atomic.h>
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
-#include "configuration.h"
-#include "couch-kvstore/couch-fs-stats.h"
-#include "couch-kvstore/couch-kvstore-metadata.h"
-#include <platform/histogram.h>
-#include <platform/strerror.h>
-#include "logger.h"
-#include "item.h"
-#include "kvstore.h"
-#include "atomicqueue.h"
 
 #define COUCHSTORE_NO_OPTIONS 0
 

engines/ep/src/kvstore.cc

@@ -37,6 +37,43 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 
+ScanContext::ScanContext(std::shared_ptr<Callback<GetValue>> cb,
+                         std::shared_ptr<Callback<CacheLookup>> cl,
+                         uint16_t vb,
+                         size_t id,
+                         uint64_t start,
+                         uint64_t end,
+                         DocumentFilter _docFilter,
+                         ValueFilter _valFilter,
+                         uint64_t _documentCount,
+                         const KVStoreConfig& _config)
+    : callback(cb),
+      lookup(cl),
+      lastReadSeqno(0),
+      startSeqno(start),
+      maxSeqno(end),
+      scanId(id),
+      vbid(vb),
+      docFilter(_docFilter),
+      valFilter(_valFilter),
+      documentCount(_documentCount),
+      logger(&global_logger),
+      config(_config) {
+}
+
+void FileStats::reset() {
+    readTimeHisto.reset();
+    readSeekHisto.reset();
+    readSizeHisto.reset();
+    writeTimeHisto.reset();
+    writeSizeHisto.reset();
+    syncTimeHisto.reset();
+    readCountHisto.reset();
+    writeCountHisto.reset();
+    totalBytesRead = 0;
+    totalBytesWritten = 0;
+}
+
 KVStoreRWRO KVStoreFactory::create(KVStoreConfig& config) {
     std::string backend = config.getBackend();
     if (backend == "couchdb") {
@@ -296,6 +333,38 @@ void KVStore::optimizeWrites(std::vector<queued_item>& items) {
     std::sort(items.begin(), items.end(), cq);
 }
 
+uint64_t KVStore::getLastPersistedSeqno(uint16_t vbid) {
+    vbucket_state* state = cachedVBStates[vbid];
+    if (state) {
+        return state->highSeqno;
+    }
+    return 0;
+}
+
+vbucket_state::vbucket_state(vbucket_state_t _state,
+                             uint64_t _chkid,
+                             uint64_t _maxDelSeqNum,
+                             int64_t _highSeqno,
+                             uint64_t _purgeSeqno,
+                             uint64_t _lastSnapStart,
+                             uint64_t _lastSnapEnd,
+                             uint64_t _maxCas,
+                             int64_t _hlcCasEpochSeqno,
+                             bool _mightContainXattrs,
+                             std::string _failovers)
+    : state(_state),
+      checkpointId(_chkid),
+      maxDeletedSeqno(_maxDelSeqNum),
+      highSeqno(_highSeqno),
+      purgeSeqno(_purgeSeqno),
+      lastSnapStart(_lastSnapStart),
+      lastSnapEnd(_lastSnapEnd),
+      maxCas(_maxCas),
+      hlcCasEpochSeqno(_hlcCasEpochSeqno),
+      mightContainXattrs(_mightContainXattrs),
+      failovers(std::move(_failovers)) {
+}
+
 std::string vbucket_state::toJSON() const {
     std::stringstream jsonState;
     jsonState << "{\"state\": \"" << VBucket::toString(state) << "\""
@@ -310,6 +379,31 @@ std::string vbucket_state::toJSON() const {
     return jsonState.str();
 }
 
+bool vbucket_state::needsToBePersisted(const vbucket_state& vbstate) {
+    /**
+     * The vbucket state information is to be persisted
+     * only if a change is detected in the state or the
+     * failovers fields.
+     */
+    if (state != vbstate.state || failovers.compare(vbstate.failovers) != 0) {
+        return true;
+    }
+    return false;
+}
+
+void vbucket_state::reset() {
+    checkpointId = 0;
+    maxDeletedSeqno = 0;
+    highSeqno = 0;
+    purgeSeqno = 0;
+    lastSnapStart = 0;
+    lastSnapEnd = 0;
+    maxCas = 0;
+    hlcCasEpochSeqno = HlcCasSeqnoUninitialised;
+    mightContainXattrs = false;
+    failovers.clear();
+}
+
 IORequest::IORequest(uint16_t vbId, MutationRequestCallback &cb , bool del,
                      const DocKey itmKey)
     : vbucketId(vbId), deleteItem(del), key(itmKey) {