[refactor][cache] Remove mds-v1 related code.

Author: Wine93

conf/client.conf

@@ -41,7 +41,6 @@ disk_state.check_duration_ms=3000
 #### remote cache
 # {
 remote_cache.cache_group=
-remote_cache.mds_version=v2
 remote_cache.mds_addrs=127.0.0.1:6900
 remote_cache.mds_rpc_timeout_ms=3000
 remote_cache.mds_rpc_retry_times=1

src/cache/benchmark/benchmarker.cpp

@@ -29,12 +29,13 @@
 #include "cache/common/type.h"
 #include "cache/storage/storage_pool.h"
 #include "cache/tiercache/tier_block_cache.h"
+#include "options/cache/option.h"
 
 namespace dingofs {
 namespace cache {
 
 Benchmarker::Benchmarker()
-    : mds_client_(BuildSharedMDSClient()),
+    : mds_client_(std::make_shared<MDSClientImpl>(FLAGS_mds_addrs)),
       storage_pool_(std::make_shared<StoragePoolImpl>(mds_client_)),
       collector_(std::make_unique<Collector>()),
       reporter_(std::make_shared<Reporter>(collector_)),

src/cache/cachegroup/cache_group_node.cpp

@@ -35,16 +35,19 @@
 #include "cache/blockcache/block_cache_impl.h"
 #include "cache/common/const.h"
 #include "cache/common/macro.h"
+#include "cache/common/mds_client.h"
 #include "cache/metric/cache_group_node_metric.h"
 #include "cache/utils/context.h"
 #include "cache/utils/step_timer.h"
 #include "common/io_buffer.h"
 #include "common/status.h"
+#include "options/cache/option.h"
 
 namespace dingofs {
 namespace cache {
 
-DEFINE_string(id, "", "Specified the cache node id (only mds v2 required)");
+DEFINE_string(id, "", "Specified the cache node id");
+DEFINE_validator(id, Helper::NonEmptyString);
 
 DEFINE_string(group_name, "", "Which group this cache node belongs to");
 DEFINE_validator(group_name, Helper::NonEmptyString);
@@ -65,7 +68,7 @@ static const std::string kModule = "cachenode";
 
 CacheGroupNodeImpl::CacheGroupNodeImpl()
     : running_(false),
-      mds_client_(BuildSharedMDSClient()),
+      mds_client_(std::make_shared<MDSClientImpl>(FLAGS_mds_addrs)),
       member_(std::make_shared<CacheGroupNodeMemberImpl>(mds_client_)),
       heartbeat_(
           std::make_unique<CacheGroupNodeHeartbeatImpl>(member_, mds_client_)),

src/cache/common/mds_client.cpp

@@ -32,7 +32,6 @@
 #include <memory>
 #include <string>
 #include <unordered_map>
-#include <utility>
 
 #include "cache/common/macro.h"
 #include "cache/utils/helper.h"
@@ -52,17 +51,6 @@ DEFINE_string(mds_addrs, "",
               "Cache group member manager service rpc addresses");
 DEFINE_validator(mds_addrs, Helper::NonEmptyString);
 
-DEFINE_string(mds_version, "v2",
-              "MDS version for member managment, 'v1' or 'v2'");
-
-DEFINE_uint64(mdsv1_rpc_retry_total_ms, 16000, "");
-DEFINE_uint64(mdsv1_rpc_max_timeout_ms, 2000, "");
-DEFINE_uint64(mdsv1_rpc_timeout_ms, 500, "");
-DEFINE_uint64(mdsv1_rpc_retry_interval_us, 50000, "");
-DEFINE_uint64(mdsv1_rpc_max_failed_times_before_change_addr, 2, "");
-DEFINE_uint64(mdsv1_rpc_normal_retry_times_before_trigger_wait, 3, "");
-DEFINE_uint64(mdsv1_rpc_wait_sleep_ms, 1000, "");
-
 DEFINE_int64(mds_rpc_timeout_ms, 3000, "mds rpc timeout");
 DEFINE_validator(mds_rpc_timeout_ms, brpc::PassValidate);
 
@@ -72,12 +60,12 @@ DEFINE_validator(mds_rpc_retry_times, brpc::PassValidate);
 DEFINE_uint32(mds_request_retry_times, 3, "mds rpc request retry time");
 DEFINE_validator(mds_request_retry_times, brpc::PassValidate);
 
-MDSV2Client::MDSV2Client(const std::string& mds_addr)
+MDSClientImpl::MDSClientImpl(const std::string& mds_addr)
     : running_(false),
       rpc_(client::vfs::v2::RPC::New(mds_addr)),
       mds_discovery_(std::make_unique<client::vfs::v2::MDSDiscovery>(rpc_)) {}
 
-Status MDSV2Client::Start() {
+Status MDSClientImpl::Start() {
   CHECK_NOTNULL(rpc_);
   CHECK_NOTNULL(mds_discovery_);
 
@@ -100,7 +88,7 @@ Status MDSV2Client::Start() {
   return Status::OK();
 }
 
-Status MDSV2Client::Shutdown() {
+Status MDSClientImpl::Shutdown() {
   if (!running_.exchange(false)) {
     return Status::OK();
   }
@@ -116,23 +104,22 @@ Status MDSV2Client::Shutdown() {
   return Status::OK();
 }
 
-Status MDSV2Client::GetFSInfo(uint64_t fs_id,
-                              pb::common::StorageInfo* storage_info) {
+Status MDSClientImpl::GetFSInfo(uint64_t fs_id, pb::mds::FsInfo* fs_info) {
   pb::mds::GetFsInfoRequest request;
   pb::mds::GetFsInfoResponse response;
 
   request.set_fs_id(fs_id);
   auto status = SendRequest("MDSService", "GetFsInfo", request, response);
   if (status.ok()) {
-    *storage_info = ToCommonStorageInfo(response.fs_info());
+    *fs_info = response.fs_info();
   }
   return status;
 }
 
-Status MDSV2Client::JoinCacheGroup(const std::string& want_id,
-                                   const std::string& ip, uint32_t port,
-                                   const std::string& group_name,
-                                   uint32_t weight, std::string* member_id) {
+Status MDSClientImpl::JoinCacheGroup(const std::string& want_id,
+                                     const std::string& ip, uint32_t port,
+                                     const std::string& group_name,
+                                     uint32_t weight, std::string* member_id) {
   pb::mds::JoinCacheGroupRequest request;
   pb::mds::JoinCacheGroupResponse response;
 
@@ -157,9 +144,9 @@ Status MDSV2Client::JoinCacheGroup(const std::string& want_id,
   return Status::OK();
 }
 
-Status MDSV2Client::LeaveCacheGroup(const std::string& member_id,
-                                    const std::string& ip, uint32_t port,
-                                    const std::string& group_name) {
+Status MDSClientImpl::LeaveCacheGroup(const std::string& member_id,
+                                      const std::string& ip, uint32_t port,
+                                      const std::string& group_name) {
   pb::mds::LeaveCacheGroupRequest request;
   pb::mds::LeaveCacheGroupResponse response;
 
@@ -178,8 +165,8 @@ Status MDSV2Client::LeaveCacheGroup(const std::string& member_id,
   return status;
 }
 
-Status MDSV2Client::Heartbeat(const std::string& member_id,
-                              const std::string& ip, uint32_t port) {
+Status MDSClientImpl::Heartbeat(const std::string& member_id,
+                                const std::string& ip, uint32_t port) {
   pb::mds::HeartbeatRequest request;
   pb::mds::HeartbeatResponse response;
 
@@ -198,8 +185,8 @@ Status MDSV2Client::Heartbeat(const std::string& member_id,
   return status;
 }
 
-Status MDSV2Client::ListMembers(const std::string& group_name,
-                                std::vector<CacheGroupMember>* members) {
+Status MDSClientImpl::ListMembers(const std::string& group_name,
+                                  std::vector<CacheGroupMember>* members) {
   pb::mds::ListMembersRequest request;
   pb::mds::ListMembersResponse response;
 
@@ -224,46 +211,7 @@ Status MDSV2Client::ListMembers(const std::string& group_name,
   return Status::OK();
 }
 
-pb::common::S3Info MDSV2Client::ToCommonS3Info(const pb::mds::S3Info& in) {
-  pb::common::S3Info out;
-  out.set_ak(in.ak());
-  out.set_sk(in.sk());
-  out.set_endpoint(in.endpoint());
-  out.set_bucketname(in.bucketname());
-
-  return out;
-}
-
-pb::common::RadosInfo MDSV2Client::ToCommonRadosInfo(
-    const pb::mds::RadosInfo& in) {
-  pb::common::RadosInfo out;
-  out.set_user_name(in.user_name());
-  out.set_key(in.key());
-  out.set_mon_host(in.mon_host());
-  out.set_pool_name(in.pool_name());
-  out.set_cluster_name(in.cluster_name());
-
-  return out;
-}
-
-pb::common::StorageInfo MDSV2Client::ToCommonStorageInfo(
-    const pb::mds::FsInfo& fs_info) {
-  pb::common::StorageInfo out;
-  if (fs_info.fs_type() == pb::mds::FsType::S3) {
-    out.set_type(pb::common::StorageType::TYPE_S3);
-    *out.mutable_s3_info() = ToCommonS3Info(fs_info.extra().s3_info());
-  } else if (fs_info.fs_type() == pb::mds::FsType::RADOS) {
-    out.set_type(pb::common::StorageType::TYPE_RADOS);
-    *out.mutable_rados_info() = ToCommonRadosInfo(fs_info.extra().rados_info());
-  } else {
-    CHECK(false) << "Unsupported fs type: "
-                 << pb::mds::FsType_Name(fs_info.fs_type());
-  }
-
-  return out;
-}
-
-CacheGroupMemberState MDSV2Client::ToMemberState(
+CacheGroupMemberState MDSClientImpl::ToMemberState(
     pb::mds::CacheGroupMemberState state) {
   switch (state) {
     case pb::mds::CacheGroupMemberStateOnline:
@@ -278,7 +226,7 @@ CacheGroupMemberState MDSV2Client::ToMemberState(
   }
 }
 
-mds::MDSMeta MDSV2Client::GetRandomlyMDS(const mds::MDSMeta& old_mds) {
+mds::MDSMeta MDSClientImpl::GetRandomlyMDS(const mds::MDSMeta& old_mds) {
   auto mdses = mds_discovery_->GetNormalMDS(true);
   CHECK(!mdses.empty()) << "No normal mds found";
 
@@ -295,7 +243,7 @@ mds::MDSMeta MDSV2Client::GetRandomlyMDS(const mds::MDSMeta& old_mds) {
   return old_mds;
 }
 
-bool MDSV2Client::ShouldRetry(Status status) {
+bool MDSClientImpl::ShouldRetry(Status status) {
   static std::unordered_map<int, bool> should_retry_errnos = {
       {pb::error::EROUTER_EPOCH_CHANGE, true},
       {pb::error::ENOT_SERVE, true},
@@ -305,11 +253,11 @@ bool MDSV2Client::ShouldRetry(Status status) {
   return status.IsNetError() || should_retry_errnos.count(status.Errno()) != 0;
 }
 
-bool MDSV2Client::ShouldSetMDSAbormal(Status status) {
+bool MDSClientImpl::ShouldSetMDSAbormal(Status status) {
   return status.IsInternal() || status.IsNetError();
 }
 
-bool MDSV2Client::ShouldRefreshMDSList(Status status) {
+bool MDSClientImpl::ShouldRefreshMDSList(Status status) {
   static std::unordered_map<int, bool> should_refresh_errnos = {
       {pb::error::EROUTER_EPOCH_CHANGE, true},
       {pb::error::ENOT_SERVE, true},
@@ -319,9 +267,9 @@ bool MDSV2Client::ShouldRefreshMDSList(Status status) {
 }
 
 template <typename Request, typename Response>
-Status MDSV2Client::SendRequest(const std::string& service_name,
-                                const std::string& api_name, Request& request,
-                                Response& response) {
+Status MDSClientImpl::SendRequest(const std::string& service_name,
+                                  const std::string& api_name, Request& request,
+                                  Response& response) {
   mds::MDSMeta mds, old_mds;
   client::vfs::v2::SendRequestOption rpc_option;
   rpc_option.timeout_ms = FLAGS_mds_rpc_timeout_ms;
@@ -354,21 +302,5 @@ Status MDSV2Client::SendRequest(const std::string& service_name,
   return Status::Internal("send request fail");
 }
 
-MDSClientSPtr BuildSharedMDSClient() {
-  if (FLAGS_mds_version == "v2") {
-    return std::make_shared<MDSV2Client>(FLAGS_mds_addrs);
-  } else {
-    CHECK(false) << "Unsupported MDS version: " << FLAGS_mds_version;
-  }
-}
-
-MDSClientUPtr BuildUniqueMDSClient() {
-  if (FLAGS_mds_version == "v2") {
-    return std::make_unique<MDSV2Client>(FLAGS_mds_addrs);
-  } else {
-    CHECK(false) << "Unsupported MDS version: " << FLAGS_mds_version;
-  }
-}
-
 }  // namespace cache
 }  // namespace dingofs

src/cache/common/mds_client.h

@@ -30,6 +30,7 @@
 #include "client/vfs/meta/v2/rpc.h"
 #include "common/status.h"
 #include "dingofs/common.pb.h"
+#include "dingofs/mds.pb.h"
 #include "mds/mds/mds_meta.h"
 
 namespace dingofs {
@@ -84,8 +85,7 @@ class MDSClient {
   virtual Status Start() = 0;
   virtual Status Shutdown() = 0;
 
-  virtual Status GetFSInfo(uint64_t fs_id,
-                           pb::common::StorageInfo* storage_info) = 0;
+  virtual Status GetFSInfo(uint64_t fs_id, pb::mds::FsInfo* fs_info) = 0;
 
   virtual Status JoinCacheGroup(const std::string& want_id,
                                 const std::string& ip, uint32_t port,
@@ -103,15 +103,14 @@ class MDSClient {
 using MDSClientSPtr = std::shared_ptr<MDSClient>;
 using MDSClientUPtr = std::unique_ptr<MDSClient>;
 
-class MDSV2Client : public MDSClient {
+class MDSClientImpl : public MDSClient {
  public:
-  explicit MDSV2Client(const std::string& mds_addr);
+  explicit MDSClientImpl(const std::string& mds_addr);
 
   Status Start() override;
   Status Shutdown() override;
 
-  Status GetFSInfo(uint64_t fs_id,
-                   pb::common::StorageInfo* storage_info) override;
+  Status GetFSInfo(uint64_t fs_id, pb::mds::FsInfo* fs_info) override;
 
   Status JoinCacheGroup(const std::string& want_id, const std::string& ip,
                         uint32_t port, const std::string& group_name,
@@ -124,9 +123,6 @@ class MDSV2Client : public MDSClient {
                      std::vector<CacheGroupMember>* members) override;
 
  private:
-  pb::common::S3Info ToCommonS3Info(const pb::mds::S3Info& info);
-  pb::common::RadosInfo ToCommonRadosInfo(const pb::mds::RadosInfo& info);
-  pb::common::StorageInfo ToCommonStorageInfo(const pb::mds::FsInfo& info);
   CacheGroupMemberState ToMemberState(pb::mds::CacheGroupMemberState state);
 
   mds::MDSMeta GetRandomlyMDS(const mds::MDSMeta& old_mds);
@@ -144,9 +140,6 @@ class MDSV2Client : public MDSClient {
   std::unique_ptr<client::vfs::v2::MDSDiscovery> mds_discovery_;
 };
 
-MDSClientSPtr BuildSharedMDSClient();
-MDSClientUPtr BuildUniqueMDSClient();
-
 }  // namespace cache
 }  // namespace dingofs
 

src/cache/dingo_cache.cpp

@@ -50,12 +50,8 @@ int DingoCache::ParseFlags(int argc, char** argv) {
   }
 
   // validate flags
-  if (FLAGS_mds_version == "v1" && !FLAGS_id.empty()) {
-    std::cerr << "MDS v1 does not support cache node id, please remove the "
-                 "--id flag.\n";
-    return -1;
-  } else if (FLAGS_mds_version == "v2" && FLAGS_id.empty()) {
-    std::cerr << "MDS v2 requires cache node id, please set it by --id\n";
+  if (FLAGS_mds_addrs.empty()) {
+    std::cerr << "mds_addrs is empty, please set it by --mds_addrs\n";
     return -1;
   } else if (FLAGS_cache_store != "disk") {
     std::cerr

src/cache/remotecache/remote_cache_node_manager.cpp

@@ -26,9 +26,12 @@
 #include <gflags/gflags.h>
 #include <glog/logging.h>
 
+#include <memory>
+
 #include "cache/common/macro.h"
 #include "cache/common/mds_client.h"
 #include "cache/metric/cache_status.h"
+#include "options/cache/option.h"
 #include "utils/executor/bthread/bthread_executor.h"
 
 namespace dingofs {
@@ -39,7 +42,7 @@ DEFINE_uint32(load_members_interval_ms, 1000,
 
 RemoteCacheNodeManager::RemoteCacheNodeManager(OnMemberLoadFn on_member_load_fn)
     : running_(false),
-      mds_client_(BuildUniqueMDSClient()),
+      mds_client_(std::make_unique<MDSClientImpl>(FLAGS_mds_addrs)),
       on_member_load_fn_(on_member_load_fn),
       executor_(std::make_unique<BthreadExecutor>()) {}