feat: Add the ability to checkpoint an existing server, and spawn a read-only server on that view.

kvrocks.conf

@@ -127,6 +127,13 @@ db-name change.me.db
 # Note that you must specify a directory here, not a file name.
 dir /tmp/kvrocks
 
+# Optional: A snapshot directory
+#
+# If specified, Kvrocks will snapshot the DB at [dir] to the specified [snapshot-dir], 
+# and start a read-only server from the snapshot.
+# 
+# snapshot-dir /tmp/kvrocks-snapshot-changeme
+
 # You can configure where to store your server logs by the log-dir.
 # If you don't specify one, we will use the above `dir` as our default log directory.
 # We also can send logs to stdout/stderr is as simple as:

src/cli/main.cc

@@ -171,7 +171,10 @@ int main(int argc, char *argv[]) {
 #endif
 
   engine::Storage storage(&config);
-  s = storage.Open();
+  const bool read_only = config.snapshot_dir != "";
+  const DBOpenMode open_mode = read_only ? kDBOpenModeForReadOnly : kDBOpenModeDefault;
+  s = storage.Open(open_mode);
+
   if (!s.IsOK()) {
     LOG(ERROR) << "Failed to open: " << s.Msg();
     return 1;

src/config/config.cc

@@ -24,13 +24,11 @@
 #include <rocksdb/env.h>
 #include <strings.h>
 
-#include <algorithm>
 #include <cstdint>
 #include <cstring>
 #include <fstream>
 #include <iostream>
 #include <iterator>
-#include <limits>
 #include <string>
 #include <utility>
 #include <vector>
@@ -190,6 +188,7 @@ Config::Config() {
        new IntField(&force_compact_file_min_deleted_percentage, 10, 1, 100)},
       {"db-name", true, new StringField(&db_name, "change.me.db")},
       {"dir", true, new StringField(&dir, kDefaultDir)},
+      {"snapshot-dir", false, new StringField(&snapshot_dir, "")},
       {"backup-dir", false, new StringField(&backup_dir, kDefaultBackupDir)},
       {"log-dir", true, new StringField(&log_dir, "")},
       {"log-level", false, new EnumField<int>(&log_level, log_levels, google::INFO)},

src/config/config.h

@@ -140,6 +140,10 @@ struct Config {
   std::string replica_announce_ip;
   uint32_t replica_announce_port = 0;
 
+  // The following option exists so users can spawn a read-only server from a snapshot
+  // of a running server.
+  std::string snapshot_dir;
+
   bool persist_cluster_nodes_enabled = true;
   bool slot_id_encoded = false;
   bool cluster_enabled = false;

src/storage/storage.cc

@@ -44,6 +44,7 @@
 #include "redis_metadata.h"
 #include "rocksdb/cache.h"
 #include "rocksdb_crc32c.h"
+#include "scope_exit.h"
 #include "server/server.h"
 #include "storage/batch_indexer.h"
 #include "table_properties_collector.h"
@@ -75,12 +76,46 @@ const int64_t kIORateLimitMaxMb = 1024000;
 
 using rocksdb::Slice;
 
+static Status CreateSnapshot(Config &config, const std::string &snapshot_location) {
+  // The Storage destructor deletes anything at the checkpoint_dir, so we need to make 
+  // sure it's empty in case the user happens to use a snapshot name which matches the 
+  // default (checkpoint/)
+  const std::string old_checkpoint_dir = std::exchange(config.checkpoint_dir, "");
+  const auto checkpoint_dir_guard =
+      MakeScopeExit([&config, &old_checkpoint_dir] { config.checkpoint_dir = old_checkpoint_dir; });
+
+  engine::Storage storage(&config);
+  if (const auto s = storage.Open(kDBOpenModeForReadOnly); !s.IsOK()) {
+    return {Status::NotOK, fmt::format("failed to open DB in read-only mode: {}", s.Msg())};
+  }
+
+  rocksdb::Checkpoint *snapshot = nullptr;
+  if (const auto s = rocksdb::Checkpoint::Create(storage.GetDB(), &snapshot); !s.ok()) {
+    return {Status::NotOK, s.ToString()};
+  }
+
+  std::unique_ptr<rocksdb::Checkpoint> snapshot_guard(snapshot);
+  if (const auto s = snapshot->CreateCheckpoint(snapshot_location + "/db"); !s.ok()) {
+    return {Status::NotOK, s.ToString()};
+  }
+
+  return Status::OK();
+}
+
 Storage::Storage(Config *config)
     : backup_creating_time_secs_(util::GetTimeStamp<std::chrono::seconds>()),
       env_(rocksdb::Env::Default()),
       config_(config),
       lock_mgr_(16),
       db_stats_(std::make_unique<DBStats>()) {
+  if (config->snapshot_dir != "") {
+    if (const auto s = CreateSnapshot(*config, config->snapshot_dir); !s.IsOK()) {
+      throw std::runtime_error(fmt::format("Failed to create snapshot: {}", s.Msg()));
+    }
+    LOG(INFO) << "Starting server in read-only mode with snapshot dir: " << config->snapshot_dir;
+    config->db_dir = config->snapshot_dir + "/db";
+  }
+
   Metadata::InitVersionCounter();
   SetWriteOptions(config->rocks_db.write_options);
 }