From 7b125d82c754ab6656d65b11f2b01483299ae794 Mon Sep 17 00:00:00 2001 From: cheniujh <1271435567@qq.com> Date: Mon, 8 Jul 2024 20:25:52 +0800 Subject: [PATCH 1/6] 1 add return flag for flushdb 2 add an atomic flag for flushdb 3 add callback function when deleted old path 4 revised some ugly code --- include/pika_admin.h | 21 ++++++--- include/pika_db.h | 4 ++ include/pika_server.h | 1 + src/pika_admin.cc | 101 ++++++++++++++++++++++++++-------------- src/pika_db.cc | 20 ++++++-- src/pika_server.cc | 21 +++++++++ src/pika_transaction.cc | 2 +- 7 files changed, 125 insertions(+), 45 deletions(-) diff --git a/include/pika_admin.h b/include/pika_admin.h index 67a1969820..a51bcd946f 100644 --- a/include/pika_admin.h +++ b/include/pika_admin.h @@ -185,11 +185,15 @@ class FlushallCmd : public Cmd { void Split(const HintKeys& hint_keys) override{}; void Merge() override{}; Cmd* Clone() override { return new FlushallCmd(*this); } - void FlushAllWithoutLock(); + bool FlushAllWithoutLock(); + void DoBinlog() override; private: void DoInitial() override; - void DoWithoutLock(std::shared_ptr db); + bool DoWithoutLock(std::shared_ptr db); + void Clear() override { flushall_succeed_ = false; } + + bool flushall_succeed_{false}; }; class FlushdbCmd : public Cmd { @@ -204,14 +208,19 @@ class FlushdbCmd : public Cmd { void Split(const HintKeys& hint_keys) override{}; void Merge() override{}; Cmd* Clone() override { return new FlushdbCmd(*this); } - void FlushAllDBsWithoutLock(); std::string GetFlushDBname() { return db_name_; } + void DoBinlog() override; + bool DoWithoutLock(); private: - std::string db_name_; void DoInitial() override; - void Clear() override { db_name_.clear(); } - void DoWithoutLock(); + void Clear() override { + db_name_.clear(); + flush_succeed_ = false; + } + + bool flush_succeed_{false}; + std::string db_name_; }; class ClientCmd : public Cmd { diff --git a/include/pika_db.h b/include/pika_db.h index c3d4fce211..867148bdc1 100644 --- a/include/pika_db.h +++ b/include/pika_db.h @@ -148,6 +148,9 @@ class DB : public std::enable_shared_from_this, public pstd::noncopyable { bool IsBgSaving(); BgSaveInfo bgsave_info(); pstd::Status GetKeyNum(std::vector* key_info); + void ResetIsFlushingDBToFalse() { + is_flushing_db_.store(false); + } private: bool opened_ = false; @@ -160,6 +163,7 @@ class DB : public std::enable_shared_from_this, public pstd::noncopyable { pstd::Mutex key_info_protector_; std::atomic binlog_io_error_; std::shared_mutex dbs_rw_; + std::atomic is_flushing_db_; // class may be shared, using shared_ptr would be a better choice std::shared_ptr lock_mgr_; std::shared_ptr storage_; diff --git a/include/pika_server.h b/include/pika_server.h index 1374158f88..d1ffd543ea 100644 --- a/include/pika_server.h +++ b/include/pika_server.h @@ -202,6 +202,7 @@ class PikaServer : public pstd::noncopyable { * Flushall & Flushdb used */ void PurgeDir(const std::string& path); + void PurgeDirWithCallBack(const std::string& path, const std::function& call_back); void PurgeDirTaskSchedule(void (*function)(void*), void* arg); /* diff --git a/src/pika_admin.cc b/src/pika_admin.cc index 81a5a36ab6..fd2bd4fcff 100644 --- a/src/pika_admin.cc +++ b/src/pika_admin.cc @@ -492,6 +492,7 @@ void SelectCmd::Do() { } void FlushallCmd::DoInitial() { + flushall_succeed_ = false; if (!CheckArg(argv_.size())) { res_.SetRes(CmdRes::kWrongNum, kCmdNameFlushall); return; @@ -510,13 +511,17 @@ void FlushallCmd::Do() { for (const auto& db_item : g_pika_server->GetDB()) { db_item.second->DBLock(); } - FlushAllWithoutLock(); + flushall_succeed_ = FlushAllWithoutLock(); for (const auto& db_item : g_pika_server->GetDB()) { db_item.second->DBUnlock(); } g_pika_rm->DBUnlock(); - if (res_.ok()) { + if (flushall_succeed_) { res_.SetRes(CmdRes::kOk); + } else { + res_.SetRes(CmdRes::kErrOther, + "Flushall failed, maybe only some of the dbs successfully flushed while some not, check WARNING/ERROR log to know " + "more, you can try again moment later"); } } @@ -525,37 +530,52 @@ void FlushallCmd::DoThroughDB() { } void FlushallCmd::DoUpdateCache(std::shared_ptr db) { + if (!flushall_succeed_) { + //flushdb failed, also don't clear the cache + return; + } // clear cache if (PIKA_CACHE_NONE != g_pika_conf->cache_mode()) { g_pika_server->ClearCacheDbAsync(db); } } -void FlushallCmd::FlushAllWithoutLock() { +bool FlushallCmd::FlushAllWithoutLock() { for (const auto& db_item : g_pika_server->GetDB()) { std::shared_ptr db = db_item.second; DBInfo p_info(db->GetDBName()); if (g_pika_rm->GetSyncMasterDBs().find(p_info) == g_pika_rm->GetSyncMasterDBs().end()) { - res_.SetRes(CmdRes::kErrOther, "DB not found"); - return; + LOG(ERROR) << p_info.db_name_ << " not found when flushall db"; + return false; } - DoWithoutLock(db); - } - if (res_.ok()) { - res_.SetRes(CmdRes::kOk); + bool success = DoWithoutLock(db); + if (!success) { return false; } } + return true; } -void FlushallCmd::DoWithoutLock(std::shared_ptr db) { +bool FlushallCmd::DoWithoutLock(std::shared_ptr db) { if (!db) { - LOG(INFO) << "Flushall, but DB not found"; + LOG(ERROR) << "Flushall, but DB not found"; + return false; } else { - db->FlushDBWithoutLock(); + bool success = db->FlushDBWithoutLock(); + if (!success) { + //if the db is not flushed, return before clear the cache + return success; + } DoUpdateCache(db); } + return true; +} +void FlushallCmd::DoBinlog() { + if (flushall_succeed_) { + Cmd::DoBinlog(); + } } void FlushdbCmd::DoInitial() { + flush_succeed_ = false; if (!CheckArg(argv_.size())) { res_.SetRes(CmdRes::kWrongNum, kCmdNameFlushdb); return; @@ -570,16 +590,20 @@ void FlushdbCmd::DoInitial() { void FlushdbCmd::Do() { if (!db_) { - res_.SetRes(CmdRes::kInvalidDB); + res_.SetRes(CmdRes::kInvalidDB, "DB not found while flushdb"); + return; + } + if (db_->IsKeyScaning()) { + res_.SetRes(CmdRes::kErrOther, "The keyscan operation is executing, Try again later"); + return; + } + std::lock_guard s_prw(g_pika_rm->GetDBLock()); + std::lock_guard l_prw(db_->GetDBLock()); + flush_succeed_ = DoWithoutLock(); + if (flush_succeed_) { + res_.SetRes(CmdRes::kOk); } else { - if (db_->IsKeyScaning()) { - res_.SetRes(CmdRes::kErrOther, "The keyscan operation is executing, Try again later"); - } else { - std::lock_guard s_prw(g_pika_rm->GetDBLock()); - std::lock_guard l_prw(db_->GetDBLock()); - FlushAllDBsWithoutLock(); - res_.SetRes(CmdRes::kOk); - } + res_.SetRes(CmdRes::kErrOther, "flushdb failed, Try again later(check WARNING/ERROR log to know more)"); } } @@ -588,31 +612,38 @@ void FlushdbCmd::DoThroughDB() { } void FlushdbCmd::DoUpdateCache() { + if (!flush_succeed_) { + //if flushdb failed, also do not clear the cache + return; + } // clear cache if (g_pika_conf->cache_mode() != PIKA_CACHE_NONE) { g_pika_server->ClearCacheDbAsync(db_); } } -void FlushdbCmd::FlushAllDBsWithoutLock() { +bool FlushdbCmd::DoWithoutLock() { + if (!db_) { + LOG(ERROR) << "Flushdb, but DB not found"; + return false; + } DBInfo p_info(db_->GetDBName()); if (g_pika_rm->GetSyncMasterDBs().find(p_info) == g_pika_rm->GetSyncMasterDBs().end()) { - res_.SetRes(CmdRes::kErrOther, "DB not found"); - return; + LOG(ERROR) << "DB not found when flushing " << db_->GetDBName(); + return false; } - DoWithoutLock(); + if (db_name_ != "all") { + //Floyd does not support flushdb by type + LOG(ERROR) << "cannot flushdb by type in floyd"; + return false; + } + + return db_->FlushDBWithoutLock(); } -void FlushdbCmd::DoWithoutLock() { - if (!db_) { - LOG(INFO) << "Flushdb, but DB not found"; - } else { - if (db_name_ == "all") { - db_->FlushDBWithoutLock(); - } else { - //Floyd does not support flushdb by type - LOG(ERROR) << "cannot flushdb by type in floyd"; - } +void FlushdbCmd::DoBinlog() { + if (flush_succeed_) { + Cmd::DoBinlog(); } } diff --git a/src/pika_db.cc b/src/pika_db.cc index efe004c122..f2024b083d 100644 --- a/src/pika_db.cc +++ b/src/pika_db.cc @@ -44,6 +44,7 @@ DB::DB(std::string db_name, const std::string& db_path, pstd::CreatePath(log_path_); lock_mgr_ = std::make_shared(1000, 0, std::make_shared()); binlog_io_error_.store(false); + is_flushing_db_.store(false); opened_ = s.ok(); assert(storage_); assert(s.ok()); @@ -197,6 +198,12 @@ bool DB::FlushDBWithoutLock() { return false; } + bool expected = false; + if (!is_flushing_db_.compare_exchange_strong(expected, true, std::memory_order::memory_order_seq_cst)) { + LOG(WARNING) << db_name_ << ": Aborting curr FlushDB task due to the previous FlushDB task is still executing (deleting old db path is an async task)"; + return false; + } + LOG(INFO) << db_name_ << " Delete old db..."; storage_.reset(); @@ -205,15 +212,22 @@ bool DB::FlushDBWithoutLock() { dbpath.erase(dbpath.length() - 1); } dbpath.append("_deleting/"); - pstd::RenameFile(db_path_, dbpath); - + auto rename_success = pstd::RenameFile(db_path_, dbpath); storage_ = std::make_shared(g_pika_conf->db_instance_num(), g_pika_conf->default_slot_num(), g_pika_conf->classic_mode()); rocksdb::Status s = storage_->Open(g_pika_server->storage_options(), db_path_); assert(storage_); assert(s.ok()); + if (rename_success == -1) { + //the storage_->Open actually opened old RocksDB instance, so flushdb failed + LOG(WARNING) << db_name_ << " FlushDB failed due to rename old db_path_ failed"; + return false; + } LOG(INFO) << db_name_ << " Open new db success"; - g_pika_server->PurgeDir(dbpath); + + //when dbpath successfully deleted, a call back fun will reset flushing db flag to false, so the next FlushDB task can be exec + auto reset_flag_call_back = [this]{ this->ResetIsFlushingDBToFalse(); }; + g_pika_server->PurgeDirWithCallBack(dbpath, reset_flag_call_back); return true; } diff --git a/src/pika_server.cc b/src/pika_server.cc index 35efd46747..083a714277 100644 --- a/src/pika_server.cc +++ b/src/pika_server.cc @@ -41,6 +41,22 @@ void DoPurgeDir(void* arg) { LOG(INFO) << "Delete dir: " << *path << " done"; } +struct PurgeDirArgsWithCallBackArgs { + PurgeDirArgsWithCallBackArgs(std::string path, const std::function& call_back) + : path_(std::move(path)), call_back_(call_back) {} + std::string path_; + std::function call_back_; +}; + +void DoPurgeDirWithCallBack(void* arg) { + std::unique_ptr args(static_cast(arg)); + LOG(INFO) << "Delete dir: " << args->path_ << " start"; + pstd::DeleteDir(args->path_); + LOG(INFO) << "Delete dir: " << args->path_ << " done"; + args->call_back_(); +} + + PikaServer::PikaServer() : exit_(false), slow_cmd_thread_pool_flag_(g_pika_conf->slow_cmd_pool()), @@ -794,6 +810,11 @@ void PikaServer::PurgeDir(const std::string& path) { PurgeDirTaskSchedule(&DoPurgeDir, static_cast(dir_path)); } +void PikaServer::PurgeDirWithCallBack(const std::string& path, const std::function& call_back) { + auto args = new PurgeDirArgsWithCallBackArgs(path, call_back); + PurgeDirTaskSchedule(&DoPurgeDirWithCallBack, static_cast(args)); +} + void PikaServer::PurgeDirTaskSchedule(void (*function)(void*), void* arg) { purge_thread_.set_thread_name("PurgeDirTask"); purge_thread_.StartThread(); diff --git a/src/pika_transaction.cc b/src/pika_transaction.cc index cdf47856df..29fbac4754 100644 --- a/src/pika_transaction.cc +++ b/src/pika_transaction.cc @@ -60,7 +60,7 @@ void ExecCmd::Do() { client_conn->SetAllTxnFailed(); } else if (cmd->name() == kCmdNameFlushdb) { auto flushdb = std::dynamic_pointer_cast(cmd); - flushdb->FlushAllDBsWithoutLock(); + flushdb->DoWithoutLock(); if (cmd->res().ok()) { cmd->res().SetRes(CmdRes::kOk); } From 86578e2b87408ebac349b7b8ffda55f2c9239b43 Mon Sep 17 00:00:00 2001 From: cheniujh <1271435567@qq.com> Date: Wed, 10 Jul 2024 14:42:04 +0800 Subject: [PATCH 2/6] add timestamp for deleting suffix when flushdb --- include/pika_db.h | 4 ---- include/pika_server.h | 1 - src/pika_admin.cc | 14 +++++++------- src/pika_db.cc | 17 ++++++----------- src/pika_server.cc | 19 ------------------- 5 files changed, 13 insertions(+), 42 deletions(-) diff --git a/include/pika_db.h b/include/pika_db.h index 867148bdc1..c3d4fce211 100644 --- a/include/pika_db.h +++ b/include/pika_db.h @@ -148,9 +148,6 @@ class DB : public std::enable_shared_from_this, public pstd::noncopyable { bool IsBgSaving(); BgSaveInfo bgsave_info(); pstd::Status GetKeyNum(std::vector* key_info); - void ResetIsFlushingDBToFalse() { - is_flushing_db_.store(false); - } private: bool opened_ = false; @@ -163,7 +160,6 @@ class DB : public std::enable_shared_from_this, public pstd::noncopyable { pstd::Mutex key_info_protector_; std::atomic binlog_io_error_; std::shared_mutex dbs_rw_; - std::atomic is_flushing_db_; // class may be shared, using shared_ptr would be a better choice std::shared_ptr lock_mgr_; std::shared_ptr storage_; diff --git a/include/pika_server.h b/include/pika_server.h index d1ffd543ea..1374158f88 100644 --- a/include/pika_server.h +++ b/include/pika_server.h @@ -202,7 +202,6 @@ class PikaServer : public pstd::noncopyable { * Flushall & Flushdb used */ void PurgeDir(const std::string& path); - void PurgeDirWithCallBack(const std::string& path, const std::function& call_back); void PurgeDirTaskSchedule(void (*function)(void*), void* arg); /* diff --git a/src/pika_admin.cc b/src/pika_admin.cc index fd2bd4fcff..785df8c4aa 100644 --- a/src/pika_admin.cc +++ b/src/pika_admin.cc @@ -558,14 +558,14 @@ bool FlushallCmd::DoWithoutLock(std::shared_ptr db) { if (!db) { LOG(ERROR) << "Flushall, but DB not found"; return false; - } else { - bool success = db->FlushDBWithoutLock(); - if (!success) { - //if the db is not flushed, return before clear the cache - return success; - } - DoUpdateCache(db); } + bool success = db->FlushDBWithoutLock(); + if (!success) { + // if the db is not flushed, return before clear the cache + return success; + } + DoUpdateCache(db); + return true; } void FlushallCmd::DoBinlog() { diff --git a/src/pika_db.cc b/src/pika_db.cc index f2024b083d..c8b5874e36 100644 --- a/src/pika_db.cc +++ b/src/pika_db.cc @@ -44,7 +44,6 @@ DB::DB(std::string db_name, const std::string& db_path, pstd::CreatePath(log_path_); lock_mgr_ = std::make_shared(1000, 0, std::make_shared()); binlog_io_error_.store(false); - is_flushing_db_.store(false); opened_ = s.ok(); assert(storage_); assert(s.ok()); @@ -198,12 +197,6 @@ bool DB::FlushDBWithoutLock() { return false; } - bool expected = false; - if (!is_flushing_db_.compare_exchange_strong(expected, true, std::memory_order::memory_order_seq_cst)) { - LOG(WARNING) << db_name_ << ": Aborting curr FlushDB task due to the previous FlushDB task is still executing (deleting old db path is an async task)"; - return false; - } - LOG(INFO) << db_name_ << " Delete old db..."; storage_.reset(); @@ -211,7 +204,11 @@ bool DB::FlushDBWithoutLock() { if (dbpath[dbpath.length() - 1] == '/') { dbpath.erase(dbpath.length() - 1); } - dbpath.append("_deleting/"); + std::string delete_suffix("_deleting_"); + delete_suffix.append(std::to_string(NowMicros())); + delete_suffix.append("/"); + dbpath.append(delete_suffix); + LOG(INFO) << "remaned:" << dbpath; auto rename_success = pstd::RenameFile(db_path_, dbpath); storage_ = std::make_shared(g_pika_conf->db_instance_num(), g_pika_conf->default_slot_num(), g_pika_conf->classic_mode()); @@ -225,9 +222,7 @@ bool DB::FlushDBWithoutLock() { } LOG(INFO) << db_name_ << " Open new db success"; - //when dbpath successfully deleted, a call back fun will reset flushing db flag to false, so the next FlushDB task can be exec - auto reset_flag_call_back = [this]{ this->ResetIsFlushingDBToFalse(); }; - g_pika_server->PurgeDirWithCallBack(dbpath, reset_flag_call_back); + g_pika_server->PurgeDir(dbpath); return true; } diff --git a/src/pika_server.cc b/src/pika_server.cc index 083a714277..a3f03f7fd7 100644 --- a/src/pika_server.cc +++ b/src/pika_server.cc @@ -41,21 +41,6 @@ void DoPurgeDir(void* arg) { LOG(INFO) << "Delete dir: " << *path << " done"; } -struct PurgeDirArgsWithCallBackArgs { - PurgeDirArgsWithCallBackArgs(std::string path, const std::function& call_back) - : path_(std::move(path)), call_back_(call_back) {} - std::string path_; - std::function call_back_; -}; - -void DoPurgeDirWithCallBack(void* arg) { - std::unique_ptr args(static_cast(arg)); - LOG(INFO) << "Delete dir: " << args->path_ << " start"; - pstd::DeleteDir(args->path_); - LOG(INFO) << "Delete dir: " << args->path_ << " done"; - args->call_back_(); -} - PikaServer::PikaServer() : exit_(false), @@ -810,10 +795,6 @@ void PikaServer::PurgeDir(const std::string& path) { PurgeDirTaskSchedule(&DoPurgeDir, static_cast(dir_path)); } -void PikaServer::PurgeDirWithCallBack(const std::string& path, const std::function& call_back) { - auto args = new PurgeDirArgsWithCallBackArgs(path, call_back); - PurgeDirTaskSchedule(&DoPurgeDirWithCallBack, static_cast(args)); -} void PikaServer::PurgeDirTaskSchedule(void (*function)(void*), void* arg) { purge_thread_.set_thread_name("PurgeDirTask"); From 9a747d2b6a0ffa56fae2cff7c9306376094f9946 Mon Sep 17 00:00:00 2001 From: cheniujh <1271435567@qq.com> Date: Wed, 10 Jul 2024 16:06:51 +0800 Subject: [PATCH 3/6] remove debug remove debug log --- src/pika_db.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/src/pika_db.cc b/src/pika_db.cc index c8b5874e36..26f821b57c 100644 --- a/src/pika_db.cc +++ b/src/pika_db.cc @@ -208,7 +208,6 @@ bool DB::FlushDBWithoutLock() { delete_suffix.append(std::to_string(NowMicros())); delete_suffix.append("/"); dbpath.append(delete_suffix); - LOG(INFO) << "remaned:" << dbpath; auto rename_success = pstd::RenameFile(db_path_, dbpath); storage_ = std::make_shared(g_pika_conf->db_instance_num(), g_pika_conf->default_slot_num(), g_pika_conf->classic_mode()); From 7cd4d950e3649c9425f2b7f6330cea0cdb5c3f2f Mon Sep 17 00:00:00 2001 From: cheniujh <1271435567@qq.com> Date: Mon, 15 Jul 2024 16:26:59 +0800 Subject: [PATCH 4/6] change a return value to fixed "false" --- src/pika_admin.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pika_admin.cc b/src/pika_admin.cc index 785df8c4aa..9e1c4a4432 100644 --- a/src/pika_admin.cc +++ b/src/pika_admin.cc @@ -562,7 +562,7 @@ bool FlushallCmd::DoWithoutLock(std::shared_ptr db) { bool success = db->FlushDBWithoutLock(); if (!success) { // if the db is not flushed, return before clear the cache - return success; + return false; } DoUpdateCache(db); From 52e14ee747c9d52b107a141fda21244c587ad238 Mon Sep 17 00:00:00 2001 From: cheniujh <1271435567@qq.com> Date: Mon, 15 Jul 2024 18:19:11 +0800 Subject: [PATCH 5/6] add failed reason to user resp --- src/pika_admin.cc | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/src/pika_admin.cc b/src/pika_admin.cc index 9e1c4a4432..dc3b79fd45 100644 --- a/src/pika_admin.cc +++ b/src/pika_admin.cc @@ -518,7 +518,10 @@ void FlushallCmd::Do() { g_pika_rm->DBUnlock(); if (flushall_succeed_) { res_.SetRes(CmdRes::kOk); + } else if (res_.ret() == CmdRes::kErrOther){ + //flushdb failed and the res_ was set } else { + //flushall failed, but res_ was not set res_.SetRes(CmdRes::kErrOther, "Flushall failed, maybe only some of the dbs successfully flushed while some not, check WARNING/ERROR log to know " "more, you can try again moment later"); @@ -545,7 +548,8 @@ bool FlushallCmd::FlushAllWithoutLock() { std::shared_ptr db = db_item.second; DBInfo p_info(db->GetDBName()); if (g_pika_rm->GetSyncMasterDBs().find(p_info) == g_pika_rm->GetSyncMasterDBs().end()) { - LOG(ERROR) << p_info.db_name_ << " not found when flushall db"; + LOG(ERROR) << p_info.db_name_ + " not found when flushall db"; + res_.SetRes(CmdRes::kErrOther,p_info.db_name_ + " not found when flushall db"); return false; } bool success = DoWithoutLock(db); @@ -557,11 +561,13 @@ bool FlushallCmd::FlushAllWithoutLock() { bool FlushallCmd::DoWithoutLock(std::shared_ptr db) { if (!db) { LOG(ERROR) << "Flushall, but DB not found"; + res_.SetRes(CmdRes::kErrOther,db->GetDBName() + " not found when flushall db"); return false; } bool success = db->FlushDBWithoutLock(); if (!success) { // if the db is not flushed, return before clear the cache + res_.SetRes(CmdRes::kErrOther,db->GetDBName() + " flushall failed due to other Errors, please check Error/Warning log to know more"); return false; } DoUpdateCache(db); @@ -602,8 +608,10 @@ void FlushdbCmd::Do() { flush_succeed_ = DoWithoutLock(); if (flush_succeed_) { res_.SetRes(CmdRes::kOk); + } else if (res_.ret() == CmdRes::kErrOther || res_.ret() == CmdRes::kInvalidParameter) { + //flushdb failed and res_ was set } else { - res_.SetRes(CmdRes::kErrOther, "flushdb failed, Try again later(check WARNING/ERROR log to know more)"); + res_.SetRes(CmdRes::kErrOther, "flushdb failed, maybe you cna try again later(check WARNING/ERROR log to know more)"); } } @@ -624,17 +632,20 @@ void FlushdbCmd::DoUpdateCache() { bool FlushdbCmd::DoWithoutLock() { if (!db_) { - LOG(ERROR) << "Flushdb, but DB not found"; + LOG(ERROR) << db_name_ << " Flushdb, but DB not found"; + res_.SetRes(CmdRes::kErrOther, db_name_ + " Flushdb, but DB not found"); return false; } DBInfo p_info(db_->GetDBName()); if (g_pika_rm->GetSyncMasterDBs().find(p_info) == g_pika_rm->GetSyncMasterDBs().end()) { LOG(ERROR) << "DB not found when flushing " << db_->GetDBName(); + res_.SetRes(CmdRes::kErrOther, db_->GetDBName() + " Flushdb, but DB not found"); return false; } if (db_name_ != "all") { //Floyd does not support flushdb by type LOG(ERROR) << "cannot flushdb by type in floyd"; + res_.SetRes(CmdRes::kInvalidParameter, "cannot flushdb by type in floyd"); return false; } From 66daa772c57a165eab45b6a7d00685e78ad90a27 Mon Sep 17 00:00:00 2001 From: cheniujh <1271435567@qq.com> Date: Tue, 16 Jul 2024 11:12:45 +0800 Subject: [PATCH 6/6] removed duplicated logic --- src/pika_admin.cc | 7 ------- 1 file changed, 7 deletions(-) diff --git a/src/pika_admin.cc b/src/pika_admin.cc index dc3b79fd45..04f9bbbf5c 100644 --- a/src/pika_admin.cc +++ b/src/pika_admin.cc @@ -642,13 +642,6 @@ bool FlushdbCmd::DoWithoutLock() { res_.SetRes(CmdRes::kErrOther, db_->GetDBName() + " Flushdb, but DB not found"); return false; } - if (db_name_ != "all") { - //Floyd does not support flushdb by type - LOG(ERROR) << "cannot flushdb by type in floyd"; - res_.SetRes(CmdRes::kInvalidParameter, "cannot flushdb by type in floyd"); - return false; - } - return db_->FlushDBWithoutLock(); }