refactor(cli): refactor object storage config (#7009)

* refactor: refactor object storage config Signed-off-by: WenyXu <wenymedia@gmail.com> * chore: public common config Signed-off-by: WenyXu <wenymedia@gmail.com> * chore: apply suggestions Signed-off-by: WenyXu <wenymedia@gmail.com> --------- Signed-off-by: WenyXu <wenymedia@gmail.com>
2026-05-30 20:00:36 +00:00 · 2025-09-24 14:50:47 +08:00
parent b5a8725582
commit 0c038f755f
23 changed files with 546 additions and 462 deletions
--- a/src/cli/Cargo.toml
+++ b/src/cli/Cargo.toml
@@ -51,6 +51,7 @@ meta-srv.workspace = true
 nu-ansi-term = "0.46"
 object-store.workspace = true
 operator.workspace = true
+paste.workspace = true
 query.workspace = true
 rand.workspace = true
 reqwest.workspace = true
--- a/src/cli/src/common.rs
+++ b/src/cli/src/common.rs
@@ -0,0 +1,19 @@
+// Copyright 2023 Greptime Team
+//
+// 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.
+
+mod object_store;
+mod store;
+
+pub use object_store::ObjectStoreConfig;
+pub use store::StoreConfig;
--- a/src/cli/src/common/object_store.rs
+++ b/src/cli/src/common/object_store.rs
@@ -0,0 +1,230 @@
+// Copyright 2023 Greptime Team
+//
+// 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.
+
+use common_base::secrets::SecretString;
+use common_error::ext::BoxedError;
+use object_store::config::FileConfig;
+use object_store::services::{Azblob, Gcs, Oss, S3};
+use object_store::util::{with_instrument_layers, with_retry_layers};
+use object_store::{AzblobConnection, GcsConnection, ObjectStore, OssConnection, S3Connection};
+use paste::paste;
+use snafu::ResultExt;
+
+use crate::error::{self};
+
+macro_rules! wrap_with_clap_prefix {
+    (
+        $new_name:ident, $prefix:literal, $base:ty, {
+            $( $( #[doc = $doc:expr] )? $( #[alias = $alias:literal] )? $field:ident : $type:ty $( = $default:expr )? ),* $(,)?
+        }
+    ) => {
+        paste!{
+            #[derive(clap::Parser, Debug, Clone, PartialEq, Default)]
+            pub struct $new_name {
+                $(
+                    $( #[doc = $doc] )?
+                    $( #[clap(alias = $alias)] )?
+                    #[clap(long $(, default_value_t = $default )? )]
+                    [<$prefix $field>]: $type,
+                )*
+            }
+
+            impl From<$new_name> for $base {
+                fn from(w: $new_name) -> Self {
+                    Self {
+                        $( $field: w.[<$prefix $field>] ),*
+                    }
+                }
+            }
+        }
+    };
+}
+
+wrap_with_clap_prefix! {
+    PrefixedAzblobConnection,
+    "azblob-",
+    AzblobConnection,
+    {
+        #[doc = "The container of the object store."]
+        container: String = Default::default(),
+        #[doc = "The root of the object store."]
+        root: String = Default::default(),
+        #[doc = "The account name of the object store."]
+        account_name: SecretString = Default::default(),
+        #[doc = "The account key of the object store."]
+        account_key: SecretString = Default::default(),
+        #[doc = "The endpoint of the object store."]
+        endpoint: String = Default::default(),
+        #[doc = "The SAS token of the object store."]
+        sas_token: Option<String>,
+    }
+}
+
+wrap_with_clap_prefix! {
+    PrefixedS3Connection,
+    "s3-",
+    S3Connection,
+    {
+        #[doc = "The bucket of the object store."]
+        bucket: String = Default::default(),
+        #[doc = "The root of the object store."]
+        root: String = Default::default(),
+        #[doc = "The access key ID of the object store."]
+        access_key_id: SecretString = Default::default(),
+        #[doc = "The secret access key of the object store."]
+        secret_access_key: SecretString = Default::default(),
+        #[doc = "The endpoint of the object store."]
+        endpoint: Option<String>,
+        #[doc = "The region of the object store."]
+        region: Option<String>,
+        #[doc = "Enable virtual host style for the object store."]
+        enable_virtual_host_style: bool = Default::default(),
+    }
+}
+
+wrap_with_clap_prefix! {
+    PrefixedOssConnection,
+    "oss-",
+    OssConnection,
+    {
+        #[doc = "The bucket of the object store."]
+        bucket: String = Default::default(),
+        #[doc = "The root of the object store."]
+        root: String = Default::default(),
+        #[doc = "The access key ID of the object store."]
+        access_key_id: SecretString = Default::default(),
+        #[doc = "The access key secret of the object store."]
+        access_key_secret: SecretString = Default::default(),
+        #[doc = "The endpoint of the object store."]
+        endpoint: String = Default::default(),
+    }
+}
+
+wrap_with_clap_prefix! {
+    PrefixedGcsConnection,
+    "gcs-",
+    GcsConnection,
+    {
+        #[doc = "The root of the object store."]
+        root: String = Default::default(),
+        #[doc = "The bucket of the object store."]
+        bucket: String = Default::default(),
+        #[doc = "The scope of the object store."]
+        scope: String = Default::default(),
+        #[doc = "The credential path of the object store."]
+        credential_path: SecretString = Default::default(),
+        #[doc = "The credential of the object store."]
+        credential: SecretString = Default::default(),
+        #[doc = "The endpoint of the object store."]
+        endpoint: String = Default::default(),
+    }
+}
+
+/// common config for object store.
+#[derive(clap::Parser, Debug, Clone, PartialEq, Default)]
+pub struct ObjectStoreConfig {
+    /// Whether to use S3 object store.
+    #[clap(long, alias = "s3")]
+    pub enable_s3: bool,
+
+    #[clap(flatten)]
+    pub s3: PrefixedS3Connection,
+
+    /// Whether to use OSS.
+    #[clap(long, alias = "oss")]
+    pub enable_oss: bool,
+
+    #[clap(flatten)]
+    pub oss: PrefixedOssConnection,
+
+    /// Whether to use GCS.
+    #[clap(long, alias = "gcs")]
+    pub enable_gcs: bool,
+
+    #[clap(flatten)]
+    pub gcs: PrefixedGcsConnection,
+
+    /// Whether to use Azure Blob.
+    #[clap(long, alias = "azblob")]
+    pub enable_azblob: bool,
+
+    #[clap(flatten)]
+    pub azblob: PrefixedAzblobConnection,
+}
+
+/// Creates a new file system object store.
+pub fn new_fs_object_store_in_current_dir() -> std::result::Result<ObjectStore, BoxedError> {
+    let data_home = ".";
+    let object_store =
+        object_store::factory::new_fs_object_store(data_home, &FileConfig::default())
+            .map_err(BoxedError::new)?;
+
+    Ok(with_instrument_layers(object_store, false))
+}
+
+impl ObjectStoreConfig {
+    /// Builds the object store from the config.
+    pub fn build(&self) -> Result<ObjectStore, BoxedError> {
+        let object_store = if self.enable_s3 {
+            let s3 = S3Connection::from(self.s3.clone());
+            common_telemetry::info!("Building object store with s3: {:?}", s3);
+            Some(
+                ObjectStore::new(S3::from(&s3))
+                    .context(error::InitBackendSnafu)
+                    .map_err(BoxedError::new)?
+                    .finish(),
+            )
+        } else if self.enable_oss {
+            let oss = OssConnection::from(self.oss.clone());
+            common_telemetry::info!("Building object store with oss: {:?}", oss);
+            Some(
+                ObjectStore::new(Oss::from(&oss))
+                    .context(error::InitBackendSnafu)
+                    .map_err(BoxedError::new)?
+                    .finish(),
+            )
+        } else if self.enable_gcs {
+            let gcs = GcsConnection::from(self.gcs.clone());
+            common_telemetry::info!("Building object store with gcs: {:?}", gcs);
+            Some(
+                ObjectStore::new(Gcs::from(&gcs))
+                    .context(error::InitBackendSnafu)
+                    .map_err(BoxedError::new)?
+                    .finish(),
+            )
+        } else if self.enable_azblob {
+            let azblob = AzblobConnection::from(self.azblob.clone());
+            common_telemetry::info!("Building object store with azblob: {:?}", azblob);
+            Some(
+                ObjectStore::new(Azblob::from(&azblob))
+                    .context(error::InitBackendSnafu)
+                    .map_err(BoxedError::new)?
+                    .finish(),
+            )
+        } else {
+            None
+        };
+
+        let object_store = object_store
+            .map(|object_store| with_instrument_layers(with_retry_layers(object_store), false));
+
+        match object_store {
+            Some(object_store) => Ok(object_store),
+            None => Ok(with_instrument_layers(
+                new_fs_object_store_in_current_dir()?,
+                false,
+            )),
+        }
+    }
+}
--- a/src/cli/src/metadata/common.rs
+++ b/src/cli/src/metadata/common.rs
@@ -26,7 +26,7 @@ use servers::tls::{TlsMode, TlsOption};
 use crate::error::{EmptyStoreAddrsSnafu, UnsupportedMemoryBackendSnafu};

 #[derive(Debug, Default, Parser)]
-pub(crate) struct StoreConfig {
+pub struct StoreConfig {
    /// The endpoint of store. one of etcd, postgres or mysql.
    ///
    /// For postgres store, the format is:
@@ -38,48 +38,48 @@ pub(crate) struct StoreConfig {
    /// For mysql store, the format is:
    /// "mysql://user:password@ip:port/dbname"
    #[clap(long, alias = "store-addr", value_delimiter = ',', num_args = 1..)]
-    store_addrs: Vec<String>,
+    pub store_addrs: Vec<String>,

    /// The maximum number of operations in a transaction. Only used when using [etcd-store].
    #[clap(long, default_value = "128")]
-    max_txn_ops: usize,
+    pub max_txn_ops: usize,

    /// The metadata store backend.
    #[clap(long, value_enum, default_value = "etcd-store")]
-    backend: BackendImpl,
+    pub backend: BackendImpl,

    /// The key prefix of the metadata store.
    #[clap(long, default_value = "")]
-    store_key_prefix: String,
+    pub store_key_prefix: String,

    /// The table name in RDS to store metadata. Only used when using [postgres-store] or [mysql-store].
    #[cfg(any(feature = "pg_kvbackend", feature = "mysql_kvbackend"))]
    #[clap(long, default_value = common_meta::kv_backend::DEFAULT_META_TABLE_NAME)]
-    meta_table_name: String,
+    pub meta_table_name: String,

    /// Optional PostgreSQL schema for metadata table (defaults to current search_path if unset).
    #[cfg(feature = "pg_kvbackend")]
    #[clap(long)]
-    meta_schema_name: Option<String>,
+    pub meta_schema_name: Option<String>,
    /// TLS mode for backend store connections (etcd, PostgreSQL, MySQL)
    #[clap(long = "backend-tls-mode", value_enum, default_value = "disable")]
-    backend_tls_mode: TlsMode,
+    pub backend_tls_mode: TlsMode,

    /// Path to TLS certificate file for backend store connections
    #[clap(long = "backend-tls-cert-path", default_value = "")]
-    backend_tls_cert_path: String,
+    pub backend_tls_cert_path: String,

    /// Path to TLS private key file for backend store connections
    #[clap(long = "backend-tls-key-path", default_value = "")]
-    backend_tls_key_path: String,
+    pub backend_tls_key_path: String,

    /// Path to TLS CA certificate file for backend store connections
    #[clap(long = "backend-tls-ca-cert-path", default_value = "")]
-    backend_tls_ca_cert_path: String,
+    pub backend_tls_ca_cert_path: String,

    /// Enable watching TLS certificate files for changes
    #[clap(long = "backend-tls-watch")]
-    backend_tls_watch: bool,
+    pub backend_tls_watch: bool,
 }

 impl StoreConfig {
@@ -104,6 +104,11 @@ impl StoreConfig {
        if store_addrs.is_empty() {
            EmptyStoreAddrsSnafu.fail().map_err(BoxedError::new)
        } else {
+            common_telemetry::info!(
+                "Building kvbackend with store addrs: {:?}, backend: {:?}",
+                store_addrs,
+                self.backend
+            );
            let kvbackend = match self.backend {
                BackendImpl::EtcdStore => {
                    let tls_config = self.tls_config();
--- a/src/cli/src/lib.rs
+++ b/src/cli/src/lib.rs
@@ -14,6 +14,7 @@

 #![allow(clippy::print_stdout)]
 mod bench;
+mod common;
 mod data;
 mod database;
 pub mod error;
@@ -21,6 +22,7 @@ mod metadata;

 use async_trait::async_trait;
 use clap::Parser;
+pub use common::{ObjectStoreConfig, StoreConfig};
 use common_error::ext::BoxedError;
 pub use database::DatabaseClient;
 use error::Result;
--- a/src/cli/src/metadata.rs
+++ b/src/cli/src/metadata.rs
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-mod common;
 mod control;
 mod repair;
 mod snapshot;
--- a/src/cli/src/metadata/control/del/key.rs
+++ b/src/cli/src/metadata/control/del/key.rs
@@ -20,7 +20,7 @@ use common_meta::kv_backend::KvBackendRef;
 use common_meta::rpc::store::RangeRequest;

 use crate::Tool;
-use crate::metadata::common::StoreConfig;
+use crate::common::StoreConfig;
 use crate::metadata::control::del::CLI_TOMBSTONE_PREFIX;

 /// Delete key-value pairs logically from the metadata store.
--- a/src/cli/src/metadata/control/del/table.rs
+++ b/src/cli/src/metadata/control/del/table.rs
@@ -24,8 +24,8 @@ use common_meta::kv_backend::KvBackendRef;
 use store_api::storage::TableId;

 use crate::Tool;
+use crate::common::StoreConfig;
 use crate::error::{InvalidArgumentsSnafu, TableNotFoundSnafu};
-use crate::metadata::common::StoreConfig;
 use crate::metadata::control::del::CLI_TOMBSTONE_PREFIX;
 use crate::metadata::control::utils::get_table_id_by_name;

@@ -48,6 +48,7 @@ pub struct DelTableCommand {
    #[clap(long, default_value = DEFAULT_CATALOG_NAME)]
    catalog_name: String,

+    /// The store config.
    #[clap(flatten)]
    store: StoreConfig,
 }
--- a/src/cli/src/metadata/control/get.rs
+++ b/src/cli/src/metadata/control/get.rs
@@ -28,8 +28,8 @@ use common_meta::rpc::store::RangeRequest;
 use futures::TryStreamExt;

 use crate::Tool;
+use crate::common::StoreConfig;
 use crate::error::InvalidArgumentsSnafu;
-use crate::metadata::common::StoreConfig;
 use crate::metadata::control::utils::{decode_key_value, get_table_id_by_name, json_fromatter};

 /// Getting metadata from metadata store.
--- a/src/cli/src/metadata/repair.rs
+++ b/src/cli/src/metadata/repair.rs
@@ -38,10 +38,10 @@ use snafu::{ResultExt, ensure};
 use store_api::storage::TableId;

 use crate::Tool;
+use crate::common::StoreConfig;
 use crate::error::{
    InvalidArgumentsSnafu, Result, SendRequestToDatanodeSnafu, TableMetadataSnafu, UnexpectedSnafu,
 };
-use crate::metadata::common::StoreConfig;
 use crate::metadata::utils::{FullTableMetadata, IteratorInput, TableMetadataIterator};

 /// Repair metadata of logical tables.
--- a/src/cli/src/metadata/snapshot.rs
+++ b/src/cli/src/metadata/snapshot.rs
@@ -16,16 +16,14 @@ use std::path::Path;

 use async_trait::async_trait;
 use clap::{Parser, Subcommand};
-use common_base::secrets::{ExposeSecret, SecretString};
 use common_error::ext::BoxedError;
 use common_meta::snapshot::MetadataSnapshotManager;
 use object_store::ObjectStore;
-use object_store::services::{Fs, S3};
-use snafu::{OptionExt, ResultExt};
+use snafu::OptionExt;

 use crate::Tool;
-use crate::error::{InvalidFilePathSnafu, OpenDalSnafu, S3ConfigNotSetSnafu};
-use crate::metadata::common::StoreConfig;
+use crate::common::{ObjectStoreConfig, StoreConfig};
+use crate::error::UnexpectedSnafu;

 /// Subcommand for metadata snapshot operations, including saving snapshots, restoring from snapshots, and viewing snapshot information.
 #[derive(Subcommand)]
@@ -48,65 +46,6 @@ impl SnapshotCommand {
    }
 }

-// TODO(qtang): Abstract a generic s3 config for export import meta snapshot restore
-#[derive(Debug, Default, Parser)]
-struct S3Config {
-    /// whether to use s3 as the output directory. default is false.
-    #[clap(long, default_value = "false")]
-    s3: bool,
-    /// The s3 bucket name.
-    #[clap(long)]
-    s3_bucket: Option<String>,
-    /// The s3 region.
-    #[clap(long)]
-    s3_region: Option<String>,
-    /// The s3 access key.
-    #[clap(long)]
-    s3_access_key: Option<SecretString>,
-    /// The s3 secret key.
-    #[clap(long)]
-    s3_secret_key: Option<SecretString>,
-    /// The s3 endpoint. we will automatically use the default s3 decided by the region if not set.
-    #[clap(long)]
-    s3_endpoint: Option<String>,
-}
-
-impl S3Config {
-    pub fn build(&self, root: &str) -> Result<Option<ObjectStore>, BoxedError> {
-        if !self.s3 {
-            Ok(None)
-        } else {
-            if self.s3_region.is_none()
-                || self.s3_access_key.is_none()
-                || self.s3_secret_key.is_none()
-                || self.s3_bucket.is_none()
-            {
-                return S3ConfigNotSetSnafu.fail().map_err(BoxedError::new);
-            }
-            // Safety, unwrap is safe because we have checked the options above.
-            let mut config = S3::default()
-                .bucket(self.s3_bucket.as_ref().unwrap())
-                .region(self.s3_region.as_ref().unwrap())
-                .access_key_id(self.s3_access_key.as_ref().unwrap().expose_secret())
-                .secret_access_key(self.s3_secret_key.as_ref().unwrap().expose_secret());
-
-            if !root.is_empty() && root != "." {
-                config = config.root(root);
-            }
-
-            if let Some(endpoint) = &self.s3_endpoint {
-                config = config.endpoint(endpoint);
-            }
-            Ok(Some(
-                ObjectStore::new(config)
-                    .context(OpenDalSnafu)
-                    .map_err(BoxedError::new)?
-                    .finish(),
-            ))
-        }
-    }
-}
-
 /// Export metadata snapshot tool.
 /// This tool is used to export metadata snapshot from etcd, pg or mysql.
 /// It will dump the metadata snapshot to local file or s3 bucket.
@@ -116,60 +55,41 @@ pub struct SaveCommand {
    /// The store configuration.
    #[clap(flatten)]
    store: StoreConfig,
-    /// The s3 config.
+    /// The object store configuration.
    #[clap(flatten)]
-    s3_config: S3Config,
+    object_store: ObjectStoreConfig,
    /// The name of the target snapshot file. we will add the file extension automatically.
    #[clap(long, default_value = "metadata_snapshot")]
    file_name: String,
    /// The directory to store the snapshot file.
-    /// if target output is s3 bucket, this is the root directory in the bucket.
-    /// if target output is local file, this is the local directory.
-    #[clap(long, default_value = "")]
-    output_dir: String,
-}
-
-fn create_local_file_object_store(root: &str) -> Result<ObjectStore, BoxedError> {
-    let root = if root.is_empty() { "." } else { root };
-    let object_store = ObjectStore::new(Fs::default().root(root))
-        .context(OpenDalSnafu)
-        .map_err(BoxedError::new)?
-        .finish();
-    Ok(object_store)
+    #[clap(long, default_value = "", alias = "output_dir")]
+    dir: String,
 }

 impl SaveCommand {
    pub async fn build(&self) -> Result<Box<dyn Tool>, BoxedError> {
        let kvbackend = self.store.build().await?;
-        let output_dir = &self.output_dir;
-        let object_store = self.s3_config.build(output_dir).map_err(BoxedError::new)?;
-        if let Some(store) = object_store {
-            let tool = MetaSnapshotTool {
-                inner: MetadataSnapshotManager::new(kvbackend, store),
-                target_file: self.file_name.clone(),
-            };
-            Ok(Box::new(tool))
-        } else {
-            let object_store = create_local_file_object_store(output_dir)?;
-            let tool = MetaSnapshotTool {
-                inner: MetadataSnapshotManager::new(kvbackend, object_store),
-                target_file: self.file_name.clone(),
-            };
-            Ok(Box::new(tool))
-        }
+        let object_store = self.object_store.build().map_err(BoxedError::new)?;
+        let tool = MetaSnapshotTool {
+            inner: MetadataSnapshotManager::new(kvbackend, object_store),
+            path: self.dir.clone(),
+            file_name: self.file_name.clone(),
+        };
+        Ok(Box::new(tool))
    }
 }

 struct MetaSnapshotTool {
    inner: MetadataSnapshotManager,
-    target_file: String,
+    path: String,
+    file_name: String,
 }

 #[async_trait]
 impl Tool for MetaSnapshotTool {
    async fn do_work(&self) -> std::result::Result<(), BoxedError> {
        self.inner
-            .dump("", &self.target_file)
+            .dump(&self.path, &self.file_name)
            .await
            .map_err(BoxedError::new)?;
        Ok(())
@@ -186,15 +106,15 @@ pub struct RestoreCommand {
    /// The store configuration.
    #[clap(flatten)]
    store: StoreConfig,
-    /// The s3 config.
+    /// The object store config.
    #[clap(flatten)]
-    s3_config: S3Config,
+    object_store: ObjectStoreConfig,
    /// The name of the target snapshot file.
    #[clap(long, default_value = "metadata_snapshot.metadata.fb")]
    file_name: String,
    /// The directory to store the snapshot file.
-    #[clap(long, default_value = ".")]
-    input_dir: String,
+    #[clap(long, default_value = ".", alias = "input_dir")]
+    dir: String,
    #[clap(long, default_value = "false")]
    force: bool,
 }
@@ -202,38 +122,39 @@ pub struct RestoreCommand {
 impl RestoreCommand {
    pub async fn build(&self) -> Result<Box<dyn Tool>, BoxedError> {
        let kvbackend = self.store.build().await?;
-        let input_dir = &self.input_dir;
-        let object_store = self.s3_config.build(input_dir).map_err(BoxedError::new)?;
-        if let Some(store) = object_store {
-            let tool = MetaRestoreTool::new(
-                MetadataSnapshotManager::new(kvbackend, store),
-                self.file_name.clone(),
-                self.force,
-            );
-            Ok(Box::new(tool))
-        } else {
-            let object_store = create_local_file_object_store(input_dir)?;
-            let tool = MetaRestoreTool::new(
-                MetadataSnapshotManager::new(kvbackend, object_store),
-                self.file_name.clone(),
-                self.force,
-            );
-            Ok(Box::new(tool))
-        }
+        let input_dir = &self.dir;
+        let file_path = Path::new(input_dir).join(&self.file_name);
+        let file_path = file_path
+            .to_str()
+            .with_context(|| UnexpectedSnafu {
+                msg: format!(
+                    "Invalid file path, input dir: {}, file name: {}",
+                    input_dir, &self.file_name
+                ),
+            })
+            .map_err(BoxedError::new)?;
+
+        let object_store = self.object_store.build().map_err(BoxedError::new)?;
+        let tool = MetaRestoreTool::new(
+            MetadataSnapshotManager::new(kvbackend, object_store),
+            file_path.to_string(),
+            self.force,
+        );
+        Ok(Box::new(tool))
    }
 }

 struct MetaRestoreTool {
    inner: MetadataSnapshotManager,
-    source_file: String,
+    file_path: String,
    force: bool,
 }

 impl MetaRestoreTool {
-    pub fn new(inner: MetadataSnapshotManager, source_file: String, force: bool) -> Self {
+    pub fn new(inner: MetadataSnapshotManager, file_path: String, force: bool) -> Self {
        Self {
            inner,
-            source_file,
+            file_path,
            force,
        }
    }
@@ -252,7 +173,7 @@ impl Tool for MetaRestoreTool {
                "The target source is clean, we will restore the metadata snapshot."
            );
            self.inner
-                .restore(&self.source_file)
+                .restore(&self.file_path)
                .await
                .map_err(BoxedError::new)?;
            Ok(())
@@ -266,7 +187,7 @@ impl Tool for MetaRestoreTool {
                "The target source is not clean, We will restore the metadata snapshot with --force."
            );
            self.inner
-                .restore(&self.source_file)
+                .restore(&self.file_path)
                .await
                .map_err(BoxedError::new)?;
            Ok(())
@@ -280,12 +201,15 @@ impl Tool for MetaRestoreTool {
 /// It prints the filtered metadata to the console.
 #[derive(Debug, Default, Parser)]
 pub struct InfoCommand {
-    /// The s3 config.
+    /// The object store config.
    #[clap(flatten)]
-    s3_config: S3Config,
+    object_store: ObjectStoreConfig,
    /// The name of the target snapshot file. we will add the file extension automatically.
    #[clap(long, default_value = "metadata_snapshot")]
    file_name: String,
+    /// The directory to store the snapshot file.
+    #[clap(long, default_value = ".", alias = "input_dir")]
+    dir: String,
    /// The query string to filter the metadata.
    #[clap(long, default_value = "*")]
    inspect_key: String,
@@ -296,7 +220,7 @@ pub struct InfoCommand {

 struct MetaInfoTool {
    inner: ObjectStore,
-    source_file: String,
+    file_path: String,
    inspect_key: String,
    limit: Option<usize>,
 }
@@ -306,7 +230,7 @@ impl Tool for MetaInfoTool {
    async fn do_work(&self) -> std::result::Result<(), BoxedError> {
        let result = MetadataSnapshotManager::info(
            &self.inner,
-            &self.source_file,
+            &self.file_path,
            &self.inspect_key,
            self.limit,
        )
@@ -320,45 +244,24 @@ impl Tool for MetaInfoTool {
 }

 impl InfoCommand {
-    fn decide_object_store_root_for_local_store(
-        file_path: &str,
-    ) -> Result<(&str, &str), BoxedError> {
-        let path = Path::new(file_path);
-        let parent = path
-            .parent()
-            .and_then(|p| p.to_str())
-            .context(InvalidFilePathSnafu { msg: file_path })
-            .map_err(BoxedError::new)?;
-        let file_name = path
-            .file_name()
-            .and_then(|f| f.to_str())
-            .context(InvalidFilePathSnafu { msg: file_path })
-            .map_err(BoxedError::new)?;
-        let root = if parent.is_empty() { "." } else { parent };
-        Ok((root, file_name))
-    }
-
    pub async fn build(&self) -> Result<Box<dyn Tool>, BoxedError> {
-        let object_store = self.s3_config.build("").map_err(BoxedError::new)?;
-        if let Some(store) = object_store {
-            let tool = MetaInfoTool {
-                inner: store,
-                source_file: self.file_name.clone(),
-                inspect_key: self.inspect_key.clone(),
-                limit: self.limit,
-            };
-            Ok(Box::new(tool))
-        } else {
-            let (root, file_name) =
-                Self::decide_object_store_root_for_local_store(&self.file_name)?;
-            let object_store = create_local_file_object_store(root)?;
-            let tool = MetaInfoTool {
-                inner: object_store,
-                source_file: file_name.to_string(),
-                inspect_key: self.inspect_key.clone(),
-                limit: self.limit,
-            };
-            Ok(Box::new(tool))
-        }
+        let object_store = self.object_store.build().map_err(BoxedError::new)?;
+        let file_path = Path::new(&self.dir).join(&self.file_name);
+        let file_path = file_path
+            .to_str()
+            .with_context(|| UnexpectedSnafu {
+                msg: format!(
+                    "Invalid file path, input dir: {}, file name: {}",
+                    &self.dir, &self.file_name
+                ),
+            })
+            .map_err(BoxedError::new)?;
+        let tool = MetaInfoTool {
+            inner: object_store,
+            file_path: file_path.to_string(),
+            inspect_key: self.inspect_key.clone(),
+            limit: self.limit,
+        };
+        Ok(Box::new(tool))
    }
 }