From 702952450432e06cdce964191ba273602d044f1b Mon Sep 17 00:00:00 2001
From: mujunxiang <1948535941@qq.com>
Date: Mon, 25 Nov 2024 15:34:46 +0800
Subject: [PATCH] peer rest frame

Signed-off-by: mujunxiang <1948535941@qq.com>
---
 Cargo.lock                                    |    6 +
 Cargo.toml                                    |    2 +
 .../src/generated/proto_gen/node_service.rs   | 2133 +++++++++++++++++
 common/protos/src/node.proto                  |  364 ++-
 e2e_test/Cargo.toml                           |    2 +
 e2e_test/src/reliant/node_interact_test.rs    |   28 +-
 ecstore/Cargo.toml                            |    5 +-
 ecstore/src/admin_server_info.rs              |  169 ++
 ecstore/src/config/mod.rs                     |    5 +
 ecstore/src/heal/heal_commands.rs             |    1 +
 ecstore/src/lib.rs                            |    1 +
 ecstore/src/store_api.rs                      |    8 +-
 rustfs/Cargo.toml                             |    3 +
 rustfs/src/grpc.rs                            |  263 +-
 rustfs/src/main.rs                            |    1 +
 rustfs/src/peer_rest_client.rs                |   47 +
 16 files changed, 3012 insertions(+), 26 deletions(-)
 create mode 100644 ecstore/src/admin_server_info.rs
 create mode 100644 rustfs/src/peer_rest_client.rs

