Move CheckpointConfig to its own file

Move CheckpointConfig from checkpoint.{h,cc} to new files
checkpoint_config.{h,cc}, reducind the number of files which need to
directly include checkpoint.h.

Change-Id: I2eadb69604aadcd33526e5a1a50883e1e84347b1
Reviewed-on: http://review.couchbase.org/82687
Reviewed-by: James Harrison <[email protected]>
Tested-by: Build Bot <[email protected]>

Author: daverigby

engines/ep/CMakeLists.txt

@@ -168,6 +168,7 @@ ADD_LIBRARY(ep_objs OBJECT
             src/bloomfilter.cc
             src/callbacks.cc
             src/checkpoint.cc
+            src/checkpoint_config.cc
             src/checkpoint_remover.cc
             src/conflict_resolution.cc
             src/connhandler.cc

engines/ep/src/checkpoint.cc

@@ -41,38 +41,6 @@ const char* to_string(enum checkpoint_state s) {
     return "<unknown>";
 }
 
-/**
- * A listener class to update checkpoint related configs at runtime.
- */
-class CheckpointConfigChangeListener : public ValueChangedListener {
-public:
-    CheckpointConfigChangeListener(CheckpointConfig &c) : config(c) { }
-    virtual ~CheckpointConfigChangeListener() { }
-
-    virtual void sizeValueChanged(const std::string &key, size_t value) {
-        if (key.compare("chk_period") == 0) {
-            config.setCheckpointPeriod(value);
-        } else if (key.compare("chk_max_items") == 0) {
-            config.setCheckpointMaxItems(value);
-        } else if (key.compare("max_checkpoints") == 0) {
-            config.setMaxCheckpoints(value);
-        }
-    }
-
-    virtual void booleanValueChanged(const std::string &key, bool value) {
-        if (key.compare("item_num_based_new_chk") == 0) {
-            config.allowItemNumBasedNewCheckpoint(value);
-        } else if (key.compare("keep_closed_chks") == 0) {
-            config.allowKeepClosedCheckpoints(value);
-        } else if (key.compare("enable_chk_merge") == 0) {
-            config.allowCheckpointMerge(value);
-        }
-    }
-
-private:
-    CheckpointConfig &config;
-};
-
 void CheckpointCursor::decrOffset(size_t decr) {
     if (offset >= decr) {
         offset.fetch_sub(decr);
@@ -1925,99 +1893,6 @@ size_t CheckpointManager::getMemoryUsageOfUnrefCheckpoints() {
     return memUsage;
 }
 
-void CheckpointConfig::addConfigChangeListener(
-                                         EventuallyPersistentEngine &engine) {
-    Configuration &configuration = engine.getConfiguration();
-    configuration.addValueChangedListener("chk_period",
-             new CheckpointConfigChangeListener(engine.getCheckpointConfig()));
-    configuration.addValueChangedListener("chk_max_items",
-             new CheckpointConfigChangeListener(engine.getCheckpointConfig()));
-    configuration.addValueChangedListener("max_checkpoints",
-             new CheckpointConfigChangeListener(engine.getCheckpointConfig()));
-    configuration.addValueChangedListener("item_num_based_new_chk",
-             new CheckpointConfigChangeListener(engine.getCheckpointConfig()));
-    configuration.addValueChangedListener("keep_closed_chks",
-             new CheckpointConfigChangeListener(engine.getCheckpointConfig()));
-    configuration.addValueChangedListener("enable_chk_merge",
-             new CheckpointConfigChangeListener(engine.getCheckpointConfig()));
-}
-
-CheckpointConfig::CheckpointConfig(EventuallyPersistentEngine &e) {
-    Configuration &config = e.getConfiguration();
-    checkpointPeriod = config.getChkPeriod();
-    checkpointMaxItems = config.getChkMaxItems();
-    maxCheckpoints = config.getMaxCheckpoints();
-    itemNumBasedNewCheckpoint = config.isItemNumBasedNewChk();
-    keepClosedCheckpoints = config.isKeepClosedChks();
-    enableChkMerge = config.isEnableChkMerge();
-    persistenceEnabled = config.getBucketType() == "persistent";
-}
-
-bool CheckpointConfig::validateCheckpointMaxItemsParam(size_t
-                                                       checkpoint_max_items) {
-    if (checkpoint_max_items < MIN_CHECKPOINT_ITEMS ||
-        checkpoint_max_items > MAX_CHECKPOINT_ITEMS) {
-        std::stringstream ss;
-        ss << "New checkpoint_max_items param value " << checkpoint_max_items
-           << " is not ranged between the min allowed value " <<
-           MIN_CHECKPOINT_ITEMS
-           << " and max value " << MAX_CHECKPOINT_ITEMS;
-        LOG(EXTENSION_LOG_WARNING, "%s", ss.str().c_str());
-        return false;
-    }
-    return true;
-}
-
-bool CheckpointConfig::validateCheckpointPeriodParam(
-                                                   size_t checkpoint_period) {
-    if (checkpoint_period < MIN_CHECKPOINT_PERIOD ||
-        checkpoint_period > MAX_CHECKPOINT_PERIOD) {
-        std::stringstream ss;
-        ss << "New checkpoint_period param value " << checkpoint_period
-           << " is not ranged between the min allowed value " <<
-              MIN_CHECKPOINT_PERIOD
-           << " and max value " << MAX_CHECKPOINT_PERIOD;
-        LOG(EXTENSION_LOG_WARNING, "%s\n", ss.str().c_str());
-        return false;
-    }
-    return true;
-}
-
-bool CheckpointConfig::validateMaxCheckpointsParam(size_t max_checkpoints) {
-    if (max_checkpoints < DEFAULT_MAX_CHECKPOINTS ||
-        max_checkpoints > MAX_CHECKPOINTS_UPPER_BOUND) {
-        std::stringstream ss;
-        ss << "New max_checkpoints param value " << max_checkpoints
-           << " is not ranged between the min allowed value " <<
-              DEFAULT_MAX_CHECKPOINTS
-           << " and max value " << MAX_CHECKPOINTS_UPPER_BOUND;
-        LOG(EXTENSION_LOG_WARNING, "%s\n", ss.str().c_str());
-        return false;
-    }
-    return true;
-}
-
-void CheckpointConfig::setCheckpointPeriod(size_t value) {
-    if (!validateCheckpointPeriodParam(value)) {
-        value = DEFAULT_CHECKPOINT_PERIOD;
-    }
-    checkpointPeriod = static_cast<rel_time_t>(value);
-}
-
-void CheckpointConfig::setCheckpointMaxItems(size_t value) {
-    if (!validateCheckpointMaxItemsParam(value)) {
-        value = DEFAULT_CHECKPOINT_ITEMS;
-    }
-    checkpointMaxItems = value;
-}
-
-void CheckpointConfig::setMaxCheckpoints(size_t value) {
-    if (!validateMaxCheckpointsParam(value)) {
-        value = DEFAULT_MAX_CHECKPOINTS;
-    }
-    maxCheckpoints = value;
-}
-
 void CheckpointManager::addStats(ADD_STAT add_stat, const void *cookie) {
     LockHolder lh(queueLock);
     char buf[256];

engines/ep/src/checkpoint.h

@@ -71,11 +71,6 @@ struct index_entry {
     int64_t mutation_id;
 };
 
-typedef struct {
-    uint64_t start;
-    uint64_t end;
-} snapshot_range_t;
-
 typedef struct {
     uint64_t start;
     snapshot_range_t range;
@@ -993,107 +988,4 @@ class CheckpointManager {
 // Outputs a textual description of the CheckpointManager.
 std::ostream& operator<<(std::ostream& os, const CheckpointManager& m);
 
-/**
- * A class containing the config parameters for checkpoint.
- */
-
-class CheckpointConfig {
-public:
-    CheckpointConfig()
-        : checkpointPeriod(DEFAULT_CHECKPOINT_PERIOD),
-          checkpointMaxItems(DEFAULT_CHECKPOINT_ITEMS),
-          maxCheckpoints(DEFAULT_MAX_CHECKPOINTS),
-          itemNumBasedNewCheckpoint(true),
-          keepClosedCheckpoints(false),
-          enableChkMerge(false),
-          persistenceEnabled(true)
-    { /* empty */ }
-
-    CheckpointConfig(rel_time_t period, size_t max_items, size_t max_ckpts,
-                     bool item_based_new_ckpt, bool keep_closed_ckpts,
-                     bool enable_ckpt_merge, bool persistence_enabled)
-        : checkpointPeriod(period),
-          checkpointMaxItems(max_items),
-          maxCheckpoints(max_ckpts),
-          itemNumBasedNewCheckpoint(item_based_new_ckpt),
-          keepClosedCheckpoints(keep_closed_ckpts),
-          enableChkMerge(enable_ckpt_merge),
-          persistenceEnabled(persistence_enabled) {}
-
-    CheckpointConfig(EventuallyPersistentEngine &e);
-
-    rel_time_t getCheckpointPeriod() const {
-        return checkpointPeriod;
-    }
-
-    size_t getCheckpointMaxItems() const {
-        return checkpointMaxItems;
-    }
-
-    size_t getMaxCheckpoints() const {
-        return maxCheckpoints;
-    }
-
-    bool isItemNumBasedNewCheckpoint() const {
-        return itemNumBasedNewCheckpoint;
-    }
-
-    bool canKeepClosedCheckpoints() const {
-        return keepClosedCheckpoints;
-    }
-
-    bool isCheckpointMergeSupported() const {
-        return enableChkMerge;
-    }
-
-    bool isPersistenceEnabled() const {
-        return persistenceEnabled;
-    }
-
-protected:
-    friend class CheckpointConfigChangeListener;
-    friend class EventuallyPersistentEngine;
-
-    bool validateCheckpointMaxItemsParam(size_t checkpoint_max_items);
-    bool validateCheckpointPeriodParam(size_t checkpoint_period);
-    bool validateMaxCheckpointsParam(size_t max_checkpoints);
-
-    void setCheckpointPeriod(size_t value);
-    void setCheckpointMaxItems(size_t value);
-    void setMaxCheckpoints(size_t value);
-
-    void allowItemNumBasedNewCheckpoint(bool value) {
-        itemNumBasedNewCheckpoint = value;
-    }
-
-    void allowKeepClosedCheckpoints(bool value) {
-        keepClosedCheckpoints = value;
-    }
-
-    void allowCheckpointMerge(bool value) {
-        enableChkMerge = value;
-    }
-
-    static void addConfigChangeListener(EventuallyPersistentEngine &engine);
-
-private:
-    // Period of a checkpoint in terms of time in sec
-    rel_time_t checkpointPeriod;
-    // Number of max items allowed in each checkpoint
-    size_t checkpointMaxItems;
-    // Number of max checkpoints allowed
-    size_t     maxCheckpoints;
-    // Flag indicating if a new checkpoint is created once the number of items in the current
-    // checkpoint is greater than the max number allowed.
-    bool itemNumBasedNewCheckpoint;
-    // Flag indicating if closed checkpoints should be kept in memory if the current memory usage
-    // below the high water mark.
-    bool keepClosedCheckpoints;
-    // Flag indicating if merging closed checkpoints is enabled or not.
-    bool enableChkMerge;
-
-    // Flag indicating if persistence is enabled.
-    bool persistenceEnabled;
-};
-
 #endif  // SRC_CHECKPOINT_H_