diff --git a/Cargo.lock b/Cargo.lock
index 3a57111a6..a65c7ab5f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -541,6 +541,26 @@ dependencies = [
  "rand_core",
 ]
 
+[[package]]
+name = "darwin-libproc"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fb90051930c9a0f09e585762152048e23ac74d20c10590ef7cf01c0343c3046"
+dependencies = [
+ "darwin-libproc-sys",
+ "libc",
+ "memchr",
+]
+
+[[package]]
+name = "darwin-libproc-sys"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57cebb5bde66eecdd30ddc4b9cd208238b15db4982ccc72db59d699ea10867c1"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "deranged"
 version = "0.3.11"
@@ -551,6 +571,17 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "derive_more"
+version = "0.99.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f33878137e4dafd7fa914ad4e259e18a4e8e532b9617a2d0150262bf53abfce"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "digest"
 version = "0.10.7"
@@ -594,6 +625,8 @@ dependencies = [
  "lazy_static",
  "lock",
  "protos",
+ "rmp-serde",
+ "serde",
  "serde_json",
  "tokio",
  "tonic",
@@ -614,6 +647,7 @@ dependencies = [
  "bytesize",
  "common",
  "crc32fast",
+ "flatbuffers",
  "futures",
  "glob",
  "hex-simd",
@@ -623,7 +657,7 @@ dependencies = [
  "lock",
  "md-5",
  "netif",
- "nix",
+ "nix 0.29.0",
  "num",
  "num_cpus",
  "openssl",
@@ -1407,6 +1441,24 @@ dependencies = [
  "hashbrown 0.12.3",
 ]
 
+[[package]]
+name = "mach2"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19b955cdeb2a02b9117f121ce63aa52d08ade45de53e48fe6a38b39c10f6f709"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "madmin"
+version = "0.0.1"
+dependencies = [
+ "ecstore",
+ "psutil",
+ "serde",
+]
+
 [[package]]
 name = "matchers"
 version = "0.1.0"
@@ -1493,6 +1545,17 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "nix"
+version = "0.24.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa52e972a9a719cecb6864fb88568781eb706bac2cd1d4f04a648542dbf78069"
+dependencies = [
+ "bitflags 1.3.2",
+ "cfg-if",
+ "libc",
+]
+
 [[package]]
 name = "nix"
 version = "0.29.0"
@@ -1812,6 +1875,12 @@ version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
 
+[[package]]
+name = "platforms"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8d0eef3571242013a0d5dc84861c3ae4a652e56e12adf8bdc26ff5f8cb34c94"
+
 [[package]]
 name = "powerfmt"
 version = "0.2.0"
@@ -1934,6 +2003,25 @@ dependencies = [
  "tower 0.5.1",
 ]
 
+[[package]]
+name = "psutil"
+version = "3.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e617cc9058daa5e1fe5a0d23ed745773a5ee354111dad1ec0235b0cc16b6730"
+dependencies = [
+ "cfg-if",
+ "darwin-libproc",
+ "derive_more",
+ "glob",
+ "mach2",
+ "nix 0.24.3",
+ "num_cpus",
+ "once_cell",
+ "platforms",
+ "thiserror",
+ "unescape",
+]
+
 [[package]]
 name = "quick-xml"
 version = "0.37.0"
@@ -2143,6 +2231,7 @@ dependencies = [
  "lazy_static",
  "lock",
  "log",
+ "madmin",
  "matchit 0.8.5",
  "mime",
  "netif",
@@ -2152,6 +2241,7 @@ dependencies = [
  "prost-types",
  "protobuf",
  "protos",
+ "rmp-serde",
  "s3s",
  "serde",
  "serde_json",
@@ -2169,6 +2259,7 @@ dependencies = [
  "tracing-error",
  "tracing-subscriber",
  "transform-stream",
+ "url",
  "uuid",
 ]
 
@@ -2896,6 +2987,12 @@ dependencies = [
  "tz-rs",
 ]
 
+[[package]]
+name = "unescape"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccb97dac3243214f8d8507998906ca3e2e0b900bf9bf4870477f125b82e68f6e"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.13"
diff --git a/Cargo.toml b/Cargo.toml
index f0309c78a..08539fe2c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,7 @@
 [workspace]
 resolver = "2"
 members = [
+    "madmin",
     "rustfs",
     "ecstore",
     "e2e_test",
@@ -20,6 +21,7 @@ rust-version = "1.75"
 version = "0.0.1"
 
 [workspace.dependencies]
+madmin = { path = "./madmin" }
 async-trait = "0.1.83"
 backon = "1.2.0"
 bytes = "1.8.0"
@@ -51,6 +53,8 @@ prost-types = "0.13.3"
 protobuf = "3.7"
 protos = { path = "./common/protos" }
 rand = "0.8.5"
+rmp = "0.8.14"
+rmp-serde = "1.3.0"
 s3s = { git = "https://github.com/Nugine/s3s.git", rev = "207170f526c75a8190e8f9afadf961909fd01d34", default-features = true, features = [
     "tower",
 ] }
diff --git a/common/protos/src/generated/proto_gen/node_service.rs b/common/protos/src/generated/proto_gen/node_service.rs
index 1ec3f589b..9dc50d8cc 100644
--- a/common/protos/src/generated/proto_gen/node_service.rs
+++ b/common/protos/src/generated/proto_gen/node_service.rs
@@ -612,6 +612,439 @@ pub struct GenerallyLockResponse {
     #[prost(string, optional, tag = "2")]
     pub error_info: ::core::option::Option<::prost::alloc::string::String>,
 }
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Mss {
+    #[prost(map = "string, string", tag = "1")]
+    pub value: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct LocalStorageInfoRequest {
+    #[prost(bool, tag = "1")]
+    pub metrics: bool,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LocalStorageInfoResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(bytes = "vec", tag = "2")]
+    pub storage_info: ::prost::alloc::vec::Vec<u8>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct ServerInfoRequest {
+    #[prost(bool, tag = "1")]
+    pub metrics: bool,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ServerInfoResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(bytes = "vec", tag = "2")]
+    pub server_properties: ::prost::alloc::vec::Vec<u8>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetCpusRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetCpusResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(bytes = "vec", tag = "2")]
+    pub cpus: ::prost::alloc::vec::Vec<u8>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetNetInfoRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetNetInfoResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(bytes = "vec", tag = "2")]
+    pub net_info: ::prost::alloc::vec::Vec<u8>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetPartitionsRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetPartitionsResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(bytes = "vec", tag = "2")]
+    pub partitions: ::prost::alloc::vec::Vec<u8>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetOsInfoRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetOsInfoResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(bytes = "vec", tag = "2")]
+    pub os_info: ::prost::alloc::vec::Vec<u8>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetSeLinuxInfoRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetSeLinuxInfoResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(bytes = "vec", tag = "2")]
+    pub sys_services: ::prost::alloc::vec::Vec<u8>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetSysConfigRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetSysConfigResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(bytes = "vec", tag = "2")]
+    pub sys_config: ::prost::alloc::vec::Vec<u8>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetSysErrorsRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetSysErrorsResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(bytes = "vec", tag = "2")]
+    pub sys_errors: ::prost::alloc::vec::Vec<u8>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetMemInfoRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetMemInfoResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(bytes = "vec", tag = "2")]
+    pub mem_info: ::prost::alloc::vec::Vec<u8>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetMetricsRequest {
+    #[prost(uint64, tag = "1")]
+    pub metric_type: u64,
+    #[prost(bytes = "vec", tag = "2")]
+    pub opts: ::prost::alloc::vec::Vec<u8>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetMetricsResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(bytes = "vec", tag = "2")]
+    pub realtime_metrics: ::prost::alloc::vec::Vec<u8>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetProcInfoRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetProcInfoResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(bytes = "vec", tag = "2")]
+    pub proc_info: ::prost::alloc::vec::Vec<u8>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct StartProfilingRequest {
+    #[prost(string, tag = "1")]
+    pub profiler: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct StartProfilingResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, optional, tag = "2")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct DownloadProfileDataRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DownloadProfileDataResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(map = "string, bytes", tag = "2")]
+    pub data: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::vec::Vec<u8>>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetBucketStatsDataRequest {
+    #[prost(string, tag = "1")]
+    pub bucket: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetBucketStatsDataResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(bytes = "vec", tag = "2")]
+    pub bucket_stats: ::prost::alloc::vec::Vec<u8>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetSrMetricsDataRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetSrMetricsDataResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(bytes = "vec", tag = "2")]
+    pub sr_metrics_summary: ::prost::alloc::vec::Vec<u8>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetAllBucketStatsRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetAllBucketStatsResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(bytes = "vec", tag = "2")]
+    pub bucket_stats_map: ::prost::alloc::vec::Vec<u8>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LoadBucketMetadataRequest {
+    #[prost(string, tag = "1")]
+    pub bucket: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LoadBucketMetadataResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, optional, tag = "2")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DeleteBucketMetadataRequest {
+    #[prost(string, tag = "1")]
+    pub bucket: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DeleteBucketMetadataResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, optional, tag = "2")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DeletePolicyRequest {
+    #[prost(string, tag = "1")]
+    pub policy_name: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DeletePolicyResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, optional, tag = "2")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LoadPolicyRequest {
+    #[prost(string, tag = "1")]
+    pub policy_name: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LoadPolicyResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, optional, tag = "2")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LoadPolicyMappingRequest {
+    #[prost(string, tag = "1")]
+    pub user_or_group: ::prost::alloc::string::String,
+    #[prost(uint64, tag = "2")]
+    pub user_type: u64,
+    #[prost(bool, tag = "3")]
+    pub is_group: bool,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LoadPolicyMappingResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, optional, tag = "2")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DeleteUserRequest {
+    #[prost(string, tag = "1")]
+    pub access_key: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DeleteUserResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, optional, tag = "2")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DeleteServiceAccountRequest {
+    #[prost(string, tag = "1")]
+    pub access_key: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DeleteServiceAccountResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, optional, tag = "2")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LoadUserRequest {
+    #[prost(string, tag = "1")]
+    pub access_key: ::prost::alloc::string::String,
+    #[prost(bool, tag = "2")]
+    pub temp: bool,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LoadUserResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, optional, tag = "2")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LoadServiceAccountRequest {
+    #[prost(string, tag = "1")]
+    pub access_key: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LoadServiceAccountResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, optional, tag = "2")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LoadGroupRequest {
+    #[prost(string, tag = "1")]
+    pub group: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LoadGroupResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, optional, tag = "2")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct ReloadSiteReplicationConfigRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ReloadSiteReplicationConfigResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, optional, tag = "2")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SignalServiceRequest {
+    #[prost(message, optional, tag = "1")]
+    pub vars: ::core::option::Option<Mss>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SignalServiceResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, optional, tag = "2")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct BackgroundHealStatusRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct BackgroundHealStatusResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(bytes = "vec", tag = "2")]
+    pub bg_heal_state: ::prost::alloc::vec::Vec<u8>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetMetacacheListingRequest {
+    #[prost(bytes = "vec", tag = "1")]
+    pub opts: ::prost::alloc::vec::Vec<u8>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetMetacacheListingResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(bytes = "vec", tag = "2")]
+    pub metacache: ::prost::alloc::vec::Vec<u8>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct UpdateMetacacheListingRequest {
+    #[prost(bytes = "vec", tag = "1")]
+    pub metacache: ::prost::alloc::vec::Vec<u8>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct UpdateMetacacheListingResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(bytes = "vec", tag = "2")]
+    pub metacache: ::prost::alloc::vec::Vec<u8>,
+    #[prost(string, optional, tag = "3")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct ReloadPoolMetaRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ReloadPoolMetaResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, optional, tag = "2")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct StopRebalanceRequest {}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct StopRebalanceResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, optional, tag = "2")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct LoadRebalanceMetaRequest {
+    #[prost(bool, tag = "1")]
+    pub start_rebalance: bool,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LoadRebalanceMetaResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, optional, tag = "2")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct LoadTransitionTierConfigRequest {}
+
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LoadTransitionTierConfigResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, optional, tag = "2")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
 /// Generated client implementations.
 pub mod node_service_client {
     #![allow(unused_variables, dead_code, missing_docs, clippy::wildcard_imports, clippy::let_unit_value)]
@@ -1293,6 +1726,548 @@ pub mod node_service_client {
                 .insert(GrpcMethod::new("node_service.NodeService", "Refresh"));
             self.inner.unary(req, path, codec).await
         }
+        pub async fn local_storage_info(
+            &mut self,
+            request: impl tonic::IntoRequest<super::LocalStorageInfoRequest>,
+        ) -> std::result::Result<tonic::Response<super::LocalStorageInfoResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/LocalStorageInfo");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "LocalStorageInfo"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn server_info(
+            &mut self,
+            request: impl tonic::IntoRequest<super::ServerInfoRequest>,
+        ) -> std::result::Result<tonic::Response<super::ServerInfoResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/ServerInfo");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "ServerInfo"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_cpus(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetCpusRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetCpusResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/GetCpus");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "GetCpus"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_net_info(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetNetInfoRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetNetInfoResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/GetNetInfo");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "GetNetInfo"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_partitions(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetPartitionsRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetPartitionsResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/GetPartitions");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "GetPartitions"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_os_info(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetOsInfoRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetOsInfoResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/GetOsInfo");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "GetOsInfo"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_se_linux_info(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetSeLinuxInfoRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetSeLinuxInfoResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/GetSELinuxInfo");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "GetSELinuxInfo"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_sys_config(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetSysConfigRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetSysConfigResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/GetSysConfig");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "GetSysConfig"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_sys_errors(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetSysErrorsRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetSysErrorsResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/GetSysErrors");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "GetSysErrors"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_mem_info(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetMemInfoRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetMemInfoResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/GetMemInfo");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "GetMemInfo"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_metrics(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetMetricsRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetMetricsResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/GetMetrics");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "GetMetrics"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_proc_info(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetProcInfoRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetProcInfoResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/GetProcInfo");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "GetProcInfo"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn start_profiling(
+            &mut self,
+            request: impl tonic::IntoRequest<super::StartProfilingRequest>,
+        ) -> std::result::Result<tonic::Response<super::StartProfilingResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/StartProfiling");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "StartProfiling"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn download_profile_data(
+            &mut self,
+            request: impl tonic::IntoRequest<super::DownloadProfileDataRequest>,
+        ) -> std::result::Result<tonic::Response<super::DownloadProfileDataResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/DownloadProfileData");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "DownloadProfileData"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_bucket_stats(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetBucketStatsDataRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetBucketStatsDataResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/GetBucketStats");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "GetBucketStats"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_sr_metrics(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetSrMetricsDataRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetSrMetricsDataResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/GetSRMetrics");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "GetSRMetrics"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_all_bucket_stats(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetAllBucketStatsRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetAllBucketStatsResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/GetAllBucketStats");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "GetAllBucketStats"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn load_bucket_metadata(
+            &mut self,
+            request: impl tonic::IntoRequest<super::LoadBucketMetadataRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoadBucketMetadataResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/LoadBucketMetadata");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "LoadBucketMetadata"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn delete_bucket_metadata(
+            &mut self,
+            request: impl tonic::IntoRequest<super::DeleteBucketMetadataRequest>,
+        ) -> std::result::Result<tonic::Response<super::DeleteBucketMetadataResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/DeleteBucketMetadata");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "DeleteBucketMetadata"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn delete_policy(
+            &mut self,
+            request: impl tonic::IntoRequest<super::DeletePolicyRequest>,
+        ) -> std::result::Result<tonic::Response<super::DeletePolicyResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/DeletePolicy");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "DeletePolicy"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn load_policy(
+            &mut self,
+            request: impl tonic::IntoRequest<super::LoadPolicyRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoadPolicyResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/LoadPolicy");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "LoadPolicy"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn load_policy_mapping(
+            &mut self,
+            request: impl tonic::IntoRequest<super::LoadPolicyMappingRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoadPolicyMappingResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/LoadPolicyMapping");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "LoadPolicyMapping"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn delete_user(
+            &mut self,
+            request: impl tonic::IntoRequest<super::DeleteUserRequest>,
+        ) -> std::result::Result<tonic::Response<super::DeleteUserResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/DeleteUser");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "DeleteUser"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn delete_service_account(
+            &mut self,
+            request: impl tonic::IntoRequest<super::DeleteServiceAccountRequest>,
+        ) -> std::result::Result<tonic::Response<super::DeleteServiceAccountResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/DeleteServiceAccount");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "DeleteServiceAccount"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn load_user(
+            &mut self,
+            request: impl tonic::IntoRequest<super::LoadUserRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoadUserResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/LoadUser");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "LoadUser"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn load_service_account(
+            &mut self,
+            request: impl tonic::IntoRequest<super::LoadServiceAccountRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoadServiceAccountResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/LoadServiceAccount");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "LoadServiceAccount"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn load_group(
+            &mut self,
+            request: impl tonic::IntoRequest<super::LoadGroupRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoadGroupResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/LoadGroup");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "LoadGroup"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn reload_site_replication_config(
+            &mut self,
+            request: impl tonic::IntoRequest<super::ReloadSiteReplicationConfigRequest>,
+        ) -> std::result::Result<tonic::Response<super::ReloadSiteReplicationConfigResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/ReloadSiteReplicationConfig");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "ReloadSiteReplicationConfig"));
+            self.inner.unary(req, path, codec).await
+        }
+        /// rpc VerifyBinary() returns () {};
+        /// rpc CommitBinary() returns () {};
+        pub async fn signal_service(
+            &mut self,
+            request: impl tonic::IntoRequest<super::SignalServiceRequest>,
+        ) -> std::result::Result<tonic::Response<super::SignalServiceResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/SignalService");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "SignalService"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn background_heal_status(
+            &mut self,
+            request: impl tonic::IntoRequest<super::BackgroundHealStatusRequest>,
+        ) -> std::result::Result<tonic::Response<super::BackgroundHealStatusResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/BackgroundHealStatus");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "BackgroundHealStatus"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_metacache_listing(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetMetacacheListingRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetMetacacheListingResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/GetMetacacheListing");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "GetMetacacheListing"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn update_metacache_listing(
+            &mut self,
+            request: impl tonic::IntoRequest<super::UpdateMetacacheListingRequest>,
+        ) -> std::result::Result<tonic::Response<super::UpdateMetacacheListingResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/UpdateMetacacheListing");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "UpdateMetacacheListing"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn reload_pool_meta(
+            &mut self,
+            request: impl tonic::IntoRequest<super::ReloadPoolMetaRequest>,
+        ) -> std::result::Result<tonic::Response<super::ReloadPoolMetaResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/ReloadPoolMeta");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "ReloadPoolMeta"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn stop_rebalance(
+            &mut self,
+            request: impl tonic::IntoRequest<super::StopRebalanceRequest>,
+        ) -> std::result::Result<tonic::Response<super::StopRebalanceResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/StopRebalance");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "StopRebalance"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn load_rebalance_meta(
+            &mut self,
+            request: impl tonic::IntoRequest<super::LoadRebalanceMetaRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoadRebalanceMetaResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/LoadRebalanceMeta");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "LoadRebalanceMeta"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn load_transition_tier_config(
+            &mut self,
+            request: impl tonic::IntoRequest<super::LoadTransitionTierConfigRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoadTransitionTierConfigResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/node_service.NodeService/LoadTransitionTierConfig");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "LoadTransitionTierConfig"));
+            self.inner.unary(req, path, codec).await
+        }
     }
 }
 /// Generated server implementations.