diff --git a/Cargo.lock b/Cargo.lock
index 3a57111a..026d0c23 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -594,6 +594,8 @@ dependencies = [
  "lazy_static",
  "lock",
  "protos",
+ "rmp-serde",
+ "serde",
  "serde_json",
  "tokio",
  "tonic",
@@ -614,6 +616,7 @@ dependencies = [
  "bytesize",
  "common",
  "crc32fast",
+ "flatbuffers",
  "futures",
  "glob",
  "hex-simd",
@@ -2152,6 +2155,8 @@ dependencies = [
  "prost-types",
  "protobuf",
  "protos",
+ "rmp-serde",
+ "router",
  "s3s",
  "serde",
  "serde_json",
@@ -2169,6 +2174,7 @@ dependencies = [
  "tracing-error",
  "tracing-subscriber",
  "transform-stream",
+ "url",
  "uuid",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index f0309c78..47b00226 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -51,6 +51,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 1ec3f589..29f00293 100644
--- a/common/protos/src/generated/proto_gen/node_service.rs
+++ b/common/protos/src/generated/proto_gen/node_service.rs
@@ -612,6 +612,441 @@ 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 {
+    #[prost(bool, tag = "1")]
+    pub start_rebalance: bool,
+}
+#[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 +1728,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 +2453,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 +3793,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 f80fb10f..5cd4015a 100644
--- a/common/protos/src/node.proto
+++ b/common/protos/src/node.proto
@@ -411,8 +411,327 @@ 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 {
+  bool start_rebalance = 1;
+}
+
+message LoadTransitionTierConfigResponse {
+  bool success = 1;
+  optional string error_info = 2;
 }
 
 /* -------------------------------------------------------------------- */
@@ -466,4 +785,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 f740cc15..771f97e8 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 951647f1..db456ad2 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 27f09e77..a52874e5 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 00000000..e6df440b
--- /dev/null
+++ b/ecstore/src/admin_server_info.rs
@@ -0,0 +1,169 @@
+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();
+
+    for ep in GLOBAL_Endpoints.read().await.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 a169d698..f241d0f1 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/heal/heal_commands.rs b/ecstore/src/heal/heal_commands.rs
index 6950cef1..d27dad41 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/lib.rs b/ecstore/src/lib.rs
index 0edb1a46..44d8cd0e 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;
diff --git a/ecstore/src/store_api.rs b/ecstore/src/store_api.rs
index 2853f884..75cb4133 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/rustfs/Cargo.toml b/rustfs/Cargo.toml
index 57f84ab1..f2818309 100644
--- a/rustfs/Cargo.toml
+++ b/rustfs/Cargo.toml
@@ -31,7 +31,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,6 +53,7 @@ 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"
diff --git a/rustfs/src/grpc.rs b/rustfs/src/grpc.rs
index 0567f66f..fd7071fd 100644
--- a/rustfs/src/grpc.rs
+++ b/rustfs/src/grpc.rs
@@ -1,36 +1,27 @@
 use std::{error::Error, io::ErrorKind, pin::Pin};
 
 use ecstore::{
+    admin_server_info::get_local_server_property,
     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 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 +1497,246 @@ 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> {
+        todo!()
+    }
+
+    async fn get_net_info(&self, _request: Request<GetNetInfoRequest>) -> Result<Response<GetNetInfoResponse>, Status> {
+        todo!()
+    }
+
+    async fn get_partitions(&self, _request: Request<GetPartitionsRequest>) -> Result<Response<GetPartitionsResponse>, Status> {
+        todo!()
+    }
+
+    async fn get_os_info(&self, _request: Request<GetOsInfoRequest>) -> Result<Response<GetOsInfoResponse>, Status> {
+        todo!()
+    }
+
+    async fn get_se_linux_info(
+        &self,
+        _request: Request<GetSeLinuxInfoRequest>,
+    ) -> Result<Response<GetSeLinuxInfoResponse>, Status> {
+        todo!()
+    }
+
+    async fn get_sys_config(&self, _request: Request<GetSysConfigRequest>) -> Result<Response<GetSysConfigResponse>, Status> {
+        todo!()
+    }
+
+    async fn get_sys_errors(&self, _request: Request<GetSysErrorsRequest>) -> Result<Response<GetSysErrorsResponse>, Status> {
+        todo!()
+    }
+
+    async fn get_mem_info(&self, _request: Request<GetMemInfoRequest>) -> Result<Response<GetMemInfoResponse>, Status> {
+        todo!()
+    }
+
+    async fn get_metrics(&self, _request: Request<GetMetricsRequest>) -> Result<Response<GetMetricsResponse>, Status> {
+        todo!()
+    }
+
+    async fn get_proc_info(&self, _request: Request<GetProcInfoRequest>) -> Result<Response<GetProcInfoResponse>, Status> {
+        todo!()
+    }
+
+    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> {
+        todo!()
+    }
+
+    async fn delete_bucket_metadata(
+        &self,
+        _request: Request<DeleteBucketMetadataRequest>,
+    ) -> Result<Response<DeleteBucketMetadataResponse>, Status> {
+        todo!()
+    }
+
+    async fn delete_policy(&self, _request: Request<DeletePolicyRequest>) -> Result<Response<DeletePolicyResponse>, Status> {
+        todo!()
+    }
+
+    async fn load_policy(&self, _request: Request<LoadPolicyRequest>) -> Result<Response<LoadPolicyResponse>, Status> {
+        todo!()
+    }
+
+    async fn load_policy_mapping(
+        &self,
+        _request: Request<LoadPolicyMappingRequest>,
+    ) -> Result<Response<LoadPolicyMappingResponse>, Status> {
+        todo!()
+    }
+
+    async fn delete_user(&self, _request: Request<DeleteUserRequest>) -> Result<Response<DeleteUserResponse>, Status> {
+        todo!()
+    }
+
+    async fn delete_service_account(
+        &self,
+        _request: Request<DeleteServiceAccountRequest>,
+    ) -> Result<Response<DeleteServiceAccountResponse>, Status> {
+        todo!()
+    }
+
+    async fn load_user(&self, _request: Request<LoadUserRequest>) -> Result<Response<LoadUserResponse>, Status> {
+        todo!()
+    }
+
+    async fn load_service_account(
+        &self,
+        _request: Request<LoadServiceAccountRequest>,
+    ) -> Result<Response<LoadServiceAccountResponse>, Status> {
+        todo!()
+    }
+
+    async fn load_group(&self, _request: Request<LoadGroupRequest>) -> Result<Response<LoadGroupResponse>, Status> {
+        todo!()
+    }
+
+    async fn reload_site_replication_config(
+        &self,
+        _request: Request<ReloadSiteReplicationConfigRequest>,
+    ) -> Result<Response<ReloadSiteReplicationConfigResponse>, Status> {
+        todo!()
+    }
+
+    async fn signal_service(&self, _request: Request<SignalServiceRequest>) -> Result<Response<SignalServiceResponse>, Status> {
+        todo!()
+    }
+
+    async fn background_heal_status(
+        &self,
+        _request: Request<BackgroundHealStatusRequest>,
+    ) -> Result<Response<BackgroundHealStatusResponse>, Status> {
+        todo!()
+    }
+
+    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> {
+        todo!()
+    }
+
+    async fn stop_rebalance(&self, _request: Request<StopRebalanceRequest>) -> Result<Response<StopRebalanceResponse>, Status> {
+        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 00cee910..cef94af6 100644
--- a/rustfs/src/main.rs
+++ b/rustfs/src/main.rs
@@ -1,6 +1,7 @@
 mod admin;
 mod config;
 mod grpc;
+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 00000000..55e34996
--- /dev/null
+++ b/rustfs/src/peer_rest_client.rs
@@ -0,0 +1,47 @@
+use std::io::Cursor;
+
+use common::error::{Error, Result};
+use ecstore::{admin_server_info::ServerProperties, store_api::StorageInfo};
+use protos::{node_service_time_out_client, proto_gen::node_service::LocalStorageInfoRequest};
+use rmp_serde::Deserializer;
+use serde::Deserialize;
+use tonic::Request;
+
+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 info = response.storage_info;
+
+        let mut buf = Deserializer::new(Cursor::new(info));
+        let storage_info: StorageInfo = Deserialize::deserialize(&mut buf).unwrap();
+
+        Ok(storage_info)
+    }
+
+    pub async fn server_info(&self) -> Request<ServerProperties> {
+        todo!()
+    }
+}