feat:distable compaction during shutdown

include/pika_db.h

@@ -126,6 +126,8 @@ class DB : public std::enable_shared_from_this<DB>, public pstd::noncopyable {
   void Compact(const storage::DataType& type);
   void CompactRange(const storage::DataType& type, const std::string& start, const std::string& end);
 
+  void SetCompactRangeOptions(const bool is_canceled);
+
   std::shared_ptr<pstd::lock::LockMgr> LockMgr();
   void DbRWLockWriter();
   void DbRWLockReader();

include/pika_server.h

@@ -484,6 +484,11 @@ class PikaServer : public pstd::noncopyable {
   void ProcessCronTask();
   double HitRatio();
 
+  /*
+  * disable compact
+  */
+  void DisableCompact();
+
   /*
    * lastsave used
    */

src/pika_admin.cc

@@ -823,7 +823,9 @@ void ShutdownCmd::DoInitial() {
 // no return
 void ShutdownCmd::Do() {
   DLOG(WARNING) << "handle \'shutdown\'";
+  slot->DbRWUnLock();
   g_pika_server->Exit();
+  slot->DbRWLockReader();
   res_.SetRes(CmdRes::kNone);
 }
 

src/pika_db.cc

@@ -190,6 +190,13 @@ void DB::InitKeyScan() {
   key_scan_info_.duration = -1;  // duration -1 mean the task in processing
 }
 
+void Slot::SetCompactRangeOptions(const bool is_canceled) {
+  if (!opened_) {
+    return;
+  }
+  db_->SetCompactRangeOptions(is_canceled);
+}
+
 void DB::DbRWLockWriter() { db_rwlock_.lock(); }
 
 DisplayCacheInfo DB::GetCacheInfo() {

src/pika_server.cc

@@ -211,6 +211,7 @@ void PikaServer::Start() {
 }
 
 void PikaServer::Exit() {
+  g_pika_server->DisableCompact();
   exit_mutex_.unlock();
   exit_ = true;
 }
@@ -1674,6 +1675,25 @@ void PikaServer::CheckPubsubClientKill(const std::string& userName, const std::v
   });
 }
 
+void PikaServer::DisableCompact() {
+  /* disable auto compactions */
+  std::unordered_map<std::string, std::string> options_map{{"disable_auto_compactions", "true"}};
+  storage::Status s = g_pika_server->RewriteStorageOptions(storage::OptionType::kColumnFamily, options_map);
+  if (!s.ok()) {
+    LOG(FATAL) << "-ERR Set storage::OptionType::kColumnFamily disable_auto_compactions error: " + s.ToString() + "\r\n";
+    return;
+  }
+  g_pika_conf->SetDisableAutoCompaction("true");
+
+  /* cancel in-progress manual compactions */
+  std::shared_lock rwl(dbs_rw_);
+  for (const auto& db_item : dbs_) {
+    for (const auto& slot_item : db_item.second->slots_) {
+      slot_item.second->SetCompactRangeOptions(true);
+    }
+  }
+}
+
 void DoBgslotscleanup(void* arg) {
   auto p = static_cast<PikaServer*>(arg);
   PikaServer::BGSlotsCleanup cleanup = p->bgslots_cleanup();

src/storage/include/storage/storage.h

@@ -1055,6 +1055,7 @@ class Storage {
 
   Status SetOptions(const OptionType& option_type, const std::string& db_type,
                     const std::unordered_map<std::string, std::string>& options);
+  void SetCompactRangeOptions(const bool is_canceled);
   Status EnableDymayticOptions(const OptionType& option_type, 
                     const std::string& db_type, const std::unordered_map<std::string, std::string>& options);
   Status EnableAutoCompaction(const OptionType& option_type, 

src/storage/src/redis.cc

@@ -29,6 +29,10 @@ Redis::~Redis() {
     delete handle;
   }
   delete db_;
+
+  if (default_compact_range_options_.canceled) {
+    delete default_compact_range_options_.canceled;
+  }
 }
 
 Status Redis::GetScanStartPoint(const Slice& key, const Slice& pattern, int64_t cursor, std::string* start_point) {
@@ -187,4 +191,12 @@ void Redis::SetWriteWalOptions(const bool is_wal_disable) {
   default_write_options_.disableWAL = is_wal_disable;
 }
 
+void Redis::SetCompactRangeOptions(const bool is_canceled) {
+  if (!default_compact_range_options_.canceled) {
+    default_compact_range_options_.canceled = new std::atomic<bool>(is_canceled);
+  } else {
+    default_compact_range_options_.canceled->store(is_canceled);
+  } 
+}
+
 }  // namespace storage

src/storage/src/redis.h

@@ -89,6 +89,7 @@ class Redis {
 
   Status SetOptions(const OptionType& option_type, const std::unordered_map<std::string, std::string>& options);
   void SetWriteWalOptions(const bool is_wal_disable);
+  void SetCompactRangeOptions(const bool is_canceled);
 
   // Common Commands
   virtual Status Open(const StorageOptions& storage_options, const std::string& db_path) = 0;

src/storage/src/storage.cc

@@ -1808,6 +1808,14 @@ Status Storage::SetOptions(const OptionType& option_type, const std::string& db_
   return s;
 }
 
+void Storage::SetCompactRangeOptions(const bool is_canceled) {
+  strings_db_->SetCompactRangeOptions(is_canceled);
+  hashes_db_->SetCompactRangeOptions(is_canceled);
+  lists_db_->SetCompactRangeOptions(is_canceled);
+  sets_db_->SetCompactRangeOptions(is_canceled);
+  zsets_db_->SetCompactRangeOptions(is_canceled);
+}
+
 Status Storage::EnableDymayticOptions(const OptionType& option_type, 
                             const std::string& db_type, const std::unordered_map<std::string, std::string>& options) {
   Status s;