@@ -1476,6 +2451,152 @@ pub mod node_service_server {
             &self,
             request: tonic::Request<super::GenerallyLockRequest>,
         ) -> std::result::Result<tonic::Response<super::GenerallyLockResponse>, tonic::Status>;
+        async fn local_storage_info(
+            &self,
+            request: tonic::Request<super::LocalStorageInfoRequest>,
+        ) -> std::result::Result<tonic::Response<super::LocalStorageInfoResponse>, tonic::Status>;
+        async fn server_info(
+            &self,
+            request: tonic::Request<super::ServerInfoRequest>,
+        ) -> std::result::Result<tonic::Response<super::ServerInfoResponse>, tonic::Status>;
+        async fn get_cpus(
+            &self,
+            request: tonic::Request<super::GetCpusRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetCpusResponse>, tonic::Status>;
+        async fn get_net_info(
+            &self,
+            request: tonic::Request<super::GetNetInfoRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetNetInfoResponse>, tonic::Status>;
+        async fn get_partitions(
+            &self,
+            request: tonic::Request<super::GetPartitionsRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetPartitionsResponse>, tonic::Status>;
+        async fn get_os_info(
+            &self,
+            request: tonic::Request<super::GetOsInfoRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetOsInfoResponse>, tonic::Status>;
+        async fn get_se_linux_info(
+            &self,
+            request: tonic::Request<super::GetSeLinuxInfoRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetSeLinuxInfoResponse>, tonic::Status>;
+        async fn get_sys_config(
+            &self,
+            request: tonic::Request<super::GetSysConfigRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetSysConfigResponse>, tonic::Status>;
+        async fn get_sys_errors(
+            &self,
+            request: tonic::Request<super::GetSysErrorsRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetSysErrorsResponse>, tonic::Status>;
+        async fn get_mem_info(
+            &self,
+            request: tonic::Request<super::GetMemInfoRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetMemInfoResponse>, tonic::Status>;
+        async fn get_metrics(
+            &self,
+            request: tonic::Request<super::GetMetricsRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetMetricsResponse>, tonic::Status>;
+        async fn get_proc_info(
+            &self,
+            request: tonic::Request<super::GetProcInfoRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetProcInfoResponse>, tonic::Status>;
+        async fn start_profiling(
+            &self,
+            request: tonic::Request<super::StartProfilingRequest>,
+        ) -> std::result::Result<tonic::Response<super::StartProfilingResponse>, tonic::Status>;
+        async fn download_profile_data(
+            &self,
+            request: tonic::Request<super::DownloadProfileDataRequest>,
+        ) -> std::result::Result<tonic::Response<super::DownloadProfileDataResponse>, tonic::Status>;
+        async fn get_bucket_stats(
+            &self,
+            request: tonic::Request<super::GetBucketStatsDataRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetBucketStatsDataResponse>, tonic::Status>;
+        async fn get_sr_metrics(
+            &self,
+            request: tonic::Request<super::GetSrMetricsDataRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetSrMetricsDataResponse>, tonic::Status>;
+        async fn get_all_bucket_stats(
+            &self,
+            request: tonic::Request<super::GetAllBucketStatsRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetAllBucketStatsResponse>, tonic::Status>;
+        async fn load_bucket_metadata(
+            &self,
+            request: tonic::Request<super::LoadBucketMetadataRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoadBucketMetadataResponse>, tonic::Status>;
+        async fn delete_bucket_metadata(
+            &self,
+            request: tonic::Request<super::DeleteBucketMetadataRequest>,
+        ) -> std::result::Result<tonic::Response<super::DeleteBucketMetadataResponse>, tonic::Status>;
+        async fn delete_policy(
+            &self,
+            request: tonic::Request<super::DeletePolicyRequest>,
+        ) -> std::result::Result<tonic::Response<super::DeletePolicyResponse>, tonic::Status>;
+        async fn load_policy(
+            &self,
+            request: tonic::Request<super::LoadPolicyRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoadPolicyResponse>, tonic::Status>;
+        async fn load_policy_mapping(
+            &self,
+            request: tonic::Request<super::LoadPolicyMappingRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoadPolicyMappingResponse>, tonic::Status>;
+        async fn delete_user(
+            &self,
+            request: tonic::Request<super::DeleteUserRequest>,
+        ) -> std::result::Result<tonic::Response<super::DeleteUserResponse>, tonic::Status>;
+        async fn delete_service_account(
+            &self,
+            request: tonic::Request<super::DeleteServiceAccountRequest>,
+        ) -> std::result::Result<tonic::Response<super::DeleteServiceAccountResponse>, tonic::Status>;
+        async fn load_user(
+            &self,
+            request: tonic::Request<super::LoadUserRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoadUserResponse>, tonic::Status>;
+        async fn load_service_account(
+            &self,
+            request: tonic::Request<super::LoadServiceAccountRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoadServiceAccountResponse>, tonic::Status>;
+        async fn load_group(
+            &self,
+            request: tonic::Request<super::LoadGroupRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoadGroupResponse>, tonic::Status>;
+        async fn reload_site_replication_config(
+            &self,
+            request: tonic::Request<super::ReloadSiteReplicationConfigRequest>,
+        ) -> std::result::Result<tonic::Response<super::ReloadSiteReplicationConfigResponse>, tonic::Status>;
+        /// rpc VerifyBinary() returns () {};
+        /// rpc CommitBinary() returns () {};
+        async fn signal_service(
+            &self,
+            request: tonic::Request<super::SignalServiceRequest>,
+        ) -> std::result::Result<tonic::Response<super::SignalServiceResponse>, tonic::Status>;
+        async fn background_heal_status(
+            &self,
+            request: tonic::Request<super::BackgroundHealStatusRequest>,
+        ) -> std::result::Result<tonic::Response<super::BackgroundHealStatusResponse>, tonic::Status>;
+        async fn get_metacache_listing(
+            &self,
+            request: tonic::Request<super::GetMetacacheListingRequest>,
+        ) -> std::result::Result<tonic::Response<super::GetMetacacheListingResponse>, tonic::Status>;
+        async fn update_metacache_listing(
+            &self,
+            request: tonic::Request<super::UpdateMetacacheListingRequest>,
+        ) -> std::result::Result<tonic::Response<super::UpdateMetacacheListingResponse>, tonic::Status>;
+        async fn reload_pool_meta(
+            &self,
+            request: tonic::Request<super::ReloadPoolMetaRequest>,
+        ) -> std::result::Result<tonic::Response<super::ReloadPoolMetaResponse>, tonic::Status>;
+        async fn stop_rebalance(
+            &self,
+            request: tonic::Request<super::StopRebalanceRequest>,
+        ) -> std::result::Result<tonic::Response<super::StopRebalanceResponse>, tonic::Status>;
+        async fn load_rebalance_meta(
+            &self,
+            request: tonic::Request<super::LoadRebalanceMetaRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoadRebalanceMetaResponse>, tonic::Status>;
+        async fn load_transition_tier_config(
+            &self,
+            request: tonic::Request<super::LoadTransitionTierConfigRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoadTransitionTierConfigResponse>, tonic::Status>;
     }
     #[derive(Debug)]
     pub struct NodeServiceServer<T> {
@@ -2670,6 +3791,1016 @@ pub mod node_service_server {
                     };
                     Box::pin(fut)
                 }
+                "/node_service.NodeService/LocalStorageInfo" => {
+                    #[allow(non_camel_case_types)]
+                    struct LocalStorageInfoSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::LocalStorageInfoRequest> for LocalStorageInfoSvc<T> {
+                        type Response = super::LocalStorageInfoResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::LocalStorageInfoRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::local_storage_info(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = LocalStorageInfoSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/ServerInfo" => {
+                    #[allow(non_camel_case_types)]
+                    struct ServerInfoSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::ServerInfoRequest> for ServerInfoSvc<T> {
+                        type Response = super::ServerInfoResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::ServerInfoRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::server_info(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = ServerInfoSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/GetCpus" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetCpusSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::GetCpusRequest> for GetCpusSvc<T> {
+                        type Response = super::GetCpusResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::GetCpusRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::get_cpus(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetCpusSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/GetNetInfo" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetNetInfoSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::GetNetInfoRequest> for GetNetInfoSvc<T> {
+                        type Response = super::GetNetInfoResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::GetNetInfoRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::get_net_info(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetNetInfoSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/GetPartitions" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetPartitionsSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::GetPartitionsRequest> for GetPartitionsSvc<T> {
+                        type Response = super::GetPartitionsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::GetPartitionsRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::get_partitions(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetPartitionsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/GetOsInfo" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetOsInfoSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::GetOsInfoRequest> for GetOsInfoSvc<T> {
+                        type Response = super::GetOsInfoResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::GetOsInfoRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::get_os_info(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetOsInfoSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/GetSELinuxInfo" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetSELinuxInfoSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::GetSeLinuxInfoRequest> for GetSELinuxInfoSvc<T> {
+                        type Response = super::GetSeLinuxInfoResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::GetSeLinuxInfoRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::get_se_linux_info(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetSELinuxInfoSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/GetSysConfig" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetSysConfigSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::GetSysConfigRequest> for GetSysConfigSvc<T> {
+                        type Response = super::GetSysConfigResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::GetSysConfigRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::get_sys_config(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetSysConfigSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/GetSysErrors" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetSysErrorsSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::GetSysErrorsRequest> for GetSysErrorsSvc<T> {
+                        type Response = super::GetSysErrorsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::GetSysErrorsRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::get_sys_errors(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetSysErrorsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/GetMemInfo" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetMemInfoSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::GetMemInfoRequest> for GetMemInfoSvc<T> {
+                        type Response = super::GetMemInfoResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::GetMemInfoRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::get_mem_info(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetMemInfoSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/GetMetrics" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetMetricsSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::GetMetricsRequest> for GetMetricsSvc<T> {
+                        type Response = super::GetMetricsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::GetMetricsRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::get_metrics(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetMetricsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/GetProcInfo" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetProcInfoSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::GetProcInfoRequest> for GetProcInfoSvc<T> {
+                        type Response = super::GetProcInfoResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::GetProcInfoRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::get_proc_info(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetProcInfoSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/StartProfiling" => {
+                    #[allow(non_camel_case_types)]
+                    struct StartProfilingSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::StartProfilingRequest> for StartProfilingSvc<T> {
+                        type Response = super::StartProfilingResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::StartProfilingRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::start_profiling(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = StartProfilingSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/DownloadProfileData" => {
+                    #[allow(non_camel_case_types)]
+                    struct DownloadProfileDataSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::DownloadProfileDataRequest> for DownloadProfileDataSvc<T> {
+                        type Response = super::DownloadProfileDataResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::DownloadProfileDataRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::download_profile_data(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = DownloadProfileDataSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/GetBucketStats" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetBucketStatsSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::GetBucketStatsDataRequest> for GetBucketStatsSvc<T> {
+                        type Response = super::GetBucketStatsDataResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::GetBucketStatsDataRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::get_bucket_stats(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetBucketStatsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/GetSRMetrics" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetSRMetricsSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::GetSrMetricsDataRequest> for GetSRMetricsSvc<T> {
+                        type Response = super::GetSrMetricsDataResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::GetSrMetricsDataRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::get_sr_metrics(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetSRMetricsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/GetAllBucketStats" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetAllBucketStatsSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::GetAllBucketStatsRequest> for GetAllBucketStatsSvc<T> {
+                        type Response = super::GetAllBucketStatsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::GetAllBucketStatsRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::get_all_bucket_stats(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetAllBucketStatsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/LoadBucketMetadata" => {
+                    #[allow(non_camel_case_types)]
+                    struct LoadBucketMetadataSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::LoadBucketMetadataRequest> for LoadBucketMetadataSvc<T> {
+                        type Response = super::LoadBucketMetadataResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::LoadBucketMetadataRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::load_bucket_metadata(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = LoadBucketMetadataSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/DeleteBucketMetadata" => {
+                    #[allow(non_camel_case_types)]
+                    struct DeleteBucketMetadataSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::DeleteBucketMetadataRequest> for DeleteBucketMetadataSvc<T> {
+                        type Response = super::DeleteBucketMetadataResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::DeleteBucketMetadataRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::delete_bucket_metadata(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = DeleteBucketMetadataSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/DeletePolicy" => {
+                    #[allow(non_camel_case_types)]
+                    struct DeletePolicySvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::DeletePolicyRequest> for DeletePolicySvc<T> {
+                        type Response = super::DeletePolicyResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::DeletePolicyRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::delete_policy(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = DeletePolicySvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/LoadPolicy" => {
+                    #[allow(non_camel_case_types)]
+                    struct LoadPolicySvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::LoadPolicyRequest> for LoadPolicySvc<T> {
+                        type Response = super::LoadPolicyResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::LoadPolicyRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::load_policy(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = LoadPolicySvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/LoadPolicyMapping" => {
+                    #[allow(non_camel_case_types)]
+                    struct LoadPolicyMappingSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::LoadPolicyMappingRequest> for LoadPolicyMappingSvc<T> {
+                        type Response = super::LoadPolicyMappingResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::LoadPolicyMappingRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::load_policy_mapping(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = LoadPolicyMappingSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/DeleteUser" => {
+                    #[allow(non_camel_case_types)]
+                    struct DeleteUserSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::DeleteUserRequest> for DeleteUserSvc<T> {
+                        type Response = super::DeleteUserResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::DeleteUserRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::delete_user(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = DeleteUserSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/DeleteServiceAccount" => {
+                    #[allow(non_camel_case_types)]
+                    struct DeleteServiceAccountSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::DeleteServiceAccountRequest> for DeleteServiceAccountSvc<T> {
+                        type Response = super::DeleteServiceAccountResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::DeleteServiceAccountRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::delete_service_account(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = DeleteServiceAccountSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/LoadUser" => {
+                    #[allow(non_camel_case_types)]
+                    struct LoadUserSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::LoadUserRequest> for LoadUserSvc<T> {
+                        type Response = super::LoadUserResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::LoadUserRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::load_user(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = LoadUserSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/LoadServiceAccount" => {
+                    #[allow(non_camel_case_types)]
+                    struct LoadServiceAccountSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::LoadServiceAccountRequest> for LoadServiceAccountSvc<T> {
+                        type Response = super::LoadServiceAccountResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::LoadServiceAccountRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::load_service_account(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = LoadServiceAccountSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/LoadGroup" => {
+                    #[allow(non_camel_case_types)]
+                    struct LoadGroupSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::LoadGroupRequest> for LoadGroupSvc<T> {
+                        type Response = super::LoadGroupResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::LoadGroupRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::load_group(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = LoadGroupSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/ReloadSiteReplicationConfig" => {
+                    #[allow(non_camel_case_types)]
+                    struct ReloadSiteReplicationConfigSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::ReloadSiteReplicationConfigRequest>
+                        for ReloadSiteReplicationConfigSvc<T>
+                    {
+                        type Response = super::ReloadSiteReplicationConfigResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::ReloadSiteReplicationConfigRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::reload_site_replication_config(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = ReloadSiteReplicationConfigSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/SignalService" => {
+                    #[allow(non_camel_case_types)]
+                    struct SignalServiceSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::SignalServiceRequest> for SignalServiceSvc<T> {
+                        type Response = super::SignalServiceResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::SignalServiceRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::signal_service(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = SignalServiceSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/BackgroundHealStatus" => {
+                    #[allow(non_camel_case_types)]
+                    struct BackgroundHealStatusSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::BackgroundHealStatusRequest> for BackgroundHealStatusSvc<T> {
+                        type Response = super::BackgroundHealStatusResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::BackgroundHealStatusRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::background_heal_status(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = BackgroundHealStatusSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/GetMetacacheListing" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetMetacacheListingSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::GetMetacacheListingRequest> for GetMetacacheListingSvc<T> {
+                        type Response = super::GetMetacacheListingResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::GetMetacacheListingRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::get_metacache_listing(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetMetacacheListingSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/UpdateMetacacheListing" => {
+                    #[allow(non_camel_case_types)]
+                    struct UpdateMetacacheListingSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::UpdateMetacacheListingRequest> for UpdateMetacacheListingSvc<T> {
+                        type Response = super::UpdateMetacacheListingResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::UpdateMetacacheListingRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::update_metacache_listing(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = UpdateMetacacheListingSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/ReloadPoolMeta" => {
+                    #[allow(non_camel_case_types)]
+                    struct ReloadPoolMetaSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::ReloadPoolMetaRequest> for ReloadPoolMetaSvc<T> {
+                        type Response = super::ReloadPoolMetaResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::ReloadPoolMetaRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::reload_pool_meta(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = ReloadPoolMetaSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/StopRebalance" => {
+                    #[allow(non_camel_case_types)]
+                    struct StopRebalanceSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::StopRebalanceRequest> for StopRebalanceSvc<T> {
+                        type Response = super::StopRebalanceResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::StopRebalanceRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::stop_rebalance(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = StopRebalanceSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/LoadRebalanceMeta" => {
+                    #[allow(non_camel_case_types)]
+                    struct LoadRebalanceMetaSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::LoadRebalanceMetaRequest> for LoadRebalanceMetaSvc<T> {
+                        type Response = super::LoadRebalanceMetaResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::LoadRebalanceMetaRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::load_rebalance_meta(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = LoadRebalanceMetaSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/node_service.NodeService/LoadTransitionTierConfig" => {
+                    #[allow(non_camel_case_types)]
+                    struct LoadTransitionTierConfigSvc<T: NodeService>(pub Arc<T>);
+                    impl<T: NodeService> tonic::server::UnaryService<super::LoadTransitionTierConfigRequest> for LoadTransitionTierConfigSvc<T> {
+                        type Response = super::LoadTransitionTierConfigResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(&mut self, request: tonic::Request<super::LoadTransitionTierConfigRequest>) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { <T as NodeService>::load_transition_tier_config(&inner, request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = LoadTransitionTierConfigSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(accept_compression_encodings, send_compression_encodings)
+                            .apply_max_message_size_config(max_decoding_message_size, max_encoding_message_size);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
                 _ => Box::pin(async move {
                     let mut response = http::Response::new(empty_body());
                     let headers = response.headers_mut();
diff --git a/common/protos/src/node.proto b/common/protos/src/node.proto
index f80fb10f3..e3c0ad667 100644
--- a/common/protos/src/node.proto
+++ b/common/protos/src/node.proto
@@ -411,8 +411,325 @@ message GenerallyLockRequest {
 }
 
 message GenerallyLockResponse {
-    bool success = 1;
-    optional string error_info = 2;
+  bool success = 1;
+  optional string error_info = 2;
+}
+
+message Mss {
+  map<string, string> value = 1;
+}
+
+message LocalStorageInfoRequest {
+  bool metrics = 1;
+}
+
+message LocalStorageInfoResponse {
+  bool success = 1;
+  bytes storage_info = 2;
+  optional string error_info = 3;
+}
+
+message ServerInfoRequest {
+  bool metrics = 1;
+}
+
+message ServerInfoResponse {
+  bool success = 1;
+  bytes server_properties = 2;
+  optional string error_info = 3;
+}
+
+message GetCpusRequest {}
+
+message GetCpusResponse {
+  bool success = 1;
+  bytes cpus = 2;
+  optional string error_info = 3;
+}
+
+message GetNetInfoRequest {}
+
+message GetNetInfoResponse {
+  bool success = 1;
+  bytes net_info = 2;
+  optional string error_info = 3;
+}
+
+message GetPartitionsRequest {}
+
+message GetPartitionsResponse {
+  bool success = 1;
+  bytes partitions = 2;
+  optional string error_info = 3;
+}
+
+message GetOsInfoRequest {}
+
+message GetOsInfoResponse {
+  bool success = 1;
+  bytes os_info = 2;
+  optional string error_info = 3;
+}
+
+message GetSELinuxInfoRequest {}
+
+message GetSELinuxInfoResponse {
+  bool success = 1;
+  bytes sys_services = 2;
+  optional string error_info = 3;
+}
+
+message GetSysConfigRequest {}
+
+message GetSysConfigResponse {
+  bool success = 1;
+  bytes sys_config = 2;
+  optional string error_info = 3;
+}
+
+message GetSysErrorsRequest {}
+
+message GetSysErrorsResponse {
+  bool success = 1;
+  bytes sys_errors = 2;
+  optional string error_info = 3;
+}
+
+message GetMemInfoRequest {}
+
+message GetMemInfoResponse {
+  bool success = 1;
+  bytes mem_info = 2;
+  optional string error_info = 3;
+}
+
+message GetMetricsRequest {
+  uint64 metric_type = 1;
+  bytes opts = 2;
+}
+
+message GetMetricsResponse {
+  bool success = 1;
+  bytes realtime_metrics = 2;
+  optional string error_info = 3;
+}
+
+message GetProcInfoRequest {}
+
+message GetProcInfoResponse {
+  bool success = 1;
+  bytes proc_info = 2;
+  optional string error_info = 3;
+}
+
+message StartProfilingRequest {
+  string profiler = 1;
+}
+
+message StartProfilingResponse {
+  bool success = 1;
+  optional string error_info = 2;
+}
+
+message DownloadProfileDataRequest {}
+
+message DownloadProfileDataResponse {
+  bool success = 1;
+  map<string, bytes> data = 2;
+  optional string error_info = 3;
+}
+
+message GetBucketStatsDataRequest {
+  string bucket = 1;
+}
+
+message GetBucketStatsDataResponse {
+  bool success = 1;
+  bytes bucket_stats = 2;
+  optional string error_info = 3;
+}
+
+message GetSRMetricsDataRequest {}
+
+message GetSRMetricsDataResponse {
+  bool success = 1;
+  bytes sr_metrics_summary = 2;
+  optional string error_info = 3;
+}
+
+message GetAllBucketStatsRequest {}
+
+message GetAllBucketStatsResponse {
+  bool success = 1;
+  bytes bucket_stats_map = 2;
+  optional string error_info = 3;
+}
+
+message LoadBucketMetadataRequest {
+  string bucket = 1;
+}
+
+message LoadBucketMetadataResponse {
+  bool success = 1;
+  optional string error_info = 2;
+}
+
+message DeleteBucketMetadataRequest {
+  string bucket = 1;
+}
+
+message DeleteBucketMetadataResponse {
+  bool success = 1;
+  optional string error_info = 2;
+}
+
+message DeletePolicyRequest {
+  string policy_name = 1;
+}
+
+message DeletePolicyResponse {
+  bool success = 1;
+  optional string error_info = 2;
+}
+
+message LoadPolicyRequest {
+  string policy_name = 1;
+}
+
+message LoadPolicyResponse {
+  bool success = 1;
+  optional string error_info = 2;
+}
+
+message LoadPolicyMappingRequest {
+  string user_or_group = 1;
+  uint64 user_type = 2;
+  bool is_group = 3;
+}
+
+message LoadPolicyMappingResponse {
+  bool success = 1;
+  optional string error_info = 2;
+}
+
+message DeleteUserRequest {
+  string access_key = 1;
+}
+
+message DeleteUserResponse {
+  bool success = 1;
+  optional string error_info = 2;
+}
+
+message DeleteServiceAccountRequest {
+  string access_key = 1;
+}
+
+message DeleteServiceAccountResponse {
+  bool success = 1;
+  optional string error_info = 2;
+}
+
+message LoadUserRequest {
+  string access_key = 1;
+  bool temp = 2;
+}
+
+message LoadUserResponse {
+  bool success = 1;
+  optional string error_info = 2;
+}
+
+message LoadServiceAccountRequest {
+  string access_key = 1;
+}
+
+message LoadServiceAccountResponse {
+  bool success = 1;
+  optional string error_info = 2;
+}
+
+message LoadGroupRequest {
+  string group = 1;
+}
+
+message LoadGroupResponse {
+  bool success = 1;
+  optional string error_info = 2;
+}
+
+message ReloadSiteReplicationConfigRequest {}
+
+message ReloadSiteReplicationConfigResponse {
+  bool success = 1;
+  optional string error_info = 2;
+}
+
+message SignalServiceRequest {
+  Mss vars = 1;
+}
+
+message SignalServiceResponse {
+  bool success = 1;
+  optional string error_info = 2;
+}
+
+message BackgroundHealStatusRequest {}
+
+message BackgroundHealStatusResponse {
+  bool success = 1;
+  bytes bg_heal_state = 2;
+  optional string error_info = 3;
+}
+
+message GetMetacacheListingRequest {
+  bytes opts = 1;
+}
+
+message GetMetacacheListingResponse {
+  bool success = 1;
+  bytes metacache = 2;
+  optional string error_info = 3;
+}
+
+message UpdateMetacacheListingRequest {
+  bytes metacache = 1;
+}
+
+message UpdateMetacacheListingResponse {
+  bool success = 1;
+  bytes metacache = 2;
+  optional string error_info = 3;
+}
+
+message ReloadPoolMetaRequest {}
+
+message ReloadPoolMetaResponse {
+  bool success = 1;
+  optional string error_info = 2;
+}
+
+message StopRebalanceRequest {}
+
+message StopRebalanceResponse {
+  bool success = 1;
+  optional string error_info = 2;
+}
+
+message LoadRebalanceMetaRequest {
+  bool start_rebalance = 1;
+}
+
+message LoadRebalanceMetaResponse {
+  bool success = 1;
+  optional string error_info = 2;
+}
+
+message LoadTransitionTierConfigRequest {}
+
+message LoadTransitionTierConfigResponse {
+  bool success = 1;
+  optional string error_info = 2;
 }
 
 /* -------------------------------------------------------------------- */
@@ -466,4 +783,45 @@ service NodeService {
   rpc RUnLock(GenerallyLockRequest) returns (GenerallyLockResponse) {};
   rpc ForceUnLock(GenerallyLockRequest) returns (GenerallyLockResponse) {};
   rpc Refresh(GenerallyLockRequest) returns (GenerallyLockResponse) {};
+
+/* -------------------------------peer rest service-------------------------- */
+
+  rpc LocalStorageInfo(LocalStorageInfoRequest) returns (LocalStorageInfoResponse) {};
+  rpc ServerInfo(ServerInfoRequest) returns (ServerInfoResponse) {};
+  rpc GetCpus(GetCpusRequest) returns (GetCpusResponse) {};
+  rpc GetNetInfo(GetNetInfoRequest) returns (GetNetInfoResponse) {};
+  rpc GetPartitions(GetPartitionsRequest) returns (GetPartitionsResponse) {};
+  rpc GetOsInfo(GetOsInfoRequest) returns (GetOsInfoResponse) {};
+  rpc GetSELinuxInfo(GetSELinuxInfoRequest) returns (GetSELinuxInfoResponse) {};
+  rpc GetSysConfig(GetSysConfigRequest) returns (GetSysConfigResponse) {};
+  rpc GetSysErrors(GetSysErrorsRequest) returns (GetSysErrorsResponse) {};
+  rpc GetMemInfo(GetMemInfoRequest) returns (GetMemInfoResponse) {};
+  rpc GetMetrics(GetMetricsRequest) returns (GetMetricsResponse) {};
+  rpc GetProcInfo(GetProcInfoRequest) returns (GetProcInfoResponse) {};
+  rpc StartProfiling(StartProfilingRequest) returns (StartProfilingResponse) {};
+  rpc DownloadProfileData(DownloadProfileDataRequest) returns (DownloadProfileDataResponse) {};
+  rpc GetBucketStats(GetBucketStatsDataRequest) returns (GetBucketStatsDataResponse) {};
+  rpc GetSRMetrics(GetSRMetricsDataRequest) returns (GetSRMetricsDataResponse) {};
+  rpc GetAllBucketStats(GetAllBucketStatsRequest) returns (GetAllBucketStatsResponse) {};
+  rpc LoadBucketMetadata(LoadBucketMetadataRequest) returns (LoadBucketMetadataResponse) {};
+  rpc DeleteBucketMetadata(DeleteBucketMetadataRequest) returns (DeleteBucketMetadataResponse) {};
+  rpc DeletePolicy(DeletePolicyRequest) returns (DeletePolicyResponse) {};
+  rpc LoadPolicy(LoadPolicyRequest) returns (LoadPolicyResponse) {};
+  rpc LoadPolicyMapping(LoadPolicyMappingRequest) returns (LoadPolicyMappingResponse) {};
+  rpc DeleteUser(DeleteUserRequest) returns (DeleteUserResponse) {};
+  rpc DeleteServiceAccount(DeleteServiceAccountRequest) returns (DeleteServiceAccountResponse) {};
+  rpc LoadUser(LoadUserRequest) returns (LoadUserResponse) {};
+  rpc LoadServiceAccount(LoadServiceAccountRequest) returns (LoadServiceAccountResponse) {};
+  rpc LoadGroup(LoadGroupRequest) returns (LoadGroupResponse) {};
+  rpc ReloadSiteReplicationConfig(ReloadSiteReplicationConfigRequest) returns (ReloadSiteReplicationConfigResponse) {};
+  // rpc VerifyBinary() returns () {};
+  // rpc CommitBinary() returns () {};
+  rpc SignalService(SignalServiceRequest) returns (SignalServiceResponse) {};
+  rpc BackgroundHealStatus(BackgroundHealStatusRequest) returns (BackgroundHealStatusResponse) {};
+  rpc GetMetacacheListing(GetMetacacheListingRequest) returns (GetMetacacheListingResponse) {};
+  rpc UpdateMetacacheListing(UpdateMetacacheListingRequest) returns (UpdateMetacacheListingResponse) {};
+  rpc ReloadPoolMeta(ReloadPoolMetaRequest) returns (ReloadPoolMetaResponse) {};
+  rpc StopRebalance(StopRebalanceRequest) returns (StopRebalanceResponse) {};
+  rpc LoadRebalanceMeta(LoadRebalanceMetaRequest) returns (LoadRebalanceMetaResponse) {};
+  rpc LoadTransitionTierConfig(LoadTransitionTierConfigRequest) returns (LoadTransitionTierConfigResponse) {};
 }
diff --git a/e2e_test/Cargo.toml b/e2e_test/Cargo.toml
index f740cc156..771f97e85 100644
--- a/e2e_test/Cargo.toml
+++ b/e2e_test/Cargo.toml
@@ -14,6 +14,8 @@ flatbuffers.workspace = true
 lazy_static.workspace = true
 lock.workspace = true
 protos.workspace = true
+rmp-serde.workspace = true
+serde.workspace = true
 serde_json.workspace = true
 tonic = { version = "0.12.3", features = ["gzip"] }
 tokio = { workspace = true }
diff --git a/e2e_test/src/reliant/node_interact_test.rs b/e2e_test/src/reliant/node_interact_test.rs
index 951647f18..db456ad29 100644
--- a/e2e_test/src/reliant/node_interact_test.rs
+++ b/e2e_test/src/reliant/node_interact_test.rs
@@ -1,12 +1,16 @@
 #![cfg(test)]
 
-use ecstore::disk::VolumeInfo;
+use ecstore::{disk::VolumeInfo, store_api::StorageInfo};
 use protos::{
     models::{PingBody, PingBodyBuilder},
     node_service_time_out_client,
-    proto_gen::node_service::{ListVolumesRequest, MakeVolumeRequest, PingRequest, PingResponse, ReadAllRequest},
+    proto_gen::node_service::{
+        ListVolumesRequest, LocalStorageInfoRequest, MakeVolumeRequest, PingRequest, PingResponse, ReadAllRequest,
+    },
 };
-use std::error::Error;
+use rmp_serde::Deserializer;
+use serde::Deserialize;
+use std::{error::Error, io::Cursor};
 use tonic::Request;
 
 const CLUSTER_ADDR: &str = "http://localhost:9000";
@@ -100,3 +104,21 @@ async fn read_all() -> Result<(), Box<dyn Error>> {
     println!("{:?}", volume_infos);
     Ok(())
 }
+
+#[tokio::test]
+async fn storage_info() -> Result<(), Box<dyn Error>> {
+    let mut client = node_service_time_out_client(&CLUSTER_ADDR.to_string()).await?;
+    let request = Request::new(LocalStorageInfoRequest { metrics: true });
+
+    let response = client.local_storage_info(request).await?.into_inner();
+    if !response.success {
+        println!("{:?}", response.error_info);
+        return Ok(());
+    }
+    let info = response.storage_info;
+
+    let mut buf = Deserializer::new(Cursor::new(info));
+    let storage_info: StorageInfo = Deserialize::deserialize(&mut buf).unwrap();
+    println!("{:?}", storage_info);
+    Ok(())
+}
diff --git a/ecstore/Cargo.toml b/ecstore/Cargo.toml
index 27f09e77f..a52874e5c 100644
--- a/ecstore/Cargo.toml
+++ b/ecstore/Cargo.toml
@@ -17,6 +17,7 @@ common.workspace = true
 reader.workspace = true
 glob = "0.3.1"
 thiserror.workspace = true
+flatbuffers.workspace = true
 futures.workspace = true
 tracing.workspace = true
 serde.workspace = true
@@ -38,7 +39,8 @@ netif = "0.1.6"
 nix = { version = "0.29.0", features = ["fs"] }
 path-absolutize = "3.1.1"
 protos.workspace = true
-rmp-serde = "1.3.0"
+rmp.workspace = true
+rmp-serde.workspace = true
 tokio-util = { version = "0.7.12", features = ["io", "compat"] }
 crc32fast = "1.4.2"
 siphasher = "1.0.1"
@@ -51,7 +53,6 @@ tokio = { workspace = true, features = ["io-util", "sync", "signal"] }
 tokio-stream = "0.1.15"
 tonic.workspace = true
 tower.workspace = true
-rmp = "0.8.14"
 byteorder = "1.5.0"
 xxhash-rust = { version = "0.8.12", features = ["xxh64"] }
 num = "0.4.3"
diff --git a/ecstore/src/admin_server_info.rs b/ecstore/src/admin_server_info.rs
new file mode 100644
index 000000000..5d4d9a8f9
--- /dev/null
+++ b/ecstore/src/admin_server_info.rs
@@ -0,0 +1,173 @@
+use std::{
+    collections::{HashMap, HashSet},
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+use common::{
+    error::{Error, Result},
+    globals::GLOBAL_Local_Node_Name,
+};
+use protos::{
+    models::{PingBody, PingBodyBuilder},
+    node_service_time_out_client,
+    proto_gen::node_service::{PingRequest, PingResponse},
+};
+use serde::{Deserialize, Serialize};
+use tonic::Request;
+
+use crate::{
+    disk::endpoint::Endpoint,
+    global::GLOBAL_Endpoints,
+    new_object_layer_fn,
+    store_api::{StorageAPI, StorageDisk},
+};
+
+pub const ITEM_OFFLINE: &str = "offline";
+pub const ITEM_INITIALIZING: &str = "initializing";
+pub const ITEM_ONLINE: &str = "online";
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct MemStats {
+    alloc: u64,
+    total_alloc: u64,
+    mallocs: u64,
+    frees: u64,
+    heap_alloc: u64,
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct ServerProperties {
+    state: String,
+    endpoint: String,
+    scheme: String,
+    uptime: u64,
+    version: String,
+    commit_id: String,
+    network: HashMap<String, String>,
+    disks: Vec<StorageDisk>,
+    pool_number: i32,
+    pool_numbers: Vec<i32>,
+    mem_stats: MemStats,
+    max_procs: u64,
+    num_cpu: u64,
+    runtime_version: String,
+    rustfs_env_vars: HashMap<String, String>,
+}
+
+async fn is_server_resolvable(endpoint: &Endpoint) -> Result<()> {
+    let addr = format!(
+        "{}://{}:{}",
+        endpoint.url.scheme(),
+        endpoint.url.host_str().unwrap(),
+        endpoint.url.port().unwrap()
+    );
+    let mut fbb = flatbuffers::FlatBufferBuilder::new();
+    let payload = fbb.create_vector(b"hello world");
+
+    let mut builder = PingBodyBuilder::new(&mut fbb);
+    builder.add_payload(payload);
+    let root = builder.finish();
+    fbb.finish(root, None);
+
+    let finished_data = fbb.finished_data();
+
+    let decoded_payload = flatbuffers::root::<PingBody>(finished_data);
+    assert!(decoded_payload.is_ok());
+
+    // 创建客户端
+    let mut client = node_service_time_out_client(&addr)
+        .await
+        .map_err(|err| Error::msg(err.to_string()))?;
+
+    // 构造 PingRequest
+    let request = Request::new(PingRequest {
+        version: 1,
+        body: finished_data.to_vec(),
+    });
+
+    // 发送请求并获取响应
+    let response: PingResponse = client.ping(request).await?.into_inner();
+
+    // 打印响应
+    let ping_response_body = flatbuffers::root::<PingBody>(&response.body);
+    if let Err(e) = ping_response_body {
+        eprintln!("{}", e);
+    } else {
+        println!("ping_resp:body(flatbuffer): {:?}", ping_response_body);
+    }
+
+    Ok(())
+}
+
+pub async fn get_local_server_property() -> ServerProperties {
+    let addr = GLOBAL_Local_Node_Name.read().await.clone();
+    let mut pool_numbers = HashSet::new();
+    let mut network = HashMap::new();
+
+    let endpoints = match GLOBAL_Endpoints.get() {
+        Some(eps) => eps,
+        None => return ServerProperties::default(),
+    };
+    for ep in endpoints.as_ref().iter() {
+        for endpoint in ep.endpoints.as_ref().iter() {
+            let node_name = match endpoint.url.host_str() {
+                Some(s) => s.to_string(),
+                None => addr.clone(),
+            };
+            if endpoint.is_local {
+                pool_numbers.insert(endpoint.pool_idx + 1);
+                network.insert(node_name, ITEM_ONLINE.to_string());
+                continue;
+            }
+            if !network.contains_key(&node_name) {
+                if is_server_resolvable(endpoint).await.is_err() {
+                    network.insert(node_name, ITEM_OFFLINE.to_string());
+                } else {
+                    network.insert(node_name, ITEM_ONLINE.to_string());
+                }
+            }
+        }
+    }
+
+    // todo: mem collect
+    // let mem_stats =
+
+    let mut props = ServerProperties {
+        endpoint: addr,
+        uptime: SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs(),
+        network,
+        ..Default::default()
+    };
+
+    for pool_num in pool_numbers.iter() {
+        props.pool_numbers.push(*pool_num);
+    }
+    props.pool_numbers.sort();
+    props.pool_number = if props.pool_numbers.len() == 1 {
+        props.pool_numbers[1]
+    } else {
+        i32::MAX
+    };
+
+    // let mut sensitive = HashSet::new();
+    // sensitive.insert(ENV_ACCESS_KEY.to_string());
+    // sensitive.insert(ENV_SECRET_KEY.to_string());
+    // sensitive.insert(ENV_ROOT_USER.to_string());
+    // sensitive.insert(ENV_ROOT_PASSWORD.to_string());
+
+    let layer = new_object_layer_fn();
+    let lock = layer.read().await;
+    match lock.as_ref() {
+        Some(store) => {
+            let storage_info = store.local_storage_info().await;
+            props.state = ITEM_ONLINE.to_string();
+            props.disks = storage_info.disks;
+        }
+        None => {
+            props.state = ITEM_INITIALIZING.to_string();
+            // todo: get_offline_disks
+            // props.disks =
+        }
+    };
+    props
+}
diff --git a/ecstore/src/config/mod.rs b/ecstore/src/config/mod.rs
index a169d6988..f241d0f12 100644
--- a/ecstore/src/config/mod.rs
+++ b/ecstore/src/config/mod.rs
@@ -19,6 +19,11 @@ lazy_static! {
     pub static ref GLOBAL_ConfigSys: ConfigSys = ConfigSys::new();
 }
 
+pub const ENV_ACCESS_KEY: &str = "RUSTFS_ACCESS_KEY";
+pub const ENV_SECRET_KEY: &str = "RUSTFS_SECRET_KEY";
+pub const ENV_ROOT_USER: &str = "RUSTFS_ROOT_USER";
+pub const ENV_ROOT_PASSWORD: &str = "RUSTFS_ROOT_PASSWORD";
+
 pub static RUSTFS_CONFIG_PREFIX: &str = "config";
 
 pub struct ConfigSys {}
diff --git a/ecstore/src/disk/endpoint.rs b/ecstore/src/disk/endpoint.rs
index 8c90d35dc..16edab64e 100644
--- a/ecstore/src/disk/endpoint.rs
+++ b/ecstore/src/disk/endpoint.rs
@@ -30,13 +30,7 @@ pub struct Endpoint {
 impl Display for Endpoint {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if self.url.scheme() == "file" {
-            write!(
-                f,
-                "{}",
-                fs::canonicalize(self.url.path())
-                    .map_err(|_| std::fmt::Error)?
-                    .to_string_lossy()
-            )
+            write!(f, "{}", self.url.path())
         } else {
             write!(f, "{}", self.url)
         }
diff --git a/ecstore/src/heal/background_heal_ops.rs b/ecstore/src/heal/background_heal_ops.rs
index c60287b5a..0c64482a1 100644
--- a/ecstore/src/heal/background_heal_ops.rs
+++ b/ecstore/src/heal/background_heal_ops.rs
@@ -65,7 +65,7 @@ async fn init_background_healing() {
         .await;
 }
 
-async fn get_local_disks_to_heal() -> Vec<Endpoint> {
+pub async fn get_local_disks_to_heal() -> Vec<Endpoint> {
     let mut disks_to_heal = Vec::new();
     for (_, disk) in GLOBAL_LOCAL_DISK_MAP.read().await.iter() {
         if let Some(disk) = disk {
diff --git a/ecstore/src/heal/heal_commands.rs b/ecstore/src/heal/heal_commands.rs
index 6950cef1e..d27dad414 100644
--- a/ecstore/src/heal/heal_commands.rs
+++ b/ecstore/src/heal/heal_commands.rs
@@ -97,6 +97,7 @@ impl Default for HealStartSuccess {
 
 pub type HealStopSuccess = HealStartSuccess;
 
+#[derive(Debug, Default)]
 pub struct HealingDisk {
     pub id: String,
     pub heal_id: String,
diff --git a/ecstore/src/heal/heal_ops.rs b/ecstore/src/heal/heal_ops.rs
index c869e4ebb..a271f6c36 100644
--- a/ecstore/src/heal/heal_ops.rs
+++ b/ecstore/src/heal/heal_ops.rs
@@ -190,19 +190,19 @@ impl HealSequence {
 }
 
 impl HealSequence {
-    fn _get_scanned_items_count(&self) -> usize {
+    pub fn get_scanned_items_count(&self) -> usize {
         self.scanned_items_map.values().sum()
     }
 
-    fn _get_scanned_items_map(&self) -> ItemsMap {
+    pub fn _get_scanned_items_map(&self) -> ItemsMap {
         self.scanned_items_map.clone()
     }
 
-    fn _get_healed_items_map(&self) -> ItemsMap {
+    pub fn _get_healed_items_map(&self) -> ItemsMap {
         self.healed_items_map.clone()
     }
 
-    fn _get_heal_failed_items_map(&self) -> ItemsMap {
+    pub fn _get_heal_failed_items_map(&self) -> ItemsMap {
         self.heal_failed_items_map.clone()
     }
 
diff --git a/ecstore/src/lib.rs b/ecstore/src/lib.rs
index 0edb1a46b..9c5bbaa3a 100644
--- a/ecstore/src/lib.rs
+++ b/ecstore/src/lib.rs
@@ -1,3 +1,4 @@
+pub mod admin_server_info;
 pub mod bitrot;
 pub mod cache_value;
 mod chunk_stream;
@@ -8,7 +9,7 @@ pub mod endpoints;
 pub mod erasure;
 pub mod error;
 mod file_meta;
-mod global;
+pub mod global;
 pub mod heal;
 pub mod peer;
 mod quorum;
diff --git a/ecstore/src/pools.rs b/ecstore/src/pools.rs
index 53a22392b..f732fc2ff 100644
--- a/ecstore/src/pools.rs
+++ b/ecstore/src/pools.rs
@@ -1,12 +1,22 @@
+use crate::config::common::{read_config, save_config};
+use crate::config::error::ConfigError;
 use crate::error::{Error, Result};
+use crate::new_object_layer_fn;
 use crate::store_api::{StorageAPI, StorageDisk, StorageInfo};
 use crate::store_err::StorageError;
 use crate::{sets::Sets, store::ECStore};
-use serde::Serialize;
+use byteorder::{ByteOrder, LittleEndian, WriteBytesExt};
+use rmp_serde::{Deserializer, Serializer};
+use serde::{Deserialize, Serialize};
+use std::io::{Cursor, Write};
 use std::sync::Arc;
 use time::OffsetDateTime;
 
-#[derive(Debug, Clone, Serialize)]
+pub const POOL_META_NAME: &str = "pool.bin";
+pub const POOL_META_FORMAT: u16 = 1;
+pub const POOL_META_VERSION: u16 = 1;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct PoolStatus {
     pub id: usize,
     pub cmd_line: String,
@@ -14,8 +24,9 @@ pub struct PoolStatus {
     pub decommission: Option<PoolDecommissionInfo>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct PoolMeta {
+    pub version: u16,
     pub pools: Vec<PoolStatus>,
     pub dont_save: bool,
 }
@@ -33,6 +44,7 @@ impl PoolMeta {
         }
 
         Self {
+            version: POOL_META_VERSION,
             pools: status,
             dont_save: false,
         }
@@ -46,6 +58,62 @@ impl PoolMeta {
         self.pools[idx].decommission.is_some()
     }
 
+    pub async fn load(&mut self, store: &ECStore) -> Result<()> {
+        let data = match read_config(store, POOL_META_NAME).await {
+            Ok(data) => {
+                if data.is_empty() {
+                    return Ok(());
+                } else if data.len() <= 4 {
+                    return Err(Error::from_string("poolMeta: no data"));
+                }
+                data
+            }
+            Err(err) => {
+                if let Some(ConfigError::NotFound) = err.downcast_ref::<ConfigError>() {
+                    return Ok(());
+                }
+                return Err(err);
+            }
+        };
+        let format = LittleEndian::read_u16(&data[0..2]);
+        if format != POOL_META_FORMAT {
+            return Err(Error::msg(format!("PoolMeta: unknown format: {}", format)));
+        }
+        let version = LittleEndian::read_u16(&data[2..4]);
+        if version != POOL_META_VERSION {
+            return Err(Error::msg(format!("PoolMeta: unknown version: {}", version)));
+        }
+
+        let mut buf = Deserializer::new(Cursor::new(&data[4..]));
+        let meta: PoolMeta = Deserialize::deserialize(&mut buf).unwrap();
+        *self = meta;
+
+        if self.version != POOL_META_VERSION {
+            return Err(Error::msg(format!("unexpected PoolMeta version: {}", self.version)));
+        }
+        Ok(())
+    }
+
+    pub async fn save(&self) -> Result<()> {
+        if self.dont_save {
+            return Ok(());
+        }
+        let mut data = Vec::new();
+        data.write_u16::<LittleEndian>(POOL_META_FORMAT).unwrap();
+        data.write_u16::<LittleEndian>(POOL_META_VERSION).unwrap();
+        let mut buf = Vec::new();
+        self.serialize(&mut Serializer::new(&mut buf))?;
+        data.write_all(&buf)?;
+
+        let layer = new_object_layer_fn();
+        let lock = layer.read().await;
+        let store = match lock.as_ref() {
+            Some(s) => s,
+            None => return Err(Error::from_string("errServerNotInitialized".to_string())),
+        };
+        save_config(store, &POOL_META_NAME, &data).await
+    }
+
     pub fn decommission_cancel(&mut self, idx: usize) -> bool {
         if let Some(stats) = self.pools.get_mut(idx) {
             if let Some(d) = &stats.decommission {
@@ -72,7 +140,7 @@ impl PoolMeta {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Default)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct PoolDecommissionInfo {
     pub start_time: Option<OffsetDateTime>,
     pub start_size: usize,
@@ -103,7 +171,7 @@ pub struct PoolSpaceInfo {
 impl ECStore {
     pub async fn status(&self, idx: usize) -> Result<PoolStatus> {
         let space_info = self.get_decommission_pool_space_info(idx).await?;
-        let mut pool_info = self.pool_meta.pools[idx].clone();
+        let mut pool_info = self.pool_meta.read().unwrap().pools[idx].clone();
         if let Some(d) = pool_info.decommission.as_mut() {
             d.total_size = space_info.total;
             d.current_size = space_info.free;
@@ -149,7 +217,7 @@ impl ECStore {
             return Err(Error::new(StorageError::DecommissionNotStarted));
         }
 
-        if self.pool_meta.decommission_cancel(idx) {
+        if self.pool_meta.write().unwrap().decommission_cancel(idx) {
             // FIXME:
         }
 
@@ -182,3 +250,33 @@ fn get_total_usable_capacity_free(disks: &Vec<StorageDisk>, info: &StorageInfo)
     }
     capacity
 }
+
+#[test]
+fn test_pool_meta() -> Result<()> {
+    let meta = PoolMeta::new(vec![]);
+    let mut data = Vec::new();
+    data.write_u16::<LittleEndian>(POOL_META_FORMAT).unwrap();
+    data.write_u16::<LittleEndian>(POOL_META_VERSION).unwrap();
+    let mut buf = Vec::new();
+    meta.serialize(&mut Serializer::new(&mut buf))?;
+    data.write_all(&buf)?;
+
+    let format = LittleEndian::read_u16(&data[0..2]);
+    if format != POOL_META_FORMAT {
+        return Err(Error::msg(format!("PoolMeta: unknown format: {}", format)));
+    }
+    let version = LittleEndian::read_u16(&data[2..4]);
+    if version != POOL_META_VERSION {
+        return Err(Error::msg(format!("PoolMeta: unknown version: {}", version)));
+    }
+
+    let mut buf = Deserializer::new(Cursor::new(&data[4..]));
+    let de_meta: PoolMeta = Deserialize::deserialize(&mut buf).unwrap();
+
+    if de_meta.version != POOL_META_VERSION {
+        return Err(Error::msg(format!("unexpected PoolMeta version: {}", de_meta.version)));
+    }
+
+    println!("meta: {:?}", de_meta);
+    Ok(())
+}
diff --git a/ecstore/src/store.rs b/ecstore/src/store.rs
index 927bcdc7a..7e3124cf0 100644
--- a/ecstore/src/store.rs
+++ b/ecstore/src/store.rs
@@ -55,7 +55,7 @@ use std::slice::Iter;
 use std::time::SystemTime;
 use std::{
     collections::{HashMap, HashSet},
-    sync::Arc,
+    sync::{Arc, RwLock as std_RwLock},
     time::Duration,
 };
 use time::OffsetDateTime;
@@ -68,7 +68,7 @@ use uuid::Uuid;
 
 const MAX_UPLOADS_LIST: usize = 10000;
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct ECStore {
     pub id: uuid::Uuid,
     // pub disks: Vec<DiskStore>,
@@ -76,10 +76,27 @@ pub struct ECStore {
     pub pools: Vec<Arc<Sets>>,
     pub peer_sys: S3PeerSys,
     // pub local_disks: Vec<DiskStore>,
-    pub pool_meta: PoolMeta,
+    pub pool_meta: std_RwLock<PoolMeta>,
     pub decommission_cancelers: Vec<Option<usize>>,
 }
 
+impl Clone for ECStore {
+    fn clone(&self) -> Self {
+        let pool_meta = match self.pool_meta.read() {
+            Ok(pool_meta) => pool_meta.clone(),
+            Err(_) => PoolMeta::default(),
+        };
+        Self {
+            id: self.id.clone(),
+            disk_map: self.disk_map.clone(),
+            pools: self.pools.clone(),
+            peer_sys: self.peer_sys.clone(),
+            pool_meta: std_RwLock::new(pool_meta),
+            decommission_cancelers: self.decommission_cancelers.clone(),
+        }
+    }
+}
+
 impl ECStore {
     #[allow(clippy::new_ret_no_self)]
     pub async fn new(_address: String, endpoint_pools: EndpointServerPools) -> Result<Self> {
@@ -189,7 +206,7 @@ impl ECStore {
         if !is_dist_erasure().await {
             let mut global_local_disk_map = GLOBAL_LOCAL_DISK_MAP.write().await;
             for disk in local_disks {
-                let path = disk.path().to_string_lossy().to_string();
+                let path = disk.endpoint().to_string();
                 global_local_disk_map.insert(path, Some(disk.clone()));
             }
         }
@@ -204,7 +221,7 @@ impl ECStore {
             disk_map,
             pools,
             peer_sys,
-            pool_meta,
+            pool_meta: pool_meta.into(),
             decommission_cancelers,
         };
 
@@ -480,7 +497,10 @@ impl ECStore {
 
     fn is_suspended(&self, idx: usize) -> bool {
         // TODO: LOCK
-        self.pool_meta.is_suspended(idx)
+        match self.pool_meta.read() {
+            Ok(pool_meta) => pool_meta.is_suspended(idx),
+            Err(_) => false,
+        }
     }
 
     async fn get_pool_idx(&self, bucket: &str, object: &str, size: i64) -> Result<usize> {
@@ -575,7 +595,7 @@ impl ECStore {
         let mut has_def_pool = false;
 
         for pinfo in ress.iter() {
-            if opts.skip_decommissioned && self.pool_meta.is_suspended(pinfo.index) {
+            if opts.skip_decommissioned && self.pool_meta.read().unwrap().is_suspended(pinfo.index) {
                 continue;
             }
 
@@ -616,7 +636,7 @@ impl ECStore {
     fn pools_with_object(&self, pools: &Vec<PoolObjInfo>, opts: &ObjectOptions) -> Vec<PoolErr> {
         let mut errs = Vec::new();
         for pool in pools.iter() {
-            if opts.skip_decommissioned && self.pool_meta.is_suspended(pool.index) {
+            if opts.skip_decommissioned && self.pool_meta.read().unwrap().is_suspended(pool.index) {
                 continue;
             }
             // TODO:SkipRebalancing
@@ -869,6 +889,13 @@ impl ECStore {
 
         Ok(objs[0].as_ref().unwrap().clone())
     }
+
+    pub async fn reload_pool_meta(&self) -> Result<()> {
+        let mut meta = PoolMeta::default();
+        meta.load(self).await?;
+        *self.pool_meta.write().unwrap() = meta;
+        Ok(())
+    }
 }
 
 async fn update_scan(
@@ -965,7 +992,7 @@ pub async fn init_local_disks(endpoint_pools: EndpointServerPools) -> Result<()>
 
             let disk = new_disk(ep, opt).await?;
 
-            let path = disk.path().to_string_lossy().to_string();
+            let path = disk.endpoint().to_string();
 
             global_local_disk_map.insert(path, Some(disk.clone()));
 
diff --git a/ecstore/src/store_api.rs b/ecstore/src/store_api.rs
index 2853f884e..75cb4133b 100644
--- a/ecstore/src/store_api.rs
+++ b/ecstore/src/store_api.rs
@@ -795,7 +795,7 @@ pub struct DeletedObject {
     // pub replication_state: ReplicationState,
 }
 
-#[derive(Debug, Default, Serialize)]
+#[derive(Debug, Default, Serialize, Deserialize)]
 pub enum BackendByte {
     #[default]
     Unknown,
@@ -833,13 +833,13 @@ pub struct StorageDisk {
     pub disk_index: i32,
 }
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Serialize, Deserialize)]
 pub struct StorageInfo {
     pub disks: Vec<StorageDisk>,
     pub backend: BackendInfo,
 }
 
-#[derive(Debug, Default, Serialize)]
+#[derive(Debug, Default, Serialize, Deserialize)]
 pub struct BackendDisks(HashMap<String, usize>);
 
 impl BackendDisks {
@@ -851,7 +851,7 @@ impl BackendDisks {
     }
 }
 
-#[derive(Debug, Default, Serialize)]
+#[derive(Debug, Default, Serialize, Deserialize)]
 #[serde(rename_all = "PascalCase", default)]
 pub struct BackendInfo {
     pub backend_type: BackendByte,
diff --git a/madmin/Cargo.toml b/madmin/Cargo.toml
new file mode 100644
index 000000000..d0b8cd6f5
--- /dev/null
+++ b/madmin/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "madmin"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+ecstore.workspace = true
+psutil = "3.3.0"
+serde.workspace = true
diff --git a/madmin/src/heal_command.rs b/madmin/src/heal_command.rs
new file mode 100644
index 000000000..ad87352af
--- /dev/null
+++ b/madmin/src/heal_command.rs
@@ -0,0 +1,115 @@
+use std::collections::{HashMap, HashSet};
+
+use ecstore::{
+    config::storageclass::{RRS, STANDARD},
+    global::GLOBAL_BackgroundHealState,
+    heal::{background_heal_ops::get_local_disks_to_heal, heal_ops::BG_HEALING_UUID},
+    new_object_layer_fn,
+    store_api::{StorageAPI, StorageDisk},
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct MRFStatus {
+    bytes_healed: u64,
+    items_healed: u64,
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct SetStatus {
+    pub id: String,
+    pub pool_index: i32,
+    pub set_index: i32,
+    pub heal_status: String,
+    pub heal_priority: String,
+    pub total_objects: usize,
+    pub disks: Vec<StorageDisk>,
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct BgHealState {
+    offline_endpoints: Vec<String>,
+    scanned_items_count: u64,
+    heal_disks: Vec<String>,
+    sets: Vec<SetStatus>,
+    mrf: HashMap<String, MRFStatus>,
+    scparity: HashMap<String, usize>,
+}
+
+pub async fn get_local_background_heal_status() -> (BgHealState, bool) {
+    let (bg_seq, ok) = GLOBAL_BackgroundHealState
+        .read()
+        .await
+        .get_heal_sequence_by_token(BG_HEALING_UUID)
+        .await;
+    if !ok {
+        return (BgHealState::default(), false);
+    }
+    let bg_seq = bg_seq.unwrap();
+    let mut status = BgHealState {
+        scanned_items_count: bg_seq.read().await.get_scanned_items_count() as u64,
+        ..Default::default()
+    };
+    let mut heal_disks_map = HashSet::new();
+    for ep in get_local_disks_to_heal().await.iter() {
+        heal_disks_map.insert(ep.to_string());
+    }
+
+    let layer = new_object_layer_fn();
+    let lock = layer.read().await;
+    let store = match lock.as_ref() {
+        Some(s) => s,
+        None => {
+            let healing = GLOBAL_BackgroundHealState.read().await.get_local_healing_disks().await;
+            for disk in healing.values() {
+                status.heal_disks.push(disk.endpoint.clone());
+            }
+            return (status, true);
+        }
+    };
+
+    let si = store.local_storage_info().await;
+    let mut indexed = HashMap::new();
+    for disk in si.disks.iter() {
+        let set_idx = format!("{}-{}", disk.pool_index, disk.set_index);
+        // indexed.insert(set_idx, disk);
+        indexed.entry(set_idx).or_insert(Vec::new()).push(disk);
+    }
+
+    for (id, disks) in indexed {
+        let mut ss = SetStatus {
+            id,
+            set_index: disks[0].set_index,
+            pool_index: disks[0].pool_index,
+            ..Default::default()
+        };
+        for disk in disks {
+            ss.disks.push(disk.clone());
+            if disk.healing {
+                ss.heal_status = "healing".to_string();
+                ss.heal_priority = "high".to_string();
+                status.heal_disks.push(disk.endpoint.clone());
+            }
+        }
+        ss.disks.sort_by(|a, b| {
+            if a.pool_index != b.pool_index {
+                return a.pool_index.cmp(&b.pool_index);
+            }
+            if a.set_index != b.set_index {
+                return a.set_index.cmp(&b.set_index);
+            }
+            a.disk_index.cmp(&b.disk_index)
+        });
+        status.sets.push(ss);
+    }
+    status.sets.sort_by(|a, b| a.id.cmp(&b.id));
+    let backend_info = store.backend_info().await;
+    status
+        .scparity
+        .insert(STANDARD.to_string(), backend_info.standard_sc_parity.unwrap_or_default());
+    status
+        .scparity
+        .insert(RRS.to_string(), backend_info.rr_sc_parity.unwrap_or_default());
+
+    (status, true)
+}
diff --git a/madmin/src/health.rs b/madmin/src/health.rs
new file mode 100644
index 000000000..25d3fec9a
--- /dev/null
+++ b/madmin/src/health.rs
@@ -0,0 +1,177 @@
+use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct NodeCommon {
+    pub addr: String,
+    pub error: String,
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct Cpu {
+    vendor_id: String,
+    family: String,
+    model: String,
+    stepping: i32,
+    physical_id: String,
+    model_name: String,
+    mhz: f64,
+    cache_size: i32,
+    flags: Vec<String>,
+    microcode: String,
+    cores: u64,
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct CpuFreqStats {
+    name: String,
+    cpuinfo_current_frequency: Option<u64>,
+    cpuinfo_minimum_frequency: Option<u64>,
+    cpuinfo_maximum_frequency: Option<u64>,
+    cpuinfo_transition_latency: Option<u64>,
+    scaling_current_frequency: Option<u64>,
+    scaling_minimum_frequency: Option<u64>,
+    scaling_maximum_frequency: Option<u64>,
+    available_governors: String,
+    driver: String,
+    governor: String,
+    related_cpus: String,
+    set_speed: String,
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct Cpus {
+    node_common: NodeCommon,
+    cpus: Vec<Cpu>,
+    cpu_freq_stats: Vec<CpuFreqStats>,
+}
+
+pub fn get_cpus() -> Cpus {
+    // todo
+    Cpus::default()
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct Partition {
+    pub error: String,
+    device: String,
+    model: String,
+    revision: String,
+    mountpoint: String,
+    fs_type: String,
+    mount_options: String,
+    space_total: u64,
+    space_free: u64,
+    inode_total: u64,
+    inode_free: u64,
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct Partitions {
+    node_common: NodeCommon,
+    partitions: Vec<Partition>,
+}
+
+pub fn get_partitions() -> Partitions {
+    Partitions::default()
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct OsInfo {
+    node_common: NodeCommon,
+}
+
+pub fn get_os_info() -> OsInfo {
+    OsInfo::default()
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct ProcInfo {
+    node_common: NodeCommon,
+    pid: i32,
+    is_background: bool,
+    cpu_percent: f64,
+    children_pids: Vec<i32>,
+    cmd_line: String,
+    num_connections: usize,
+    create_time: u64,
+    cwd: String,
+    exec_path: String,
+    gids: Vec<i32>,
+    // io_counters:
+    is_running: bool,
+    // mem_info:
+    // mem_maps:
+    mem_percent: f32,
+    name: String,
+    nice: i32,
+    //num_ctx_switches:
+    num_fds: i32,
+    num_threads: i32,
+    // page_faults:
+    ppid: i32,
+    status: String,
+    tgid: i32,
+    uids: Vec<i32>,
+    username: String,
+}
+
+pub fn get_proc_info(_addr: &str) -> ProcInfo {
+    ProcInfo::default()
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct SysService {
+    name: String,
+    status: String,
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct SysServices {
+    node_common: NodeCommon,
+    services: Vec<SysService>,
+}
+
+pub fn get_sys_services(_add: &str) -> SysServices {
+    SysServices::default()
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct SysConfig {
+    node_common: NodeCommon,
+    config: HashMap<String, String>,
+}
+
+pub fn get_sys_config(_addr: &str) -> SysConfig {
+    SysConfig::default()
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct SysErrors {
+    node_common: NodeCommon,
+    errors: Vec<String>,
+}
+
+pub fn get_sys_errors(_add: &str) -> SysErrors {
+    SysErrors::default()
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct MemInfo {
+    node_common: NodeCommon,
+    total: u64,
+    used: u64,
+    free: u64,
+    available: u64,
+    shared: u64,
+    cache: u64,
+    buffers: u64,
+    swap_space_total: u64,
+    swap_space_free: u64,
+    limit: u64,
+}
+
+pub fn get_mem_info(_addr: &str) -> MemInfo {
+    MemInfo::default()
+}
diff --git a/madmin/src/lib.rs b/madmin/src/lib.rs
new file mode 100644
index 000000000..11da4062f
--- /dev/null
+++ b/madmin/src/lib.rs
@@ -0,0 +1,4 @@
+pub mod heal_command;
+pub mod health;
+pub mod metrics;
+pub mod net;
diff --git a/madmin/src/metrics.rs b/madmin/src/metrics.rs
new file mode 100644
index 000000000..15abc0bfc
--- /dev/null
+++ b/madmin/src/metrics.rs
@@ -0,0 +1,69 @@
+use std::collections::{HashMap, HashSet};
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct TimedAction {
+    count: u64,
+    acc_time: u64,
+    bytes: u64,
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct DiskIOStats {
+    read_ios: u64,
+    read_merges: u64,
+    read_sectors: u64,
+    read_ticks: u64,
+    write_ios: u64,
+    write_merges: u64,
+    write_sectors: u64,
+    write_ticks: u64,
+    current_ios: u64,
+    total_ticks: u64,
+    req_ticks: u64,
+    discard_ios: u64,
+    discard_merges: u64,
+    discard_sectors: u64,
+    discard_ticks: u64,
+    flush_ios: u64,
+    flush_ticks: u64,
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct DiskMetric {
+    collected_at: u64,
+    n_disks: usize,
+    offline: usize,
+    healing: usize,
+    life_time_ops: HashMap<String, u64>,
+    last_minute: HashMap<String, TimedAction>,
+    io_stats: DiskIOStats,
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct Metrics {}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct RealtimeMetrics {
+    errors: Vec<String>,
+    hosts: Vec<String>,
+    aggregated: Metrics,
+    by_host: HashMap<String, Metrics>,
+    by_disk: HashMap<String, DiskMetric>,
+    finally: bool,
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct CollectMetricsOpts {
+    hosts: HashSet<String>,
+    disks: HashSet<String>,
+    job_id: String,
+    dep_id: String,
+}
+
+pub type MetricType = u64;
+
+pub fn collect_local_metrics(_types: MetricType, _opts: &CollectMetricsOpts) -> RealtimeMetrics {
+    RealtimeMetrics::default()
+}
diff --git a/madmin/src/net/mod.rs b/madmin/src/net/mod.rs
new file mode 100644
index 000000000..6b06e5f45
--- /dev/null
+++ b/madmin/src/net/mod.rs
@@ -0,0 +1,14 @@
+use serde::{Deserialize, Serialize};
+
+use crate::health::NodeCommon;
+
+#[cfg(target_os = "linux")]
+pub mod net_linux;
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct NetInfo {
+    node_common: NodeCommon,
+    interface: String,
+    driver: String,
+    firmware_version: String,
+}
diff --git a/madmin/src/net/net_linux.rs b/madmin/src/net/net_linux.rs
new file mode 100644
index 000000000..a206f708e
--- /dev/null
+++ b/madmin/src/net/net_linux.rs
@@ -0,0 +1,9 @@
+use super::NetInfo;
+
+pub fn get_net_info(addr: &str, iface: &str) -> NetInfo {
+    let mut ni = NetInfo::default();
+    ni.node_common.addr = addr.to_string();
+    ni.interface = iface.to_string();
+
+    ni
+}
diff --git a/rustfs/Cargo.toml b/rustfs/Cargo.toml
index 57f84ab15..efb93c056 100644
--- a/rustfs/Cargo.toml
+++ b/rustfs/Cargo.toml
@@ -9,6 +9,7 @@ rust-version.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+madmin.workspace = true
 log.workspace = true
 async-trait.workspace = true
 bytes.workspace = true
@@ -31,7 +32,9 @@ prost.workspace = true
 prost-types.workspace = true
 protos.workspace = true
 protobuf.workspace = true
+rmp-serde.workspace = true
 s3s.workspace = true
+serde.workspace = true
 serde_json.workspace = true
 tracing.workspace = true
 time = { workspace = true, features = ["parsing", "formatting"] }
@@ -51,13 +54,13 @@ tracing-error.workspace = true
 tracing-subscriber.workspace = true
 transform-stream.workspace = true
 uuid = "1.11.0"
+url.workspace = true
 admin = { path = "../api/admin" }
 axum.workspace = true
 matchit = "0.8.4"
 shadow-rs = "0.35.2"
 const-str = { version = "0.5.7", features = ["std", "proc"] }
 atoi = "2.0.0"
-serde.workspace = true
 serde_urlencoded = "0.7.1"
 
 [build-dependencies]
diff --git a/rustfs/src/grpc.rs b/rustfs/src/grpc.rs
index 0567f66f9..da9a744e9 100644
--- a/rustfs/src/grpc.rs
+++ b/rustfs/src/grpc.rs
@@ -1,36 +1,43 @@
-use std::{error::Error, io::ErrorKind, pin::Pin};
+use std::{
+    collections::HashMap,
+    error::Error,
+    io::{Cursor, ErrorKind},
+    pin::Pin,
+    sync::Arc,
+};
 
 use ecstore::{
+    admin_server_info::get_local_server_property,
+    bucket::{metadata::load_bucket_metadata, metadata_sys::GLOBAL_BucketMetadataSys},
     disk::{
         DeleteOptions, DiskAPI, DiskInfoOptions, DiskStore, FileInfoVersions, ReadMultipleReq, ReadOptions, Reader,
         UpdateMetadataOpts, WalkDirOptions,
     },
     erasure::Writer,
     heal::{data_usage_cache::DataUsageCache, heal_commands::HealOpts},
+    new_object_layer_fn,
     peer::{LocalPeerS3Client, PeerS3Client},
     store::{all_local_disk_path, find_local_disk},
-    store_api::{BucketOptions, DeleteBucketOptions, FileInfo, MakeBucketOptions},
+    store_api::{BucketOptions, DeleteBucketOptions, FileInfo, MakeBucketOptions, StorageAPI},
 };
 use futures::{Stream, StreamExt};
 use lock::{lock_args::LockArgs, Locker, GLOBAL_LOCAL_SERVER};
 
+use common::globals::GLOBAL_Local_Node_Name;
+use madmin::net::net_linux::get_net_info;
+use madmin::{
+    heal_command::get_local_background_heal_status,
+    health::{
+        get_cpus, get_mem_info, get_os_info, get_partitions, get_proc_info, get_sys_config, get_sys_errors, get_sys_services,
+    },
+    metrics::{collect_local_metrics, CollectMetricsOpts},
+};
 use protos::{
     models::{PingBody, PingBodyBuilder},
-    proto_gen::node_service::{
-        node_service_server::NodeService as Node, CheckPartsRequest, CheckPartsResponse, DeleteBucketRequest,
-        DeleteBucketResponse, DeletePathsRequest, DeletePathsResponse, DeleteRequest, DeleteResponse, DeleteVersionRequest,
-        DeleteVersionResponse, DeleteVersionsRequest, DeleteVersionsResponse, DeleteVolumeRequest, DeleteVolumeResponse,
-        DiskInfoRequest, DiskInfoResponse, GenerallyLockRequest, GenerallyLockResponse, GetBucketInfoRequest,
-        GetBucketInfoResponse, HealBucketRequest, HealBucketResponse, ListBucketRequest, ListBucketResponse, ListDirRequest,
-        ListDirResponse, ListVolumesRequest, ListVolumesResponse, MakeBucketRequest, MakeBucketResponse, MakeVolumeRequest,
-        MakeVolumeResponse, MakeVolumesRequest, MakeVolumesResponse, NsScannerRequest, NsScannerResponse, PingRequest,
-        PingResponse, ReadAllRequest, ReadAllResponse, ReadAtRequest, ReadAtResponse, ReadMultipleRequest, ReadMultipleResponse,
-        ReadVersionRequest, ReadVersionResponse, ReadXlRequest, ReadXlResponse, RenameDataRequest, RenameDataResponse,
-        RenameFileRequst, RenameFileResponse, RenamePartRequst, RenamePartResponse, StatVolumeRequest, StatVolumeResponse,
-        UpdateMetadataRequest, UpdateMetadataResponse, VerifyFileRequest, VerifyFileResponse, WalkDirRequest, WalkDirResponse,
-        WriteAllRequest, WriteAllResponse, WriteMetadataRequest, WriteMetadataResponse, WriteRequest, WriteResponse,
-    },
+    proto_gen::node_service::{node_service_server::NodeService as Node, *},
 };
+use rmp_serde::{Deserializer, Serializer};
+use serde::{Deserialize, Serialize};
 use tokio::sync::mpsc;
 use tokio_stream::wrappers::ReceiverStream;
 use tonic::{Request, Response, Status, Streaming};
@@ -1506,4 +1513,657 @@ impl Node for NodeService {
             })),
         }
     }
+
+    async fn local_storage_info(
+        &self,
+        _request: Request<LocalStorageInfoRequest>,
+    ) -> Result<Response<LocalStorageInfoResponse>, Status> {
+        // let request = request.into_inner();
+        let layer = new_object_layer_fn();
+        let lock = layer.read().await;
+        let store = match lock.as_ref() {
+            Some(s) => s,
+            None => {
+                return Ok(tonic::Response::new(LocalStorageInfoResponse {
+                    success: false,
+                    storage_info: vec![],
+                    error_info: Some("errServerNotInitialized".to_string()),
+                }))
+            }
+        };
+
+        let info = store.local_storage_info().await;
+        let mut buf = Vec::new();
+        if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
+            return Ok(tonic::Response::new(LocalStorageInfoResponse {
+                success: false,
+                storage_info: vec![],
+                error_info: Some(err.to_string()),
+            }));
+        }
+
+        Ok(tonic::Response::new(LocalStorageInfoResponse {
+            success: true,
+            storage_info: buf,
+            error_info: None,
+        }))
+    }
+
+    async fn server_info(&self, _request: Request<ServerInfoRequest>) -> Result<Response<ServerInfoResponse>, Status> {
+        let info = get_local_server_property().await;
+        let mut buf = Vec::new();
+        if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
+            return Ok(tonic::Response::new(ServerInfoResponse {
+                success: false,
+                server_properties: vec![],
+                error_info: Some(err.to_string()),
+            }));
+        }
+        Ok(tonic::Response::new(ServerInfoResponse {
+            success: true,
+            server_properties: buf,
+            error_info: None,
+        }))
+    }
+
+    async fn get_cpus(&self, _request: Request<GetCpusRequest>) -> Result<Response<GetCpusResponse>, Status> {
+        let info = get_cpus();
+        let mut buf = Vec::new();
+        if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
+            return Ok(tonic::Response::new(GetCpusResponse {
+                success: false,
+                cpus: vec![],
+                error_info: Some(err.to_string()),
+            }));
+        }
+        Ok(tonic::Response::new(GetCpusResponse {
+            success: true,
+            cpus: buf,
+            error_info: None,
+        }))
+    }
+
+    async fn get_net_info(&self, _request: Request<GetNetInfoRequest>) -> Result<Response<GetNetInfoResponse>, Status> {
+        let addr = GLOBAL_Local_Node_Name.read().await.clone();
+        let info = get_net_info(&addr, "");
+        let mut buf = Vec::new();
+        if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
+            return Ok(tonic::Response::new(GetNetInfoResponse {
+                success: false,
+                net_info: vec![],
+                error_info: Some(err.to_string()),
+            }));
+        }
+        Ok(tonic::Response::new(GetNetInfoResponse {
+            success: true,
+            net_info: buf,
+            error_info: None,
+        }))
+    }
+
+    async fn get_partitions(&self, _request: Request<GetPartitionsRequest>) -> Result<Response<GetPartitionsResponse>, Status> {
+        let partitions = get_partitions();
+        let mut buf = Vec::new();
+        if let Err(err) = partitions.serialize(&mut Serializer::new(&mut buf)) {
+            return Ok(tonic::Response::new(GetPartitionsResponse {
+                success: false,
+                partitions: vec![],
+                error_info: Some(err.to_string()),
+            }));
+        }
+        Ok(tonic::Response::new(GetPartitionsResponse {
+            success: true,
+            partitions: buf,
+            error_info: None,
+        }))
+    }
+
+    async fn get_os_info(&self, _request: Request<GetOsInfoRequest>) -> Result<Response<GetOsInfoResponse>, Status> {
+        let os_info = get_os_info();
+        let mut buf = Vec::new();
+        if let Err(err) = os_info.serialize(&mut Serializer::new(&mut buf)) {
+            return Ok(tonic::Response::new(GetOsInfoResponse {
+                success: false,
+                os_info: vec![],
+                error_info: Some(err.to_string()),
+            }));
+        }
+        Ok(tonic::Response::new(GetOsInfoResponse {
+            success: true,
+            os_info: buf,
+            error_info: None,
+        }))
+    }
+
+    async fn get_se_linux_info(
+        &self,
+        _request: Request<GetSeLinuxInfoRequest>,
+    ) -> Result<Response<GetSeLinuxInfoResponse>, Status> {
+        let addr = GLOBAL_Local_Node_Name.read().await.clone();
+        let info = get_sys_services(&addr);
+        let mut buf = Vec::new();
+        if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
+            return Ok(tonic::Response::new(GetSeLinuxInfoResponse {
+                success: false,
+                sys_services: vec![],
+                error_info: Some(err.to_string()),
+            }));
+        }
+        Ok(tonic::Response::new(GetSeLinuxInfoResponse {
+            success: true,
+            sys_services: buf,
+            error_info: None,
+        }))
+    }
+
+    async fn get_sys_config(&self, _request: Request<GetSysConfigRequest>) -> Result<Response<GetSysConfigResponse>, Status> {
+        let addr = GLOBAL_Local_Node_Name.read().await.clone();
+        let info = get_sys_config(&addr);
+        let mut buf = Vec::new();
+        if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
+            return Ok(tonic::Response::new(GetSysConfigResponse {
+                success: false,
+                sys_config: vec![],
+                error_info: Some(err.to_string()),
+            }));
+        }
+        Ok(tonic::Response::new(GetSysConfigResponse {
+            success: true,
+            sys_config: buf,
+            error_info: None,
+        }))
+    }
+
+    async fn get_sys_errors(&self, _request: Request<GetSysErrorsRequest>) -> Result<Response<GetSysErrorsResponse>, Status> {
+        let addr = GLOBAL_Local_Node_Name.read().await.clone();
+        let info = get_sys_errors(&addr);
+        let mut buf = Vec::new();
+        if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
+            return Ok(tonic::Response::new(GetSysErrorsResponse {
+                success: false,
+                sys_errors: vec![],
+                error_info: Some(err.to_string()),
+            }));
+        }
+        Ok(tonic::Response::new(GetSysErrorsResponse {
+            success: true,
+            sys_errors: buf,
+            error_info: None,
+        }))
+    }
+
+    async fn get_mem_info(&self, _request: Request<GetMemInfoRequest>) -> Result<Response<GetMemInfoResponse>, Status> {
+        let addr = GLOBAL_Local_Node_Name.read().await.clone();
+        let info = get_mem_info(&addr);
+        let mut buf = Vec::new();
+        if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
+            return Ok(tonic::Response::new(GetMemInfoResponse {
+                success: false,
+                mem_info: vec![],
+                error_info: Some(err.to_string()),
+            }));
+        }
+        Ok(tonic::Response::new(GetMemInfoResponse {
+            success: true,
+            mem_info: buf,
+            error_info: None,
+        }))
+    }
+
+    async fn get_metrics(&self, request: Request<GetMetricsRequest>) -> Result<Response<GetMetricsResponse>, Status> {
+        let request = request.into_inner();
+        let mut buf = Deserializer::new(Cursor::new(request.opts));
+        let opts: CollectMetricsOpts = Deserialize::deserialize(&mut buf).unwrap();
+        let info = collect_local_metrics(request.metric_type, &opts);
+        let mut buf = Vec::new();
+        if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
+            return Ok(tonic::Response::new(GetMetricsResponse {
+                success: false,
+                realtime_metrics: vec![],
+                error_info: Some(err.to_string()),
+            }));
+        }
+        Ok(tonic::Response::new(GetMetricsResponse {
+            success: true,
+            realtime_metrics: buf,
+            error_info: None,
+        }))
+    }
+
+    async fn get_proc_info(&self, _request: Request<GetProcInfoRequest>) -> Result<Response<GetProcInfoResponse>, Status> {
+        let addr = GLOBAL_Local_Node_Name.read().await.clone();
+        let info = get_proc_info(&addr);
+        let mut buf = Vec::new();
+        if let Err(err) = info.serialize(&mut Serializer::new(&mut buf)) {
+            return Ok(tonic::Response::new(GetProcInfoResponse {
+                success: false,
+                proc_info: vec![],
+                error_info: Some(err.to_string()),
+            }));
+        }
+        Ok(tonic::Response::new(GetProcInfoResponse {
+            success: true,
+            proc_info: buf,
+            error_info: None,
+        }))
+    }
+
+    async fn start_profiling(
+        &self,
+        _request: Request<StartProfilingRequest>,
+    ) -> Result<Response<StartProfilingResponse>, Status> {
+        todo!()
+    }
+
+    async fn download_profile_data(
+        &self,
+        _request: Request<DownloadProfileDataRequest>,
+    ) -> Result<Response<DownloadProfileDataResponse>, Status> {
+        todo!()
+    }
+
+    async fn get_bucket_stats(
+        &self,
+        _request: Request<GetBucketStatsDataRequest>,
+    ) -> Result<Response<GetBucketStatsDataResponse>, Status> {
+        todo!()
+    }
+
+    async fn get_sr_metrics(
+        &self,
+        _request: Request<GetSrMetricsDataRequest>,
+    ) -> Result<Response<GetSrMetricsDataResponse>, Status> {
+        todo!()
+    }
+
+    async fn get_all_bucket_stats(
+        &self,
+        _request: Request<GetAllBucketStatsRequest>,
+    ) -> Result<Response<GetAllBucketStatsResponse>, Status> {
+        todo!()
+    }
+
+    async fn load_bucket_metadata(
+        &self,
+        request: Request<LoadBucketMetadataRequest>,
+    ) -> Result<Response<LoadBucketMetadataResponse>, Status> {
+        let request = request.into_inner();
+        let bucket = request.bucket;
+        if bucket.is_empty() {
+            return Ok(tonic::Response::new(LoadBucketMetadataResponse {
+                success: false,
+                error_info: Some("bucket name is missing".to_string()),
+            }));
+        }
+
+        let layer = new_object_layer_fn();
+        let lock = layer.read().await;
+        let store = match lock.as_ref() {
+            Some(s) => s,
+            None => {
+                return Ok(tonic::Response::new(LoadBucketMetadataResponse {
+                    success: false,
+                    error_info: Some("errServerNotInitialized".to_string()),
+                }))
+            }
+        };
+        match load_bucket_metadata(store, &bucket).await {
+            Ok(meta) => {
+                GLOBAL_BucketMetadataSys.write().await.set(bucket, Arc::new(meta)).await;
+                Ok(tonic::Response::new(LoadBucketMetadataResponse {
+                    success: true,
+                    error_info: None,
+                }))
+            }
+            Err(err) => Ok(tonic::Response::new(LoadBucketMetadataResponse {
+                success: false,
+                error_info: Some(err.to_string()),
+            })),
+        }
+    }
+
+    async fn delete_bucket_metadata(
+        &self,
+        request: Request<DeleteBucketMetadataRequest>,
+    ) -> Result<Response<DeleteBucketMetadataResponse>, Status> {
+        let request = request.into_inner();
+        let _bucket = request.bucket;
+
+        //todo
+        Ok(tonic::Response::new(DeleteBucketMetadataResponse {
+            success: true,
+            error_info: None,
+        }))
+    }
+
+    async fn delete_policy(&self, request: Request<DeletePolicyRequest>) -> Result<Response<DeletePolicyResponse>, Status> {
+        let request = request.into_inner();
+        let policy = request.policy_name;
+        if policy.is_empty() {
+            return Ok(tonic::Response::new(DeletePolicyResponse {
+                success: false,
+                error_info: Some("policy name is missing".to_string()),
+            }));
+        }
+
+        let layer = new_object_layer_fn();
+        let lock = layer.read().await;
+        let _store = match lock.as_ref() {
+            Some(s) => s,
+            None => {
+                return Ok(tonic::Response::new(DeletePolicyResponse {
+                    success: false,
+                    error_info: Some("errServerNotInitialized".to_string()),
+                }))
+            }
+        };
+
+        todo!()
+    }
+
+    async fn load_policy(&self, request: Request<LoadPolicyRequest>) -> Result<Response<LoadPolicyResponse>, Status> {
+        let request = request.into_inner();
+        let policy = request.policy_name;
+        if policy.is_empty() {
+            return Ok(tonic::Response::new(LoadPolicyResponse {
+                success: false,
+                error_info: Some("policy name is missing".to_string()),
+            }));
+        }
+        let layer = new_object_layer_fn();
+        let lock = layer.read().await;
+        let _store = match lock.as_ref() {
+            Some(s) => s,
+            None => {
+                return Ok(tonic::Response::new(LoadPolicyResponse {
+                    success: false,
+                    error_info: Some("errServerNotInitialized".to_string()),
+                }))
+            }
+        };
+        todo!()
+    }
+
+    async fn load_policy_mapping(
+        &self,
+        request: Request<LoadPolicyMappingRequest>,
+    ) -> Result<Response<LoadPolicyMappingResponse>, Status> {
+        let request = request.into_inner();
+        let user_or_group = request.user_or_group;
+        if user_or_group.is_empty() {
+            return Ok(tonic::Response::new(LoadPolicyMappingResponse {
+                success: false,
+                error_info: Some("user_or_group name is missing".to_string()),
+            }));
+        }
+        let _user_type = request.user_type;
+        let _is_group = request.is_group;
+        let layer = new_object_layer_fn();
+        let lock = layer.read().await;
+        let _store = match lock.as_ref() {
+            Some(s) => s,
+            None => {
+                return Ok(tonic::Response::new(LoadPolicyMappingResponse {
+                    success: false,
+                    error_info: Some("errServerNotInitialized".to_string()),
+                }))
+            }
+        };
+        todo!()
+    }
+
+    async fn delete_user(&self, request: Request<DeleteUserRequest>) -> Result<Response<DeleteUserResponse>, Status> {
+        let request = request.into_inner();
+        let access_key = request.access_key;
+        if access_key.is_empty() {
+            return Ok(tonic::Response::new(DeleteUserResponse {
+                success: false,
+                error_info: Some("access_key name is missing".to_string()),
+            }));
+        }
+        let layer = new_object_layer_fn();
+        let lock = layer.read().await;
+        let _store = match lock.as_ref() {
+            Some(s) => s,
+            None => {
+                return Ok(tonic::Response::new(DeleteUserResponse {
+                    success: false,
+                    error_info: Some("errServerNotInitialized".to_string()),
+                }))
+            }
+        };
+
+        todo!()
+    }
+
+    async fn delete_service_account(
+        &self,
+        request: Request<DeleteServiceAccountRequest>,
+    ) -> Result<Response<DeleteServiceAccountResponse>, Status> {
+        let request = request.into_inner();
+        let access_key = request.access_key;
+        if access_key.is_empty() {
+            return Ok(tonic::Response::new(DeleteServiceAccountResponse {
+                success: false,
+                error_info: Some("access_key name is missing".to_string()),
+            }));
+        }
+        let layer = new_object_layer_fn();
+        let lock = layer.read().await;
+        let _store = match lock.as_ref() {
+            Some(s) => s,
+            None => {
+                return Ok(tonic::Response::new(DeleteServiceAccountResponse {
+                    success: false,
+                    error_info: Some("errServerNotInitialized".to_string()),
+                }))
+            }
+        };
+        todo!()
+    }
+
+    async fn load_user(&self, request: Request<LoadUserRequest>) -> Result<Response<LoadUserResponse>, Status> {
+        let request = request.into_inner();
+        let access_key = request.access_key;
+        let _temp = request.temp;
+        if access_key.is_empty() {
+            return Ok(tonic::Response::new(LoadUserResponse {
+                success: false,
+                error_info: Some("access_key name is missing".to_string()),
+            }));
+        }
+
+        let layer = new_object_layer_fn();
+        let lock = layer.read().await;
+        let _store = match lock.as_ref() {
+            Some(s) => s,
+            None => {
+                return Ok(tonic::Response::new(LoadUserResponse {
+                    success: false,
+                    error_info: Some("errServerNotInitialized".to_string()),
+                }))
+            }
+        };
+
+        todo!()
+    }
+
+    async fn load_service_account(
+        &self,
+        request: Request<LoadServiceAccountRequest>,
+    ) -> Result<Response<LoadServiceAccountResponse>, Status> {
+        let request = request.into_inner();
+        let access_key = request.access_key;
+        if access_key.is_empty() {
+            return Ok(tonic::Response::new(LoadServiceAccountResponse {
+                success: false,
+                error_info: Some("access_key name is missing".to_string()),
+            }));
+        }
+
+        let layer = new_object_layer_fn();
+        let lock = layer.read().await;
+        let _store = match lock.as_ref() {
+            Some(s) => s,
+            None => {
+                return Ok(tonic::Response::new(LoadServiceAccountResponse {
+                    success: false,
+                    error_info: Some("errServerNotInitialized".to_string()),
+                }))
+            }
+        };
+        todo!()
+    }
+
+    async fn load_group(&self, request: Request<LoadGroupRequest>) -> Result<Response<LoadGroupResponse>, Status> {
+        let request = request.into_inner();
+        let group = request.group;
+        if group.is_empty() {
+            return Ok(tonic::Response::new(LoadGroupResponse {
+                success: false,
+                error_info: Some("group name is missing".to_string()),
+            }));
+        }
+
+        let layer = new_object_layer_fn();
+        let lock = layer.read().await;
+        let _store = match lock.as_ref() {
+            Some(s) => s,
+            None => {
+                return Ok(tonic::Response::new(LoadGroupResponse {
+                    success: false,
+                    error_info: Some("errServerNotInitialized".to_string()),
+                }))
+            }
+        };
+        todo!()
+    }
+
+    async fn reload_site_replication_config(
+        &self,
+        _request: Request<ReloadSiteReplicationConfigRequest>,
+    ) -> Result<Response<ReloadSiteReplicationConfigResponse>, Status> {
+        let layer = new_object_layer_fn();
+        let lock = layer.read().await;
+        let _store = match lock.as_ref() {
+            Some(s) => s,
+            None => {
+                return Ok(tonic::Response::new(ReloadSiteReplicationConfigResponse {
+                    success: false,
+                    error_info: Some("errServerNotInitialized".to_string()),
+                }))
+            }
+        };
+        todo!()
+    }
+
+    async fn signal_service(&self, request: Request<SignalServiceRequest>) -> Result<Response<SignalServiceResponse>, Status> {
+        let request = request.into_inner();
+        let _vars = match request.vars {
+            Some(vars) => vars.value,
+            None => HashMap::new(),
+        };
+        todo!()
+    }
+
+    async fn background_heal_status(
+        &self,
+        _request: Request<BackgroundHealStatusRequest>,
+    ) -> Result<Response<BackgroundHealStatusResponse>, Status> {
+        let (state, ok) = get_local_background_heal_status().await;
+        if !ok {
+            return Ok(tonic::Response::new(BackgroundHealStatusResponse {
+                success: false,
+                bg_heal_state: vec![],
+                error_info: Some("errServerNotInitialized".to_string()),
+            }));
+        }
+
+        let mut buf = Vec::new();
+        if let Err(err) = state.serialize(&mut Serializer::new(&mut buf)) {
+            return Ok(tonic::Response::new(BackgroundHealStatusResponse {
+                success: false,
+                bg_heal_state: vec![],
+                error_info: Some(err.to_string()),
+            }));
+        }
+        Ok(tonic::Response::new(BackgroundHealStatusResponse {
+            success: true,
+            bg_heal_state: buf,
+            error_info: None,
+        }))
+    }
+
+    async fn get_metacache_listing(
+        &self,
+        _request: Request<GetMetacacheListingRequest>,
+    ) -> Result<Response<GetMetacacheListingResponse>, Status> {
+        todo!()
+    }
+
+    async fn update_metacache_listing(
+        &self,
+        _request: Request<UpdateMetacacheListingRequest>,
+    ) -> Result<Response<UpdateMetacacheListingResponse>, Status> {
+        todo!()
+    }
+
+    async fn reload_pool_meta(
+        &self,
+        _request: Request<ReloadPoolMetaRequest>,
+    ) -> Result<Response<ReloadPoolMetaResponse>, Status> {
+        let layer = new_object_layer_fn();
+        let lock = layer.read().await;
+        let store = match lock.as_ref() {
+            Some(s) => s,
+            None => {
+                return Ok(tonic::Response::new(ReloadPoolMetaResponse {
+                    success: false,
+                    error_info: Some("errServerNotInitialized".to_string()),
+                }))
+            }
+        };
+        match store.reload_pool_meta().await {
+            Ok(_) => Ok(tonic::Response::new(ReloadPoolMetaResponse {
+                success: true,
+                error_info: None,
+            })),
+            Err(err) => Ok(tonic::Response::new(ReloadPoolMetaResponse {
+                success: false,
+                error_info: Some(err.to_string()),
+            })),
+        }
+    }
+
+    async fn stop_rebalance(&self, _request: Request<StopRebalanceRequest>) -> Result<Response<StopRebalanceResponse>, Status> {
+        let layer = new_object_layer_fn();
+        let lock = layer.read().await;
+        let _store = match lock.as_ref() {
+            Some(s) => s,
+            None => {
+                return Ok(tonic::Response::new(StopRebalanceResponse {
+                    success: false,
+                    error_info: Some("errServerNotInitialized".to_string()),
+                }))
+            }
+        };
+
+        // todo
+        // store.stop_rebalance().await;
+        todo!()
+    }
+
+    async fn load_rebalance_meta(
+        &self,
+        _request: Request<LoadRebalanceMetaRequest>,
+    ) -> Result<Response<LoadRebalanceMetaResponse>, Status> {
+        todo!()
+    }
+
+    async fn load_transition_tier_config(
+        &self,
+        _request: Request<LoadTransitionTierConfigRequest>,
+    ) -> Result<Response<LoadTransitionTierConfigResponse>, Status> {
+        todo!()
+    }
 }
diff --git a/rustfs/src/main.rs b/rustfs/src/main.rs
index 00cee9101..4b25b819f 100644
--- a/rustfs/src/main.rs
+++ b/rustfs/src/main.rs
@@ -1,6 +1,8 @@
 mod admin;
 mod config;
 mod grpc;
+#[allow(dead_code)]
+mod peer_rest_client;
 mod service;
 mod storage;
 
diff --git a/rustfs/src/peer_rest_client.rs b/rustfs/src/peer_rest_client.rs
new file mode 100644
index 000000000..b52802673
--- /dev/null
+++ b/rustfs/src/peer_rest_client.rs
@@ -0,0 +1,658 @@
+use std::{collections::HashMap, io::Cursor, time::SystemTime};
+
+use common::error::{Error, Result};
+use ecstore::{admin_server_info::ServerProperties, store_api::StorageInfo};
+use madmin::{
+    heal_command::BgHealState,
+    health::{Cpus, MemInfo, OsInfo, Partitions, ProcInfo, SysConfig, SysErrors, SysService},
+    metrics::{CollectMetricsOpts, MetricType, RealtimeMetrics},
+    net::NetInfo,
+};
+use protos::{
+    node_service_time_out_client,
+    proto_gen::node_service::{
+        BackgroundHealStatusRequest, DeleteBucketMetadataRequest, DeletePolicyRequest, DeleteServiceAccountRequest,
+        DeleteUserRequest, GetCpusRequest, GetMemInfoRequest, GetMetricsRequest, GetNetInfoRequest, GetOsInfoRequest,
+        GetPartitionsRequest, GetProcInfoRequest, GetSeLinuxInfoRequest, GetSysConfigRequest, GetSysErrorsRequest,
+        LoadBucketMetadataRequest, LoadGroupRequest, LoadPolicyMappingRequest, LoadPolicyRequest, LoadRebalanceMetaRequest,
+        LoadServiceAccountRequest, LoadTransitionTierConfigRequest, LoadUserRequest, LocalStorageInfoRequest, Mss,
+        ReloadPoolMetaRequest, ReloadSiteReplicationConfigRequest, ServerInfoRequest, SignalServiceRequest,
+        StartProfilingRequest, StopRebalanceRequest,
+    },
+};
+use rmp_serde::{Deserializer, Serializer};
+use serde::{Deserialize, Serialize};
+use tonic::Request;
+
+pub const PEER_RESTSIGNAL: &str = "signal";
+pub const PEER_RESTSUB_SYS: &str = "sub-sys";
+pub const PEER_RESTDRY_RUN: &str = "dry-run";
+
+struct PeerRestClient {
+    addr: String,
+}
+
+impl PeerRestClient {
+    pub fn new(url: url::Url) -> Self {
+        Self {
+            addr: format!("{}://{}:{}", url.scheme(), url.host_str().unwrap(), url.port().unwrap()),
+        }
+    }
+}
+
+impl PeerRestClient {
+    pub async fn local_storage_info(&self) -> Result<StorageInfo> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(LocalStorageInfoRequest { metrics: true });
+
+        let response = client.local_storage_info(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        let data = response.storage_info;
+
+        let mut buf = Deserializer::new(Cursor::new(data));
+        let storage_info: StorageInfo = Deserialize::deserialize(&mut buf).unwrap();
+
+        Ok(storage_info)
+    }
+
+    pub async fn server_info(&self) -> Result<ServerProperties> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(ServerInfoRequest { metrics: true });
+
+        let response = client.server_info(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        let data = response.server_properties;
+
+        let mut buf = Deserializer::new(Cursor::new(data));
+        let storage_properties: ServerProperties = Deserialize::deserialize(&mut buf).unwrap();
+
+        Ok(storage_properties)
+    }
+
+    pub async fn get_cpus(&self) -> Result<Cpus> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(GetCpusRequest {});
+
+        let response = client.get_cpus(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        let data = response.cpus;
+
+        let mut buf = Deserializer::new(Cursor::new(data));
+        let cpus: Cpus = Deserialize::deserialize(&mut buf).unwrap();
+
+        Ok(cpus)
+    }
+
+    pub async fn get_net_info(&self) -> Result<NetInfo> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(GetNetInfoRequest {});
+
+        let response = client.get_net_info(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        let data = response.net_info;
+
+        let mut buf = Deserializer::new(Cursor::new(data));
+        let net_info: NetInfo = Deserialize::deserialize(&mut buf).unwrap();
+
+        Ok(net_info)
+    }
+
+    pub async fn get_partitions(&self) -> Result<Partitions> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(GetPartitionsRequest {});
+
+        let response = client.get_partitions(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        let data = response.partitions;
+
+        let mut buf = Deserializer::new(Cursor::new(data));
+        let partitions: Partitions = Deserialize::deserialize(&mut buf).unwrap();
+
+        Ok(partitions)
+    }
+
+    pub async fn get_os_info(&self) -> Result<OsInfo> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(GetOsInfoRequest {});
+
+        let response = client.get_os_info(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        let data = response.os_info;
+
+        let mut buf = Deserializer::new(Cursor::new(data));
+        let os_info: OsInfo = Deserialize::deserialize(&mut buf).unwrap();
+
+        Ok(os_info)
+    }
+
+    pub async fn get_se_linux_info(&self) -> Result<SysService> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(GetSeLinuxInfoRequest {});
+
+        let response = client.get_se_linux_info(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        let data = response.sys_services;
+
+        let mut buf = Deserializer::new(Cursor::new(data));
+        let sys_services: SysService = Deserialize::deserialize(&mut buf).unwrap();
+
+        Ok(sys_services)
+    }
+
+    pub async fn get_sys_config(&self) -> Result<SysConfig> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(GetSysConfigRequest {});
+
+        let response = client.get_sys_config(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        let data = response.sys_config;
+
+        let mut buf = Deserializer::new(Cursor::new(data));
+        let sys_config: SysConfig = Deserialize::deserialize(&mut buf).unwrap();
+
+        Ok(sys_config)
+    }
+
+    pub async fn get_sys_errors(&self) -> Result<SysErrors> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(GetSysErrorsRequest {});
+
+        let response = client.get_sys_errors(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        let data = response.sys_errors;
+
+        let mut buf = Deserializer::new(Cursor::new(data));
+        let sys_errors: SysErrors = Deserialize::deserialize(&mut buf).unwrap();
+
+        Ok(sys_errors)
+    }
+
+    pub async fn get_mem_info(&self) -> Result<MemInfo> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(GetMemInfoRequest {});
+
+        let response = client.get_mem_info(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        let data = response.mem_info;
+
+        let mut buf = Deserializer::new(Cursor::new(data));
+        let mem_info: MemInfo = Deserialize::deserialize(&mut buf).unwrap();
+
+        Ok(mem_info)
+    }
+
+    pub async fn get_metrics(&self, t: MetricType, opts: &CollectMetricsOpts) -> Result<RealtimeMetrics> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let mut buf = Vec::new();
+        opts.serialize(&mut Serializer::new(&mut buf))?;
+        let request = Request::new(GetMetricsRequest {
+            metric_type: t,
+            opts: buf,
+        });
+
+        let response = client.get_metrics(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        let data = response.realtime_metrics;
+
+        let mut buf = Deserializer::new(Cursor::new(data));
+        let realtime_metrics: RealtimeMetrics = Deserialize::deserialize(&mut buf).unwrap();
+
+        Ok(realtime_metrics)
+    }
+
+    pub async fn get_proc_info(&self) -> Result<ProcInfo> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(GetProcInfoRequest {});
+
+        let response = client.get_proc_info(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        let data = response.proc_info;
+
+        let mut buf = Deserializer::new(Cursor::new(data));
+        let proc_info: ProcInfo = Deserialize::deserialize(&mut buf).unwrap();
+
+        Ok(proc_info)
+    }
+
+    pub async fn start_profiling(&self, profiler: &str) -> Result<()> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(StartProfilingRequest {
+            profiler: profiler.to_string(),
+        });
+
+        let response = client.start_profiling(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        Ok(())
+    }
+
+    pub async fn download_profile_data(&self) -> Result<()> {
+        todo!()
+    }
+
+    pub async fn get_bucket_stats(&self) -> Result<()> {
+        todo!()
+    }
+
+    pub async fn get_sr_metrics(&self) -> Result<()> {
+        todo!()
+    }
+
+    pub async fn get_all_bucket_stats(&self) -> Result<()> {
+        todo!()
+    }
+
+    pub async fn load_bucket_metadata(&self, bucket: &str) -> Result<()> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(LoadBucketMetadataRequest {
+            bucket: bucket.to_string(),
+        });
+
+        let response = client.load_bucket_metadata(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        Ok(())
+    }
+
+    pub async fn delete_bucket_metadata(&self, bucket: &str) -> Result<()> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(DeleteBucketMetadataRequest {
+            bucket: bucket.to_string(),
+        });
+
+        let response = client.delete_bucket_metadata(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        Ok(())
+    }
+
+    pub async fn delete_policy(&self, policy: &str) -> Result<()> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(DeletePolicyRequest {
+            policy_name: policy.to_string(),
+        });
+
+        let response = client.delete_policy(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        Ok(())
+    }
+
+    pub async fn load_policy(&self, policy: &str) -> Result<()> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(LoadPolicyRequest {
+            policy_name: policy.to_string(),
+        });
+
+        let response = client.load_policy(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        Ok(())
+    }
+
+    pub async fn load_policy_mapping(&self, user_or_group: &str, user_type: u64, is_group: bool) -> Result<()> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(LoadPolicyMappingRequest {
+            user_or_group: user_or_group.to_string(),
+            user_type,
+            is_group,
+        });
+
+        let response = client.load_policy_mapping(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        Ok(())
+    }
+
+    pub async fn delete_user(&self, access_key: &str) -> Result<()> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(DeleteUserRequest {
+            access_key: access_key.to_string(),
+        });
+
+        let response = client.delete_user(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        Ok(())
+    }
+
+    pub async fn delete_service_account(&self, access_key: &str) -> Result<()> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(DeleteServiceAccountRequest {
+            access_key: access_key.to_string(),
+        });
+
+        let response = client.delete_service_account(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        Ok(())
+    }
+
+    pub async fn load_user(&self, access_key: &str, temp: bool) -> Result<()> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(LoadUserRequest {
+            access_key: access_key.to_string(),
+            temp,
+        });
+
+        let response = client.load_user(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        Ok(())
+    }
+
+    pub async fn load_service_account(&self, access_key: &str) -> Result<()> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(LoadServiceAccountRequest {
+            access_key: access_key.to_string(),
+        });
+
+        let response = client.load_service_account(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        Ok(())
+    }
+
+    pub async fn load_group(&self, group: &str) -> Result<()> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(LoadGroupRequest {
+            group: group.to_string(),
+        });
+
+        let response = client.load_group(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        Ok(())
+    }
+
+    pub async fn reload_site_replication_config(&self) -> Result<()> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(ReloadSiteReplicationConfigRequest {});
+
+        let response = client.reload_site_replication_config(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        Ok(())
+    }
+
+    pub async fn signal_service(&self, sig: u64, sub_sys: &str, dry_run: bool, _exec_at: SystemTime) -> Result<()> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let mut vars = HashMap::new();
+        vars.insert(PEER_RESTSIGNAL.to_string(), sig.to_string());
+        vars.insert(PEER_RESTSUB_SYS.to_string(), sub_sys.to_string());
+        vars.insert(PEER_RESTDRY_RUN.to_string(), dry_run.to_string());
+        let request = Request::new(SignalServiceRequest {
+            vars: Some(Mss { value: vars }),
+        });
+
+        let response = client.signal_service(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        Ok(())
+    }
+
+    pub async fn background_heal_status(&self) -> Result<BgHealState> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(BackgroundHealStatusRequest {});
+
+        let response = client.background_heal_status(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+        let data = response.bg_heal_state;
+
+        let mut buf = Deserializer::new(Cursor::new(data));
+        let bg_heal_state: BgHealState = Deserialize::deserialize(&mut buf).unwrap();
+
+        Ok(bg_heal_state)
+    }
+
+    pub async fn get_metacache_listing(&self) -> Result<()> {
+        let mut _client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        todo!()
+    }
+
+    pub async fn update_metacache_listing(&self) -> Result<()> {
+        let mut _client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        todo!()
+    }
+
+    pub async fn reload_pool_meta(&self) -> Result<()> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(ReloadPoolMetaRequest {});
+
+        let response = client.reload_pool_meta(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+
+        Ok(())
+    }
+
+    pub async fn stop_rebalance(&self) -> Result<()> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(StopRebalanceRequest {});
+
+        let response = client.stop_rebalance(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+
+        Ok(())
+    }
+
+    pub async fn load_rebalance_meta(&self, start_rebalance: bool) -> Result<()> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(LoadRebalanceMetaRequest { start_rebalance });
+
+        let response = client.load_rebalance_meta(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+
+        Ok(())
+    }
+
+    pub async fn load_transition_tier_config(&self) -> Result<()> {
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::msg(err.to_string()))?;
+        let request = Request::new(LoadTransitionTierConfigRequest {});
+
+        let response = client.load_transition_tier_config(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::msg(msg));
+            }
+            return Err(Error::msg(""));
+        }
+
+        Ok(())
+    }
+}