[feat][client] Use gflags for client command options

Author: meilirensheng2020

src/cache/benchmark/CMakeLists.txt

@@ -27,6 +27,7 @@ target_link_libraries(cache_benchmark
     cache_utils
     cache_common
     cache_storage
+    cache_tiercache
 )
 
 add_executable(cache-bench main.cc)

src/cache/cachegroup/cache_group_node_server.cc

@@ -25,6 +25,7 @@
 #include "cache/cachegroup/cache_group_node.h"
 #include "cache/cachegroup/cache_group_node_service.h"
 #include "cache/common/macro.h"
+#include "common/options/cache.h"
 
 namespace brpc {
 DECLARE_bool(graceful_quit_on_sigterm);

src/cache/common/mds_client.cc

@@ -46,7 +46,7 @@
 namespace dingofs {
 namespace cache {
 
-DEFINE_string(mds_addrs, "",
+DEFINE_string(mds_addrs, "127.0.0.1:7400",
               "Cache group member manager service rpc addresses");
 DEFINE_validator(mds_addrs, Helper::NonEmptyString);
 

src/client/CMakeLists.txt

@@ -29,6 +29,7 @@ target_link_libraries(fuse_client_lib
     dingofs_metrics
     dingofs_common
     client_options
+    cache_tiercache
     jsoncpp
     ${FUSE3_LIBRARY}
 )

src/client/common/client_option.h

@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2025 dingodb.com, Inc. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef DINGOFS_CLIENT_COMMON_CLIENT_OPTION_H_
+#define DINGOFS_CLIENT_COMMON_CLIENT_OPTION_H_
+
+#include <brpc/reloadable_flags.h>
+#include <gflags/gflags.h>
+
+#include <string>
+
+#include "common/blockaccess/accesser_common.h"
+#include "common/const.h"
+#include "common/options/client.h"
+
+namespace dingofs {
+namespace client {
+
+// fuse option
+struct FuseConnInfo {
+  bool want_splice_move;
+  bool want_splice_read;
+  bool want_splice_write;
+  bool want_auto_inval_data;
+};
+
+struct FuseFileInfo {
+  bool keep_cache;
+};
+
+struct FuseOption {
+  FuseConnInfo conn_info;
+  FuseFileInfo file_info;
+};
+
+// memory option
+struct PageOption {
+  uint32_t page_size;
+  uint64_t total_size;
+  bool use_pool;
+};
+
+// vfs option
+struct VFSMetaOption {
+  uint32_t max_name_length;  // max length of file name
+};
+
+struct VFSDataOption {
+  bool writeback{false};  // whether to use writeback
+  std::string writeback_suffix;
+};
+
+struct VFSOption {
+  blockaccess::BlockAccessOptions block_access_opt;  // from gflags
+  PageOption page_option;
+  FuseOption fuse_option;
+
+  VFSMetaOption meta_option;
+  VFSDataOption data_option;
+
+  uint32_t dummy_server_port{10000};
+};
+
+static void InitFuseOption(FuseOption* option) {
+  {  // fuse conn info
+    auto* fuse_conn_info = &option->conn_info;
+    fuse_conn_info->want_splice_move = FLAGS_fuse_conn_info_want_splice_move;
+    fuse_conn_info->want_splice_read = FLAGS_fuse_conn_info_want_splice_read;
+    fuse_conn_info->want_splice_write = FLAGS_fuse_conn_info_want_splice_write;
+    fuse_conn_info->want_auto_inval_data =
+        FLAGS_fuse_conn_info_want_auto_inval_data;
+  }
+
+  {  // fuse file info
+    auto* fuse_file_info = &option->file_info;
+    fuse_file_info->keep_cache = FLAGS_client_fuse_file_info_keep_cache;
+  }
+}
+
+static void InitMemoryPageOption(PageOption* option) {
+  // page option
+  option->page_size = FLAGS_data_stream_page_size;
+  option->total_size = FLAGS_data_stream_page_total_size_mb;
+  option->use_pool = FLAGS_data_stream_page_use_pool;
+
+  if (option->page_size == 0) {
+    CHECK(false) << "page size must greater than 0.";
+  }
+
+  option->total_size = option->total_size * kMiB;
+  if (option->total_size < 64 * kMiB) {
+    CHECK(false) << "page total size must greater than 64MB.";
+  }
+}
+
+static void InitVFSMetaOption(VFSMetaOption* option) {
+  option->max_name_length = FLAGS_vfs_meta_max_name_length;
+  if (option->max_name_length < 1) {
+    CHECK(false) << "file name length must greater than 0.";
+  }
+}
+
+static void InitVFSDataOption(VFSDataOption* option) {
+  option->writeback = FLAGS_vfs_data_writeback;
+  option->writeback_suffix = FLAGS_vfs_data_writeback_suffix;
+}
+
+static void InitVFSOption(VFSOption* option) {
+  blockaccess::InitAwsSdkConfig(
+      &option->block_access_opt.s3_options.aws_sdk_config);
+  blockaccess::InitBlockAccesserThrottleOptions(
+      &option->block_access_opt.throttle_options);
+
+  InitMemoryPageOption(&option->page_option);
+
+  InitFuseOption(&option->fuse_option);
+
+  InitVFSMetaOption(&option->meta_option);
+
+  InitVFSDataOption(&option->data_option);
+
+  option->dummy_server_port = FLAGS_vfs_dummy_server_port;
+}
+
+}  // namespace client
+}  // namespace dingofs
+
+#endif  // DINGOFS_CLIENT_COMMON_CLIENT_OPTION_H_

src/client/common/global_log.h

@@ -18,37 +18,21 @@
 #define DINGOFS_SRC_CLIENT_COMMON_GLOBAL_LOG_H_
 
 #include "common/options/client.h"
-#include "fmt/format.h"
 #include "glog/logging.h"
-#include "utils/configuration.h"
-#include "utils/gflags_helper.h"
-
-static int InitLog(const char* argv0, const std::string& conf_path) {
-  dingofs::utils::Configuration conf;
-  conf.SetConfigPath(conf_path);
-  if (!conf.LoadConfig()) {
-    LOG(ERROR) << "loadConfig fail, confPath=" << conf_path;
-    return 1;
-  }
 
+static int InitLog(const char* argv0) {
   // set log dir
-  if (FLAGS_log_dir.empty()) {
-    if (!conf.GetStringValue("client.common.logDir", &FLAGS_log_dir)) {
-      LOG(WARNING) << fmt::format(
-          "no client.common.logDir in {}, will log to /tmp.", conf_path);
-    }
-  }
-
-  dingofs::utils::GflagsLoadValueFromConfIfCmdNotSet dummy;
-  dummy.Load(&conf, "v", "client.loglevel", &FLAGS_v);
-  dingofs::client::FLAGS_vlog_level = FLAGS_v;
+  FLAGS_log_dir = dingofs::client::FLAGS_client_log_dir;
+  FLAGS_v = dingofs::client::FLAGS_client_log_level;
 
   FLAGS_logbufsecs = 4;
   FLAGS_minloglevel = google::GLOG_INFO;
   FLAGS_logbuflevel = google::GLOG_INFO;
 
   // initialize logging module
   google::InitGoogleLogging(argv0);
+  LOG(INFO) << "current verbose logging level is: " << FLAGS_v
+            << ", log dir is: " << FLAGS_log_dir;
 
   return 0;
 }

src/client/common/utils.h

@@ -28,6 +28,18 @@ static std::string Char2Addr(const char* p) {
   return oss.str();
 }
 
+inline bool ParseMetaURL(const std::string& meta_url, std::string& addrs,
+                         std::string& fs_name) {
+  size_t pos = meta_url.find('/');
+  if (pos == std::string::npos) {
+    return false;
+  }
+  addrs = meta_url.substr(0, pos);
+  fs_name = meta_url.substr(pos + 1);
+
+  return true;
+}
+
 }  // namespace client
 }  // namespace dingofs
 

src/client/fuse/fuse_common.h

@@ -46,42 +46,24 @@ using dingofs::utils::TrimSpace;
 
 const std::string kFdCommPathKey = "fd_comm_path";
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 struct MountOption {
-  const char* mount_point;
-  const char* fs_name;
-  const char* fs_type;
-  char* conf;
-  char* mds_addr;
+  std::string mount_point;
+  std::string fs_name;
+  std::string fs_type;
+  std::string mds_addrs;
 };
 
-static const struct fuse_opt kMountOpts[] = {
-    {"fsname=%s", offsetof(struct MountOption, fs_name), 0},
-
-    {"fstype=%s", offsetof(struct MountOption, fs_type), 0},
-
-    {"conf=%s", offsetof(struct MountOption, conf), 0},
-
-    FUSE_OPT_END};
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
-
 inline int FuseAddOpts(struct fuse_args* args, const char* arg_value) {
   if (fuse_opt_add_arg(args, "-o") == -1) return 1;
   if (fuse_opt_add_arg(args, arg_value) == -1) return 1;
   return 0;
 }
 
 // Get file inode number
-inline int GetFileInode(const char* file_name) {
+inline int GetFileInode(const std::string& file_name) {
   struct stat file_info;
 
-  if (stat(file_name, &file_info) == 0) {
+  if (stat(file_name.c_str(), &file_info) == 0) {
     return file_info.st_ino;
   }
   return -1;
@@ -161,7 +143,7 @@ inline std::string GetFdCommFileName(const std::string& filename) {
  *
  * @param mountpoint dingo-fuse mountpoint
  */
-inline bool CanShutdownGracefully(const char* mountpoint) {
+inline bool CanShutdownGracefully(const std::string& mountpoint) {
   if (GetFileInode(mountpoint) != dingofs::ROOTINODEID) {
     return false;
   }
@@ -175,7 +157,7 @@ inline bool CanShutdownGracefully(const char* mountpoint) {
  * @param mountpoint dingo-fuse mountpoint
  * @param fd file descriptor for /dev/fuse
  */
-inline void DingoSessionUnmount(const char* mountpoint, int fd) {
+inline void DingoSessionUnmount(const std::string& mountpoint, int fd) {
   int res;
 
   if (fd != -1) {
@@ -198,7 +180,7 @@ inline void DingoSessionUnmount(const char* mountpoint, int fd) {
     if (res == 1 && (pfd.revents & POLLERR)) return;
   }
 
-  res = umount2(mountpoint, 2);
+  res = umount2(mountpoint.c_str(), 2);
   if (res == 0) return;
 }
 

src/client/fuse/fuse_op.cc

@@ -36,7 +36,6 @@
 #include "common/status.h"
 #include "fmt/format.h"
 #include "glog/logging.h"
-#include "utils/configuration.h"
 
 static dingofs::client::vfs::VFSWrapper* g_vfs = nullptr;
 
@@ -310,9 +309,9 @@ static void ReplyStatfs(fuse_req_t req, const FsStat& stat) {
 
 int InitFuseClient(const char* argv0, const struct MountOption* mount_option) {
   dingofs::client::vfs::VFSConfig config = {
+      .mds_addrs = mount_option->mds_addrs,
       .mount_point = mount_option->mount_point,
       .fs_name = mount_option->fs_name,
-      .config_path = mount_option->conf,
       .fs_type = mount_option->fs_type,
   };