diff --git a/Cargo.lock b/Cargo.lock
index 624ea269..755756bf 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1207,6 +1207,12 @@ version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
 [[package]]
 name = "hybrid-array"
 version = "0.2.1"
@@ -1676,9 +1682,12 @@ version = "0.0.1"
 dependencies = [
  "chrono",
  "common",
+ "humantime",
+ "hyper",
  "psutil",
  "serde",
  "time",
+ "tracing",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 7736c02f..31028857 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -50,6 +50,7 @@ hyper-util = { version = "0.1.10", features = [
 ] }
 http = "1.1.0"
 http-body = "1.0.1"
+humantime = "2.1.0"
 lock = { path = "./common/lock" }
 lazy_static = "1.5.0"
 mime = "0.3.17"
diff --git a/common/protos/src/generated/flatbuffers_generated/models.rs b/common/protos/src/generated/flatbuffers_generated/models.rs
index e4949fdc..aa1f6ae2 100644
--- a/common/protos/src/generated/flatbuffers_generated/models.rs
+++ b/common/protos/src/generated/flatbuffers_generated/models.rs
@@ -1,9 +1,10 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 
+
 // @generated
 
-use core::cmp::Ordering;
 use core::mem;
+use core::cmp::Ordering;
 
 extern crate flatbuffers;
 use self::flatbuffers::{EndianScalar, Follow};
@@ -11,114 +12,112 @@ use self::flatbuffers::{EndianScalar, Follow};
 #[allow(unused_imports, dead_code)]
 pub mod models {
 
-    use core::cmp::Ordering;
-    use core::mem;
+  use core::mem;
+  use core::cmp::Ordering;
 
-    extern crate flatbuffers;
-    use self::flatbuffers::{EndianScalar, Follow};
+  extern crate flatbuffers;
+  use self::flatbuffers::{EndianScalar, Follow};
 
-    pub enum PingBodyOffset {}
-    #[derive(Copy, Clone, PartialEq)]
+pub enum PingBodyOffset {}
+#[derive(Copy, Clone, PartialEq)]
 
-    pub struct PingBody<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+pub struct PingBody<'a> {
+  pub _tab: flatbuffers::Table<'a>,
+}
+
+impl<'a> flatbuffers::Follow<'a> for PingBody<'a> {
+  type Inner = PingBody<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: flatbuffers::Table::new(buf, loc) }
+  }
+}
+
+impl<'a> PingBody<'a> {
+  pub const VT_PAYLOAD: flatbuffers::VOffsetT = 4;
+
+  pub const fn get_fully_qualified_name() -> &'static str {
+    "models.PingBody"
+  }
+
+  #[inline]
+  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    PingBody { _tab: table }
+  }
+  #[allow(unused_mut)]
+  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
+    _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+    args: &'args PingBodyArgs<'args>
+  ) -> flatbuffers::WIPOffset<PingBody<'bldr>> {
+    let mut builder = PingBodyBuilder::new(_fbb);
+    if let Some(x) = args.payload { builder.add_payload(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn payload(&self) -> Option<flatbuffers::Vector<'a, u8>> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(PingBody::VT_PAYLOAD, None)}
+  }
+}
+
+impl flatbuffers::Verifiable for PingBody<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut flatbuffers::Verifier, pos: usize
+  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
+    use self::flatbuffers::Verifiable;
+    v.visit_table(pos)?
+     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("payload", Self::VT_PAYLOAD, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct PingBodyArgs<'a> {
+    pub payload: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+}
+impl<'a> Default for PingBodyArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    PingBodyArgs {
+      payload: None,
     }
+  }
+}
 
-    impl<'a> flatbuffers::Follow<'a> for PingBody<'a> {
-        type Inner = PingBody<'a>;
-        #[inline]
-        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-            Self {
-                _tab: flatbuffers::Table::new(buf, loc),
-            }
-        }
+pub struct PingBodyBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
+  fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+  start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+}
+impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> PingBodyBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_payload(&mut self, payload: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {
+    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PingBody::VT_PAYLOAD, payload);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> PingBodyBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    PingBodyBuilder {
+      fbb_: _fbb,
+      start_: start,
     }
+  }
+  #[inline]
+  pub fn finish(self) -> flatbuffers::WIPOffset<PingBody<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    flatbuffers::WIPOffset::new(o.value())
+  }
+}
 
-    impl<'a> PingBody<'a> {
-        pub const VT_PAYLOAD: flatbuffers::VOffsetT = 4;
+impl core::fmt::Debug for PingBody<'_> {
+  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    let mut ds = f.debug_struct("PingBody");
+      ds.field("payload", &self.payload());
+      ds.finish()
+  }
+}
+}  // pub mod models
 
-        pub const fn get_fully_qualified_name() -> &'static str {
-            "models.PingBody"
-        }
-
-        #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
-            PingBody { _tab: table }
-        }
-        #[allow(unused_mut)]
-        pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
-            args: &'args PingBodyArgs<'args>,
-        ) -> flatbuffers::WIPOffset<PingBody<'bldr>> {
-            let mut builder = PingBodyBuilder::new(_fbb);
-            if let Some(x) = args.payload {
-                builder.add_payload(x);
-            }
-            builder.finish()
-        }
-
-        #[inline]
-        pub fn payload(&self) -> Option<flatbuffers::Vector<'a, u8>> {
-            // Safety:
-            // Created from valid Table for this object
-            // which contains a valid value in this slot
-            unsafe {
-                self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(PingBody::VT_PAYLOAD, None)
-            }
-        }
-    }
-
-    impl flatbuffers::Verifiable for PingBody<'_> {
-        #[inline]
-        fn run_verifier(v: &mut flatbuffers::Verifier, pos: usize) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
-            v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("payload", Self::VT_PAYLOAD, false)?
-                .finish();
-            Ok(())
-        }
-    }
-    pub struct PingBodyArgs<'a> {
-        pub payload: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
-    }
-    impl<'a> Default for PingBodyArgs<'a> {
-        #[inline]
-        fn default() -> Self {
-            PingBodyArgs { payload: None }
-        }
-    }
-
-    pub struct PingBodyBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
-    }
-    impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> PingBodyBuilder<'a, 'b, A> {
-        #[inline]
-        pub fn add_payload(&mut self, payload: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
-            self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(PingBody::VT_PAYLOAD, payload);
-        }
-        #[inline]
-        pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> PingBodyBuilder<'a, 'b, A> {
-            let start = _fbb.start_table();
-            PingBodyBuilder {
-                fbb_: _fbb,
-                start_: start,
-            }
-        }
-        #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<PingBody<'a>> {
-            let o = self.fbb_.end_table(self.start_);
-            flatbuffers::WIPOffset::new(o.value())
-        }
-    }
-
-    impl core::fmt::Debug for PingBody<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-            let mut ds = f.debug_struct("PingBody");
-            ds.field("payload", &self.payload());
-            ds.finish()
-        }
-    }
-} // pub mod models
diff --git a/common/protos/src/generated/proto_gen/node_service.rs b/common/protos/src/generated/proto_gen/node_service.rs
index 6c4aef0e..74e524da 100644
--- a/common/protos/src/generated/proto_gen/node_service.rs
+++ b/common/protos/src/generated/proto_gen/node_service.rs
@@ -615,7 +615,10 @@ pub struct GenerallyLockResponse {
 #[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>,
+    pub value: ::std::collections::HashMap<
+        ::prost::alloc::string::String,
+        ::prost::alloc::string::String,
+    >,
 }
 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
 pub struct LocalStorageInfoRequest {
@@ -779,7 +782,10 @@ 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>>,
+    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>,
 }
@@ -1046,9 +1052,15 @@ pub struct LoadTransitionTierConfigResponse {
 }
 /// Generated client implementations.
 pub mod node_service_client {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::wildcard_imports, clippy::let_unit_value)]
-    use tonic::codegen::http::Uri;
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
     use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
     #[derive(Debug, Clone)]
     pub struct NodeServiceClient<T> {
         inner: tonic::client::Grpc<T>,
@@ -1079,16 +1091,22 @@ pub mod node_service_client {
             let inner = tonic::client::Grpc::with_origin(inner, origin);
             Self { inner }
         }
-        pub fn with_interceptor<F>(inner: T, interceptor: F) -> NodeServiceClient<InterceptedService<T, F>>
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> NodeServiceClient<InterceptedService<T, F>>
         where
             F: tonic::service::Interceptor,
             T::ResponseBody: Default,
             T: tonic::codegen::Service<
                 http::Request<tonic::body::BoxBody>,
-                Response = http::Response<<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
             >,
-            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
-                Into<StdError> + std::marker::Send + std::marker::Sync,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
         {
             NodeServiceClient::new(InterceptedService::new(inner, interceptor))
         }
@@ -1131,9 +1149,15 @@ pub mod node_service_client {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/Ping");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/Ping",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "Ping"));
@@ -1142,13 +1166,22 @@ pub mod node_service_client {
         pub async fn heal_bucket(
             &mut self,
             request: impl tonic::IntoRequest<super::HealBucketRequest>,
-        ) -> std::result::Result<tonic::Response<super::HealBucketResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::HealBucketResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/HealBucket");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/HealBucket",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "HealBucket"));
@@ -1157,13 +1190,22 @@ pub mod node_service_client {
         pub async fn list_bucket(
             &mut self,
             request: impl tonic::IntoRequest<super::ListBucketRequest>,
-        ) -> std::result::Result<tonic::Response<super::ListBucketResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::ListBucketResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/ListBucket");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/ListBucket",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "ListBucket"));
@@ -1172,13 +1214,22 @@ pub mod node_service_client {
         pub async fn make_bucket(
             &mut self,
             request: impl tonic::IntoRequest<super::MakeBucketRequest>,
-        ) -> std::result::Result<tonic::Response<super::MakeBucketResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::MakeBucketResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/MakeBucket");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/MakeBucket",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "MakeBucket"));
@@ -1187,13 +1238,22 @@ pub mod node_service_client {
         pub async fn get_bucket_info(
             &mut self,
             request: impl tonic::IntoRequest<super::GetBucketInfoRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetBucketInfoResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::GetBucketInfoResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/GetBucketInfo");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/GetBucketInfo",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "GetBucketInfo"));
@@ -1202,13 +1262,22 @@ pub mod node_service_client {
         pub async fn delete_bucket(
             &mut self,
             request: impl tonic::IntoRequest<super::DeleteBucketRequest>,
-        ) -> std::result::Result<tonic::Response<super::DeleteBucketResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::DeleteBucketResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/DeleteBucket");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/DeleteBucket",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "DeleteBucket"));
@@ -1217,13 +1286,22 @@ pub mod node_service_client {
         pub async fn read_all(
             &mut self,
             request: impl tonic::IntoRequest<super::ReadAllRequest>,
-        ) -> std::result::Result<tonic::Response<super::ReadAllResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::ReadAllResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/ReadAll");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/ReadAll",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "ReadAll"));
@@ -1232,13 +1310,22 @@ pub mod node_service_client {
         pub async fn write_all(
             &mut self,
             request: impl tonic::IntoRequest<super::WriteAllRequest>,
-        ) -> std::result::Result<tonic::Response<super::WriteAllResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::WriteAllResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/WriteAll");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/WriteAll",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "WriteAll"));
@@ -1251,9 +1338,15 @@ pub mod node_service_client {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/Delete");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/Delete",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "Delete"));
@@ -1262,13 +1355,22 @@ pub mod node_service_client {
         pub async fn verify_file(
             &mut self,
             request: impl tonic::IntoRequest<super::VerifyFileRequest>,
-        ) -> std::result::Result<tonic::Response<super::VerifyFileResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::VerifyFileResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/VerifyFile");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/VerifyFile",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "VerifyFile"));
@@ -1277,13 +1379,22 @@ pub mod node_service_client {
         pub async fn check_parts(
             &mut self,
             request: impl tonic::IntoRequest<super::CheckPartsRequest>,
-        ) -> std::result::Result<tonic::Response<super::CheckPartsResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::CheckPartsResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/CheckParts");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/CheckParts",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "CheckParts"));
@@ -1292,13 +1403,22 @@ pub mod node_service_client {
         pub async fn rename_part(
             &mut self,
             request: impl tonic::IntoRequest<super::RenamePartRequst>,
-        ) -> std::result::Result<tonic::Response<super::RenamePartResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::RenamePartResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/RenamePart");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/RenamePart",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "RenamePart"));
@@ -1307,13 +1427,22 @@ pub mod node_service_client {
         pub async fn rename_file(
             &mut self,
             request: impl tonic::IntoRequest<super::RenameFileRequst>,
-        ) -> std::result::Result<tonic::Response<super::RenameFileResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::RenameFileResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/RenameFile");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/RenameFile",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "RenameFile"));
@@ -1326,9 +1455,15 @@ pub mod node_service_client {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/Write");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/Write",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "Write"));
@@ -1337,13 +1472,22 @@ pub mod node_service_client {
         pub async fn write_stream(
             &mut self,
             request: impl tonic::IntoStreamingRequest<Message = super::WriteRequest>,
-        ) -> std::result::Result<tonic::Response<tonic::codec::Streaming<super::WriteResponse>>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<tonic::codec::Streaming<super::WriteResponse>>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/WriteStream");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/WriteStream",
+            );
             let mut req = request.into_streaming_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "WriteStream"));
@@ -1353,13 +1497,22 @@ pub mod node_service_client {
         pub async fn read_at(
             &mut self,
             request: impl tonic::IntoStreamingRequest<Message = super::ReadAtRequest>,
-        ) -> std::result::Result<tonic::Response<tonic::codec::Streaming<super::ReadAtResponse>>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<tonic::codec::Streaming<super::ReadAtResponse>>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/ReadAt");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/ReadAt",
+            );
             let mut req = request.into_streaming_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "ReadAt"));
@@ -1368,13 +1521,22 @@ pub mod node_service_client {
         pub async fn list_dir(
             &mut self,
             request: impl tonic::IntoRequest<super::ListDirRequest>,
-        ) -> std::result::Result<tonic::Response<super::ListDirResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::ListDirResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/ListDir");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/ListDir",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "ListDir"));
@@ -1383,13 +1545,22 @@ pub mod node_service_client {
         pub async fn walk_dir(
             &mut self,
             request: impl tonic::IntoRequest<super::WalkDirRequest>,
-        ) -> std::result::Result<tonic::Response<super::WalkDirResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::WalkDirResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/WalkDir");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/WalkDir",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "WalkDir"));
@@ -1398,13 +1569,22 @@ pub mod node_service_client {
         pub async fn rename_data(
             &mut self,
             request: impl tonic::IntoRequest<super::RenameDataRequest>,
-        ) -> std::result::Result<tonic::Response<super::RenameDataResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::RenameDataResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/RenameData");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/RenameData",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "RenameData"));
@@ -1413,13 +1593,22 @@ pub mod node_service_client {
         pub async fn make_volumes(
             &mut self,
             request: impl tonic::IntoRequest<super::MakeVolumesRequest>,
-        ) -> std::result::Result<tonic::Response<super::MakeVolumesResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::MakeVolumesResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/MakeVolumes");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/MakeVolumes",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "MakeVolumes"));
@@ -1428,13 +1617,22 @@ pub mod node_service_client {
         pub async fn make_volume(
             &mut self,
             request: impl tonic::IntoRequest<super::MakeVolumeRequest>,
-        ) -> std::result::Result<tonic::Response<super::MakeVolumeResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::MakeVolumeResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/MakeVolume");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/MakeVolume",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "MakeVolume"));
@@ -1443,13 +1641,22 @@ pub mod node_service_client {
         pub async fn list_volumes(
             &mut self,
             request: impl tonic::IntoRequest<super::ListVolumesRequest>,
-        ) -> std::result::Result<tonic::Response<super::ListVolumesResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::ListVolumesResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/ListVolumes");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/ListVolumes",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "ListVolumes"));
@@ -1458,13 +1665,22 @@ pub mod node_service_client {
         pub async fn stat_volume(
             &mut self,
             request: impl tonic::IntoRequest<super::StatVolumeRequest>,
-        ) -> std::result::Result<tonic::Response<super::StatVolumeResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::StatVolumeResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/StatVolume");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/StatVolume",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "StatVolume"));
@@ -1473,13 +1689,22 @@ pub mod node_service_client {
         pub async fn delete_paths(
             &mut self,
             request: impl tonic::IntoRequest<super::DeletePathsRequest>,
-        ) -> std::result::Result<tonic::Response<super::DeletePathsResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::DeletePathsResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/DeletePaths");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/DeletePaths",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "DeletePaths"));
@@ -1488,13 +1713,22 @@ pub mod node_service_client {
         pub async fn update_metadata(
             &mut self,
             request: impl tonic::IntoRequest<super::UpdateMetadataRequest>,
-        ) -> std::result::Result<tonic::Response<super::UpdateMetadataResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::UpdateMetadataResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/UpdateMetadata");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/UpdateMetadata",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "UpdateMetadata"));
@@ -1503,13 +1737,22 @@ pub mod node_service_client {
         pub async fn write_metadata(
             &mut self,
             request: impl tonic::IntoRequest<super::WriteMetadataRequest>,
-        ) -> std::result::Result<tonic::Response<super::WriteMetadataResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::WriteMetadataResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/WriteMetadata");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/WriteMetadata",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "WriteMetadata"));
@@ -1518,13 +1761,22 @@ pub mod node_service_client {
         pub async fn read_version(
             &mut self,
             request: impl tonic::IntoRequest<super::ReadVersionRequest>,
-        ) -> std::result::Result<tonic::Response<super::ReadVersionResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::ReadVersionResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/ReadVersion");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/ReadVersion",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "ReadVersion"));
@@ -1537,9 +1789,15 @@ pub mod node_service_client {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/ReadXL");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/ReadXL",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "ReadXL"));
@@ -1548,13 +1806,22 @@ pub mod node_service_client {
         pub async fn delete_version(
             &mut self,
             request: impl tonic::IntoRequest<super::DeleteVersionRequest>,
-        ) -> std::result::Result<tonic::Response<super::DeleteVersionResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::DeleteVersionResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/DeleteVersion");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/DeleteVersion",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "DeleteVersion"));
@@ -1563,13 +1830,22 @@ pub mod node_service_client {
         pub async fn delete_versions(
             &mut self,
             request: impl tonic::IntoRequest<super::DeleteVersionsRequest>,
-        ) -> std::result::Result<tonic::Response<super::DeleteVersionsResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::DeleteVersionsResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/DeleteVersions");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/DeleteVersions",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "DeleteVersions"));
@@ -1578,13 +1854,22 @@ pub mod node_service_client {
         pub async fn read_multiple(
             &mut self,
             request: impl tonic::IntoRequest<super::ReadMultipleRequest>,
-        ) -> std::result::Result<tonic::Response<super::ReadMultipleResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::ReadMultipleResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/ReadMultiple");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/ReadMultiple",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "ReadMultiple"));
@@ -1593,13 +1878,22 @@ pub mod node_service_client {
         pub async fn delete_volume(
             &mut self,
             request: impl tonic::IntoRequest<super::DeleteVolumeRequest>,
-        ) -> std::result::Result<tonic::Response<super::DeleteVolumeResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::DeleteVolumeResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/DeleteVolume");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/DeleteVolume",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "DeleteVolume"));
@@ -1608,13 +1902,22 @@ pub mod node_service_client {
         pub async fn disk_info(
             &mut self,
             request: impl tonic::IntoRequest<super::DiskInfoRequest>,
-        ) -> std::result::Result<tonic::Response<super::DiskInfoResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::DiskInfoResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/DiskInfo");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/DiskInfo",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "DiskInfo"));
@@ -1623,13 +1926,22 @@ pub mod node_service_client {
         pub async fn ns_scanner(
             &mut self,
             request: impl tonic::IntoStreamingRequest<Message = super::NsScannerRequest>,
-        ) -> std::result::Result<tonic::Response<tonic::codec::Streaming<super::NsScannerResponse>>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<tonic::codec::Streaming<super::NsScannerResponse>>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/NsScanner");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/NsScanner",
+            );
             let mut req = request.into_streaming_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "NsScanner"));
@@ -1638,13 +1950,22 @@ pub mod node_service_client {
         pub async fn lock(
             &mut self,
             request: impl tonic::IntoRequest<super::GenerallyLockRequest>,
-        ) -> std::result::Result<tonic::Response<super::GenerallyLockResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::GenerallyLockResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/Lock");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/Lock",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "Lock"));
@@ -1653,13 +1974,22 @@ pub mod node_service_client {
         pub async fn un_lock(
             &mut self,
             request: impl tonic::IntoRequest<super::GenerallyLockRequest>,
-        ) -> std::result::Result<tonic::Response<super::GenerallyLockResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::GenerallyLockResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/UnLock");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/UnLock",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "UnLock"));
@@ -1668,13 +1998,22 @@ pub mod node_service_client {
         pub async fn r_lock(
             &mut self,
             request: impl tonic::IntoRequest<super::GenerallyLockRequest>,
-        ) -> std::result::Result<tonic::Response<super::GenerallyLockResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::GenerallyLockResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/RLock");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/RLock",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "RLock"));
@@ -1683,13 +2022,22 @@ pub mod node_service_client {
         pub async fn r_un_lock(
             &mut self,
             request: impl tonic::IntoRequest<super::GenerallyLockRequest>,
-        ) -> std::result::Result<tonic::Response<super::GenerallyLockResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::GenerallyLockResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/RUnLock");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/RUnLock",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "RUnLock"));
@@ -1698,13 +2046,22 @@ pub mod node_service_client {
         pub async fn force_un_lock(
             &mut self,
             request: impl tonic::IntoRequest<super::GenerallyLockRequest>,
-        ) -> std::result::Result<tonic::Response<super::GenerallyLockResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::GenerallyLockResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/ForceUnLock");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/ForceUnLock",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "ForceUnLock"));
@@ -1713,13 +2070,22 @@ pub mod node_service_client {
         pub async fn refresh(
             &mut self,
             request: impl tonic::IntoRequest<super::GenerallyLockRequest>,
-        ) -> std::result::Result<tonic::Response<super::GenerallyLockResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::GenerallyLockResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
-                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {}", e.into())))?;
+                .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/Refresh");
+            let path = http::uri::PathAndQuery::from_static(
+                "/node_service.NodeService/Refresh",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("node_service.NodeService", "Refresh"));
@@ -1728,13 +2094,22 @@ pub mod node_service_client {
         pub async fn local_storage_info(
             &mut self,
             request: impl tonic::IntoRequest<super::LocalStorageInfoRequest>,
-        ) -> std::result::Result<tonic::Response<super::LocalStorageInfoResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
@@ -1743,13 +2118,22 @@ pub mod node_service_client {
         pub async fn server_info(
             &mut self,
             request: impl tonic::IntoRequest<super::ServerInfoRequest>,
-        ) -> std::result::Result<tonic::Response<super::ServerInfoResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
@@ -1758,13 +2142,22 @@ pub mod node_service_client {
         pub async fn get_cpus(
             &mut self,
             request: impl tonic::IntoRequest<super::GetCpusRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetCpusResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
@@ -1773,13 +2166,22 @@ pub mod node_service_client {
         pub async fn get_net_info(
             &mut self,
             request: impl tonic::IntoRequest<super::GetNetInfoRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetNetInfoResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
@@ -1788,13 +2190,22 @@ pub mod node_service_client {
         pub async fn get_partitions(
             &mut self,
             request: impl tonic::IntoRequest<super::GetPartitionsRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetPartitionsResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
@@ -1803,13 +2214,22 @@ pub mod node_service_client {
         pub async fn get_os_info(
             &mut self,
             request: impl tonic::IntoRequest<super::GetOsInfoRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetOsInfoResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
@@ -1818,13 +2238,22 @@ pub mod node_service_client {
         pub async fn get_se_linux_info(
             &mut self,
             request: impl tonic::IntoRequest<super::GetSeLinuxInfoRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetSeLinuxInfoResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
@@ -1833,13 +2262,22 @@ pub mod node_service_client {
         pub async fn get_sys_config(
             &mut self,
             request: impl tonic::IntoRequest<super::GetSysConfigRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetSysConfigResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
@@ -1848,13 +2286,22 @@ pub mod node_service_client {
         pub async fn get_sys_errors(
             &mut self,
             request: impl tonic::IntoRequest<super::GetSysErrorsRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetSysErrorsResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
@@ -1863,13 +2310,22 @@ pub mod node_service_client {
         pub async fn get_mem_info(
             &mut self,
             request: impl tonic::IntoRequest<super::GetMemInfoRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetMemInfoResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
@@ -1878,13 +2334,22 @@ pub mod node_service_client {
         pub async fn get_metrics(
             &mut self,
             request: impl tonic::IntoRequest<super::GetMetricsRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetMetricsResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
@@ -1893,13 +2358,22 @@ pub mod node_service_client {
         pub async fn get_proc_info(
             &mut self,
             request: impl tonic::IntoRequest<super::GetProcInfoRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetProcInfoResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
@@ -1908,13 +2382,22 @@ pub mod node_service_client {
         pub async fn start_profiling(
             &mut self,
             request: impl tonic::IntoRequest<super::StartProfilingRequest>,
-        ) -> std::result::Result<tonic::Response<super::StartProfilingResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
@@ -1923,28 +2406,48 @@ pub mod node_service_client {
         pub async fn download_profile_data(
             &mut self,
             request: impl tonic::IntoRequest<super::DownloadProfileDataRequest>,
-        ) -> std::result::Result<tonic::Response<super::DownloadProfileDataResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
+                .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> {
+        ) -> 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())))?;
+                .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 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"));
@@ -1953,13 +2456,22 @@ pub mod node_service_client {
         pub async fn get_sr_metrics(
             &mut self,
             request: impl tonic::IntoRequest<super::GetSrMetricsDataRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetSrMetricsDataResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
@@ -1968,58 +2480,100 @@ pub mod node_service_client {
         pub async fn get_all_bucket_stats(
             &mut self,
             request: impl tonic::IntoRequest<super::GetAllBucketStatsRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetAllBucketStatsResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
+                .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> {
+        ) -> 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())))?;
+                .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 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"));
+                .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> {
+        ) -> 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())))?;
+                .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 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"));
+                .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> {
+        ) -> 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())))?;
+                .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 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"));
@@ -2028,13 +2582,22 @@ pub mod node_service_client {
         pub async fn load_policy(
             &mut self,
             request: impl tonic::IntoRequest<super::LoadPolicyRequest>,
-        ) -> std::result::Result<tonic::Response<super::LoadPolicyResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
@@ -2043,28 +2606,48 @@ pub mod node_service_client {
         pub async fn load_policy_mapping(
             &mut self,
             request: impl tonic::IntoRequest<super::LoadPolicyMappingRequest>,
-        ) -> std::result::Result<tonic::Response<super::LoadPolicyMappingResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
+                .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> {
+        ) -> 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())))?;
+                .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 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"));
@@ -2073,28 +2656,48 @@ pub mod node_service_client {
         pub async fn delete_service_account(
             &mut self,
             request: impl tonic::IntoRequest<super::DeleteServiceAccountRequest>,
-        ) -> std::result::Result<tonic::Response<super::DeleteServiceAccountResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
+                .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> {
+        ) -> 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())))?;
+                .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 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"));
@@ -2103,28 +2706,48 @@ pub mod node_service_client {
         pub async fn load_service_account(
             &mut self,
             request: impl tonic::IntoRequest<super::LoadServiceAccountRequest>,
-        ) -> std::result::Result<tonic::Response<super::LoadServiceAccountResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
+                .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> {
+        ) -> 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())))?;
+                .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 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"));
@@ -2133,16 +2756,30 @@ pub mod node_service_client {
         pub async fn reload_site_replication_config(
             &mut self,
             request: impl tonic::IntoRequest<super::ReloadSiteReplicationConfigRequest>,
-        ) -> std::result::Result<tonic::Response<super::ReloadSiteReplicationConfigResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
+                .insert(
+                    GrpcMethod::new(
+                        "node_service.NodeService",
+                        "ReloadSiteReplicationConfig",
+                    ),
+                );
             self.inner.unary(req, path, codec).await
         }
         /// rpc VerifyBinary() returns () {};
@@ -2150,13 +2787,22 @@ pub mod node_service_client {
         pub async fn signal_service(
             &mut self,
             request: impl tonic::IntoRequest<super::SignalServiceRequest>,
-        ) -> std::result::Result<tonic::Response<super::SignalServiceResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
@@ -2165,58 +2811,100 @@ pub mod node_service_client {
         pub async fn background_heal_status(
             &mut self,
             request: impl tonic::IntoRequest<super::BackgroundHealStatusRequest>,
-        ) -> std::result::Result<tonic::Response<super::BackgroundHealStatusResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
+                .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> {
+        ) -> 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())))?;
+                .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 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"));
+                .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> {
+        ) -> 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())))?;
+                .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 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"));
+                .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> {
+        ) -> 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())))?;
+                .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 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"));
@@ -2225,13 +2913,22 @@ pub mod node_service_client {
         pub async fn stop_rebalance(
             &mut self,
             request: impl tonic::IntoRequest<super::StopRebalanceRequest>,
-        ) -> std::result::Result<tonic::Response<super::StopRebalanceResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
@@ -2240,38 +2937,69 @@ pub mod node_service_client {
         pub async fn load_rebalance_meta(
             &mut self,
             request: impl tonic::IntoRequest<super::LoadRebalanceMetaRequest>,
-        ) -> std::result::Result<tonic::Response<super::LoadRebalanceMetaResponse>, tonic::Status> {
+        ) -> 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())))?;
+                .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 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"));
+                .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> {
+        ) -> 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())))?;
+                .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 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"));
+                .insert(
+                    GrpcMethod::new(
+                        "node_service.NodeService",
+                        "LoadTransitionTierConfig",
+                    ),
+                );
             self.inner.unary(req, path, codec).await
         }
     }
 }
 /// Generated server implementations.
 pub mod node_service_server {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::wildcard_imports, clippy::let_unit_value)]
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
     use tonic::codegen::*;
     /// Generated trait containing gRPC methods that should be implemented for use with NodeServiceServer.
     #[async_trait]
@@ -2284,23 +3012,38 @@ pub mod node_service_server {
         async fn heal_bucket(
             &self,
             request: tonic::Request<super::HealBucketRequest>,
-        ) -> std::result::Result<tonic::Response<super::HealBucketResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::HealBucketResponse>,
+            tonic::Status,
+        >;
         async fn list_bucket(
             &self,
             request: tonic::Request<super::ListBucketRequest>,
-        ) -> std::result::Result<tonic::Response<super::ListBucketResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::ListBucketResponse>,
+            tonic::Status,
+        >;
         async fn make_bucket(
             &self,
             request: tonic::Request<super::MakeBucketRequest>,
-        ) -> std::result::Result<tonic::Response<super::MakeBucketResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::MakeBucketResponse>,
+            tonic::Status,
+        >;
         async fn get_bucket_info(
             &self,
             request: tonic::Request<super::GetBucketInfoRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetBucketInfoResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::GetBucketInfoResponse>,
+            tonic::Status,
+        >;
         async fn delete_bucket(
             &self,
             request: tonic::Request<super::DeleteBucketRequest>,
-        ) -> std::result::Result<tonic::Response<super::DeleteBucketResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::DeleteBucketResponse>,
+            tonic::Status,
+        >;
         async fn read_all(
             &self,
             request: tonic::Request<super::ReadAllRequest>,
@@ -2308,7 +3051,10 @@ pub mod node_service_server {
         async fn write_all(
             &self,
             request: tonic::Request<super::WriteAllRequest>,
-        ) -> std::result::Result<tonic::Response<super::WriteAllResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::WriteAllResponse>,
+            tonic::Status,
+        >;
         async fn delete(
             &self,
             request: tonic::Request<super::DeleteRequest>,
@@ -2316,33 +3062,52 @@ pub mod node_service_server {
         async fn verify_file(
             &self,
             request: tonic::Request<super::VerifyFileRequest>,
-        ) -> std::result::Result<tonic::Response<super::VerifyFileResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::VerifyFileResponse>,
+            tonic::Status,
+        >;
         async fn check_parts(
             &self,
             request: tonic::Request<super::CheckPartsRequest>,
-        ) -> std::result::Result<tonic::Response<super::CheckPartsResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::CheckPartsResponse>,
+            tonic::Status,
+        >;
         async fn rename_part(
             &self,
             request: tonic::Request<super::RenamePartRequst>,
-        ) -> std::result::Result<tonic::Response<super::RenamePartResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::RenamePartResponse>,
+            tonic::Status,
+        >;
         async fn rename_file(
             &self,
             request: tonic::Request<super::RenameFileRequst>,
-        ) -> std::result::Result<tonic::Response<super::RenameFileResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::RenameFileResponse>,
+            tonic::Status,
+        >;
         async fn write(
             &self,
             request: tonic::Request<super::WriteRequest>,
         ) -> std::result::Result<tonic::Response<super::WriteResponse>, tonic::Status>;
         /// Server streaming response type for the WriteStream method.
-        type WriteStreamStream: tonic::codegen::tokio_stream::Stream<Item = std::result::Result<super::WriteResponse, tonic::Status>>
+        type WriteStreamStream: tonic::codegen::tokio_stream::Stream<
+                Item = std::result::Result<super::WriteResponse, tonic::Status>,
+            >
             + std::marker::Send
             + 'static;
         async fn write_stream(
             &self,
             request: tonic::Request<tonic::Streaming<super::WriteRequest>>,
-        ) -> std::result::Result<tonic::Response<Self::WriteStreamStream>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<Self::WriteStreamStream>,
+            tonic::Status,
+        >;
         /// Server streaming response type for the ReadAt method.
-        type ReadAtStream: tonic::codegen::tokio_stream::Stream<Item = std::result::Result<super::ReadAtResponse, tonic::Status>>
+        type ReadAtStream: tonic::codegen::tokio_stream::Stream<
+                Item = std::result::Result<super::ReadAtResponse, tonic::Status>,
+            >
             + std::marker::Send
             + 'static;
         ///  rpc Append(AppendRequest) returns (AppendResponse) {};
@@ -2361,39 +3126,66 @@ pub mod node_service_server {
         async fn rename_data(
             &self,
             request: tonic::Request<super::RenameDataRequest>,
-        ) -> std::result::Result<tonic::Response<super::RenameDataResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::RenameDataResponse>,
+            tonic::Status,
+        >;
         async fn make_volumes(
             &self,
             request: tonic::Request<super::MakeVolumesRequest>,
-        ) -> std::result::Result<tonic::Response<super::MakeVolumesResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::MakeVolumesResponse>,
+            tonic::Status,
+        >;
         async fn make_volume(
             &self,
             request: tonic::Request<super::MakeVolumeRequest>,
-        ) -> std::result::Result<tonic::Response<super::MakeVolumeResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::MakeVolumeResponse>,
+            tonic::Status,
+        >;
         async fn list_volumes(
             &self,
             request: tonic::Request<super::ListVolumesRequest>,
-        ) -> std::result::Result<tonic::Response<super::ListVolumesResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::ListVolumesResponse>,
+            tonic::Status,
+        >;
         async fn stat_volume(
             &self,
             request: tonic::Request<super::StatVolumeRequest>,
-        ) -> std::result::Result<tonic::Response<super::StatVolumeResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::StatVolumeResponse>,
+            tonic::Status,
+        >;
         async fn delete_paths(
             &self,
             request: tonic::Request<super::DeletePathsRequest>,
-        ) -> std::result::Result<tonic::Response<super::DeletePathsResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::DeletePathsResponse>,
+            tonic::Status,
+        >;
         async fn update_metadata(
             &self,
             request: tonic::Request<super::UpdateMetadataRequest>,
-        ) -> std::result::Result<tonic::Response<super::UpdateMetadataResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::UpdateMetadataResponse>,
+            tonic::Status,
+        >;
         async fn write_metadata(
             &self,
             request: tonic::Request<super::WriteMetadataRequest>,
-        ) -> std::result::Result<tonic::Response<super::WriteMetadataResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::WriteMetadataResponse>,
+            tonic::Status,
+        >;
         async fn read_version(
             &self,
             request: tonic::Request<super::ReadVersionRequest>,
-        ) -> std::result::Result<tonic::Response<super::ReadVersionResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::ReadVersionResponse>,
+            tonic::Status,
+        >;
         async fn read_xl(
             &self,
             request: tonic::Request<super::ReadXlRequest>,
@@ -2401,25 +3193,42 @@ pub mod node_service_server {
         async fn delete_version(
             &self,
             request: tonic::Request<super::DeleteVersionRequest>,
-        ) -> std::result::Result<tonic::Response<super::DeleteVersionResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::DeleteVersionResponse>,
+            tonic::Status,
+        >;
         async fn delete_versions(
             &self,
             request: tonic::Request<super::DeleteVersionsRequest>,
-        ) -> std::result::Result<tonic::Response<super::DeleteVersionsResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::DeleteVersionsResponse>,
+            tonic::Status,
+        >;
         async fn read_multiple(
             &self,
             request: tonic::Request<super::ReadMultipleRequest>,
-        ) -> std::result::Result<tonic::Response<super::ReadMultipleResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::ReadMultipleResponse>,
+            tonic::Status,
+        >;
         async fn delete_volume(
             &self,
             request: tonic::Request<super::DeleteVolumeRequest>,
-        ) -> std::result::Result<tonic::Response<super::DeleteVolumeResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::DeleteVolumeResponse>,
+            tonic::Status,
+        >;
         async fn disk_info(
             &self,
             request: tonic::Request<super::DiskInfoRequest>,
-        ) -> std::result::Result<tonic::Response<super::DiskInfoResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::DiskInfoResponse>,
+            tonic::Status,
+        >;
         /// Server streaming response type for the NsScanner method.
-        type NsScannerStream: tonic::codegen::tokio_stream::Stream<Item = std::result::Result<super::NsScannerResponse, tonic::Status>>
+        type NsScannerStream: tonic::codegen::tokio_stream::Stream<
+                Item = std::result::Result<super::NsScannerResponse, tonic::Status>,
+            >
             + std::marker::Send
             + 'static;
         async fn ns_scanner(
@@ -2429,35 +3238,59 @@ pub mod node_service_server {
         async fn lock(
             &self,
             request: tonic::Request<super::GenerallyLockRequest>,
-        ) -> std::result::Result<tonic::Response<super::GenerallyLockResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::GenerallyLockResponse>,
+            tonic::Status,
+        >;
         async fn un_lock(
             &self,
             request: tonic::Request<super::GenerallyLockRequest>,
-        ) -> std::result::Result<tonic::Response<super::GenerallyLockResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::GenerallyLockResponse>,
+            tonic::Status,
+        >;
         async fn r_lock(
             &self,
             request: tonic::Request<super::GenerallyLockRequest>,
-        ) -> std::result::Result<tonic::Response<super::GenerallyLockResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::GenerallyLockResponse>,
+            tonic::Status,
+        >;
         async fn r_un_lock(
             &self,
             request: tonic::Request<super::GenerallyLockRequest>,
-        ) -> std::result::Result<tonic::Response<super::GenerallyLockResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::GenerallyLockResponse>,
+            tonic::Status,
+        >;
         async fn force_un_lock(
             &self,
             request: tonic::Request<super::GenerallyLockRequest>,
-        ) -> std::result::Result<tonic::Response<super::GenerallyLockResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::GenerallyLockResponse>,
+            tonic::Status,
+        >;
         async fn refresh(
             &self,
             request: tonic::Request<super::GenerallyLockRequest>,
-        ) -> std::result::Result<tonic::Response<super::GenerallyLockResponse>, tonic::Status>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> std::result::Result<
+            tonic::Response<super::ServerInfoResponse>,
+            tonic::Status,
+        >;
         async fn get_cpus(
             &self,
             request: tonic::Request<super::GetCpusRequest>,
@@ -2465,137 +3298,236 @@ pub mod node_service_server {
         async fn get_net_info(
             &self,
             request: tonic::Request<super::GetNetInfoRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetNetInfoResponse>, tonic::Status>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> 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>;
+        ) -> std::result::Result<
+            tonic::Response<super::LoadTransitionTierConfigResponse>,
+            tonic::Status,
+        >;
     }
     #[derive(Debug)]
     pub struct NodeServiceServer<T> {
@@ -2618,7 +3550,10 @@ pub mod node_service_server {
                 max_encoding_message_size: None,
             }
         }
-        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
         where
             F: tonic::service::Interceptor,
         {
@@ -2662,7 +3597,10 @@ pub mod node_service_server {
         type Response = http::Response<tonic::body::BoxBody>;
         type Error = std::convert::Infallible;
         type Future = BoxFuture<Self::Response, Self::Error>;
-        fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<std::result::Result<(), Self::Error>> {
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
             Poll::Ready(Ok(()))
         }
         fn call(&mut self, req: http::Request<B>) -> Self::Future {
@@ -2670,12 +3608,21 @@ pub mod node_service_server {
                 "/node_service.NodeService/Ping" => {
                     #[allow(non_camel_case_types)]
                     struct PingSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::PingRequest> for PingSvc<T> {
+                    impl<T: NodeService> tonic::server::UnaryService<super::PingRequest>
+                    for PingSvc<T> {
                         type Response = super::PingResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::PingRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PingRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::ping(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::ping(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -2688,8 +3635,14 @@ pub mod node_service_server {
                         let method = PingSvc(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);
+                            .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)
                     };
@@ -2698,12 +3651,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/HealBucket" => {
                     #[allow(non_camel_case_types)]
                     struct HealBucketSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::HealBucketRequest> for HealBucketSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::HealBucketRequest>
+                    for HealBucketSvc<T> {
                         type Response = super::HealBucketResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::HealBucketRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::HealBucketRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::heal_bucket(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::heal_bucket(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -2716,8 +3680,14 @@ pub mod node_service_server {
                         let method = HealBucketSvc(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);
+                            .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)
                     };
@@ -2726,12 +3696,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/ListBucket" => {
                     #[allow(non_camel_case_types)]
                     struct ListBucketSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::ListBucketRequest> for ListBucketSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::ListBucketRequest>
+                    for ListBucketSvc<T> {
                         type Response = super::ListBucketResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::ListBucketRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::ListBucketRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::list_bucket(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::list_bucket(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -2744,8 +3725,14 @@ pub mod node_service_server {
                         let method = ListBucketSvc(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);
+                            .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)
                     };
@@ -2754,12 +3741,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/MakeBucket" => {
                     #[allow(non_camel_case_types)]
                     struct MakeBucketSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::MakeBucketRequest> for MakeBucketSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::MakeBucketRequest>
+                    for MakeBucketSvc<T> {
                         type Response = super::MakeBucketResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::MakeBucketRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MakeBucketRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::make_bucket(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::make_bucket(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -2772,8 +3770,14 @@ pub mod node_service_server {
                         let method = MakeBucketSvc(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);
+                            .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)
                     };
@@ -2782,12 +3786,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/GetBucketInfo" => {
                     #[allow(non_camel_case_types)]
                     struct GetBucketInfoSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::GetBucketInfoRequest> for GetBucketInfoSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::GetBucketInfoRequest>
+                    for GetBucketInfoSvc<T> {
                         type Response = super::GetBucketInfoResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::GetBucketInfoRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetBucketInfoRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::get_bucket_info(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::get_bucket_info(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -2800,8 +3815,14 @@ pub mod node_service_server {
                         let method = GetBucketInfoSvc(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);
+                            .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)
                     };
@@ -2810,12 +3831,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/DeleteBucket" => {
                     #[allow(non_camel_case_types)]
                     struct DeleteBucketSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::DeleteBucketRequest> for DeleteBucketSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::DeleteBucketRequest>
+                    for DeleteBucketSvc<T> {
                         type Response = super::DeleteBucketResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::DeleteBucketRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::DeleteBucketRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::delete_bucket(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::delete_bucket(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -2828,8 +3860,14 @@ pub mod node_service_server {
                         let method = DeleteBucketSvc(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);
+                            .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)
                     };
@@ -2838,12 +3876,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/ReadAll" => {
                     #[allow(non_camel_case_types)]
                     struct ReadAllSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::ReadAllRequest> for ReadAllSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::ReadAllRequest>
+                    for ReadAllSvc<T> {
                         type Response = super::ReadAllResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::ReadAllRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::ReadAllRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::read_all(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::read_all(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -2856,8 +3905,14 @@ pub mod node_service_server {
                         let method = ReadAllSvc(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);
+                            .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)
                     };
@@ -2866,12 +3921,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/WriteAll" => {
                     #[allow(non_camel_case_types)]
                     struct WriteAllSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::WriteAllRequest> for WriteAllSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::WriteAllRequest>
+                    for WriteAllSvc<T> {
                         type Response = super::WriteAllResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::WriteAllRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::WriteAllRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::write_all(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::write_all(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -2884,8 +3950,14 @@ pub mod node_service_server {
                         let method = WriteAllSvc(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);
+                            .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)
                     };
@@ -2894,12 +3966,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/Delete" => {
                     #[allow(non_camel_case_types)]
                     struct DeleteSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::DeleteRequest> for DeleteSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::DeleteRequest>
+                    for DeleteSvc<T> {
                         type Response = super::DeleteResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::DeleteRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::DeleteRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::delete(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::delete(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -2912,8 +3995,14 @@ pub mod node_service_server {
                         let method = DeleteSvc(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);
+                            .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)
                     };
@@ -2922,12 +4011,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/VerifyFile" => {
                     #[allow(non_camel_case_types)]
                     struct VerifyFileSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::VerifyFileRequest> for VerifyFileSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::VerifyFileRequest>
+                    for VerifyFileSvc<T> {
                         type Response = super::VerifyFileResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::VerifyFileRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::VerifyFileRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::verify_file(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::verify_file(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -2940,8 +4040,14 @@ pub mod node_service_server {
                         let method = VerifyFileSvc(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);
+                            .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)
                     };
@@ -2950,12 +4056,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/CheckParts" => {
                     #[allow(non_camel_case_types)]
                     struct CheckPartsSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::CheckPartsRequest> for CheckPartsSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::CheckPartsRequest>
+                    for CheckPartsSvc<T> {
                         type Response = super::CheckPartsResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::CheckPartsRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::CheckPartsRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::check_parts(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::check_parts(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -2968,8 +4085,14 @@ pub mod node_service_server {
                         let method = CheckPartsSvc(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);
+                            .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)
                     };
@@ -2978,12 +4101,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/RenamePart" => {
                     #[allow(non_camel_case_types)]
                     struct RenamePartSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::RenamePartRequst> for RenamePartSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::RenamePartRequst>
+                    for RenamePartSvc<T> {
                         type Response = super::RenamePartResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::RenamePartRequst>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::RenamePartRequst>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::rename_part(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::rename_part(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -2996,8 +4130,14 @@ pub mod node_service_server {
                         let method = RenamePartSvc(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);
+                            .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)
                     };
@@ -3006,12 +4146,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/RenameFile" => {
                     #[allow(non_camel_case_types)]
                     struct RenameFileSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::RenameFileRequst> for RenameFileSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::RenameFileRequst>
+                    for RenameFileSvc<T> {
                         type Response = super::RenameFileResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::RenameFileRequst>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::RenameFileRequst>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::rename_file(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::rename_file(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3024,8 +4175,14 @@ pub mod node_service_server {
                         let method = RenameFileSvc(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);
+                            .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)
                     };
@@ -3034,12 +4191,21 @@ pub mod node_service_server {
                 "/node_service.NodeService/Write" => {
                     #[allow(non_camel_case_types)]
                     struct WriteSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::WriteRequest> for WriteSvc<T> {
+                    impl<T: NodeService> tonic::server::UnaryService<super::WriteRequest>
+                    for WriteSvc<T> {
                         type Response = super::WriteResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::WriteRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::WriteRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::write(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::write(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3052,8 +4218,14 @@ pub mod node_service_server {
                         let method = WriteSvc(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);
+                            .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)
                     };
@@ -3062,13 +4234,26 @@ pub mod node_service_server {
                 "/node_service.NodeService/WriteStream" => {
                     #[allow(non_camel_case_types)]
                     struct WriteStreamSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::StreamingService<super::WriteRequest> for WriteStreamSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::StreamingService<super::WriteRequest>
+                    for WriteStreamSvc<T> {
                         type Response = super::WriteResponse;
                         type ResponseStream = T::WriteStreamStream;
-                        type Future = BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<tonic::Streaming<super::WriteRequest>>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::ResponseStream>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<
+                                tonic::Streaming<super::WriteRequest>,
+                            >,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::write_stream(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::write_stream(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3081,8 +4266,14 @@ pub mod node_service_server {
                         let method = WriteStreamSvc(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);
+                            .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.streaming(method, req).await;
                         Ok(res)
                     };
@@ -3091,13 +4282,26 @@ pub mod node_service_server {
                 "/node_service.NodeService/ReadAt" => {
                     #[allow(non_camel_case_types)]
                     struct ReadAtSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::StreamingService<super::ReadAtRequest> for ReadAtSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::StreamingService<super::ReadAtRequest>
+                    for ReadAtSvc<T> {
                         type Response = super::ReadAtResponse;
                         type ResponseStream = T::ReadAtStream;
-                        type Future = BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<tonic::Streaming<super::ReadAtRequest>>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::ResponseStream>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<
+                                tonic::Streaming<super::ReadAtRequest>,
+                            >,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::read_at(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::read_at(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3110,8 +4314,14 @@ pub mod node_service_server {
                         let method = ReadAtSvc(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);
+                            .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.streaming(method, req).await;
                         Ok(res)
                     };
@@ -3120,12 +4330,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/ListDir" => {
                     #[allow(non_camel_case_types)]
                     struct ListDirSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::ListDirRequest> for ListDirSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::ListDirRequest>
+                    for ListDirSvc<T> {
                         type Response = super::ListDirResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::ListDirRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::ListDirRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::list_dir(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::list_dir(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3138,8 +4359,14 @@ pub mod node_service_server {
                         let method = ListDirSvc(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);
+                            .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)
                     };
@@ -3148,12 +4375,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/WalkDir" => {
                     #[allow(non_camel_case_types)]
                     struct WalkDirSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::WalkDirRequest> for WalkDirSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::WalkDirRequest>
+                    for WalkDirSvc<T> {
                         type Response = super::WalkDirResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::WalkDirRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::WalkDirRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::walk_dir(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::walk_dir(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3166,8 +4404,14 @@ pub mod node_service_server {
                         let method = WalkDirSvc(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);
+                            .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)
                     };
@@ -3176,12 +4420,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/RenameData" => {
                     #[allow(non_camel_case_types)]
                     struct RenameDataSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::RenameDataRequest> for RenameDataSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::RenameDataRequest>
+                    for RenameDataSvc<T> {
                         type Response = super::RenameDataResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::RenameDataRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::RenameDataRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::rename_data(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::rename_data(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3194,8 +4449,14 @@ pub mod node_service_server {
                         let method = RenameDataSvc(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);
+                            .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)
                     };
@@ -3204,12 +4465,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/MakeVolumes" => {
                     #[allow(non_camel_case_types)]
                     struct MakeVolumesSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::MakeVolumesRequest> for MakeVolumesSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::MakeVolumesRequest>
+                    for MakeVolumesSvc<T> {
                         type Response = super::MakeVolumesResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::MakeVolumesRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MakeVolumesRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::make_volumes(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::make_volumes(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3222,8 +4494,14 @@ pub mod node_service_server {
                         let method = MakeVolumesSvc(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);
+                            .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)
                     };
@@ -3232,12 +4510,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/MakeVolume" => {
                     #[allow(non_camel_case_types)]
                     struct MakeVolumeSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::MakeVolumeRequest> for MakeVolumeSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::MakeVolumeRequest>
+                    for MakeVolumeSvc<T> {
                         type Response = super::MakeVolumeResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::MakeVolumeRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MakeVolumeRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::make_volume(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::make_volume(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3250,8 +4539,14 @@ pub mod node_service_server {
                         let method = MakeVolumeSvc(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);
+                            .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)
                     };
@@ -3260,12 +4555,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/ListVolumes" => {
                     #[allow(non_camel_case_types)]
                     struct ListVolumesSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::ListVolumesRequest> for ListVolumesSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::ListVolumesRequest>
+                    for ListVolumesSvc<T> {
                         type Response = super::ListVolumesResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::ListVolumesRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::ListVolumesRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::list_volumes(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::list_volumes(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3278,8 +4584,14 @@ pub mod node_service_server {
                         let method = ListVolumesSvc(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);
+                            .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)
                     };
@@ -3288,12 +4600,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/StatVolume" => {
                     #[allow(non_camel_case_types)]
                     struct StatVolumeSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::StatVolumeRequest> for StatVolumeSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::StatVolumeRequest>
+                    for StatVolumeSvc<T> {
                         type Response = super::StatVolumeResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::StatVolumeRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::StatVolumeRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::stat_volume(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::stat_volume(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3306,8 +4629,14 @@ pub mod node_service_server {
                         let method = StatVolumeSvc(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);
+                            .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)
                     };
@@ -3316,12 +4645,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/DeletePaths" => {
                     #[allow(non_camel_case_types)]
                     struct DeletePathsSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::DeletePathsRequest> for DeletePathsSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::DeletePathsRequest>
+                    for DeletePathsSvc<T> {
                         type Response = super::DeletePathsResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::DeletePathsRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::DeletePathsRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::delete_paths(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::delete_paths(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3334,8 +4674,14 @@ pub mod node_service_server {
                         let method = DeletePathsSvc(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);
+                            .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)
                     };
@@ -3344,12 +4690,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/UpdateMetadata" => {
                     #[allow(non_camel_case_types)]
                     struct UpdateMetadataSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::UpdateMetadataRequest> for UpdateMetadataSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::UpdateMetadataRequest>
+                    for UpdateMetadataSvc<T> {
                         type Response = super::UpdateMetadataResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::UpdateMetadataRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::UpdateMetadataRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::update_metadata(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::update_metadata(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3362,8 +4719,14 @@ pub mod node_service_server {
                         let method = UpdateMetadataSvc(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);
+                            .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)
                     };
@@ -3372,12 +4735,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/WriteMetadata" => {
                     #[allow(non_camel_case_types)]
                     struct WriteMetadataSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::WriteMetadataRequest> for WriteMetadataSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::WriteMetadataRequest>
+                    for WriteMetadataSvc<T> {
                         type Response = super::WriteMetadataResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::WriteMetadataRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::WriteMetadataRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::write_metadata(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::write_metadata(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3390,8 +4764,14 @@ pub mod node_service_server {
                         let method = WriteMetadataSvc(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);
+                            .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)
                     };
@@ -3400,12 +4780,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/ReadVersion" => {
                     #[allow(non_camel_case_types)]
                     struct ReadVersionSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::ReadVersionRequest> for ReadVersionSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::ReadVersionRequest>
+                    for ReadVersionSvc<T> {
                         type Response = super::ReadVersionResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::ReadVersionRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::ReadVersionRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::read_version(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::read_version(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3418,8 +4809,14 @@ pub mod node_service_server {
                         let method = ReadVersionSvc(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);
+                            .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)
                     };
@@ -3428,12 +4825,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/ReadXL" => {
                     #[allow(non_camel_case_types)]
                     struct ReadXLSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::ReadXlRequest> for ReadXLSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::ReadXlRequest>
+                    for ReadXLSvc<T> {
                         type Response = super::ReadXlResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::ReadXlRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::ReadXlRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::read_xl(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::read_xl(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3446,8 +4854,14 @@ pub mod node_service_server {
                         let method = ReadXLSvc(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);
+                            .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)
                     };
@@ -3456,12 +4870,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/DeleteVersion" => {
                     #[allow(non_camel_case_types)]
                     struct DeleteVersionSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::DeleteVersionRequest> for DeleteVersionSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::DeleteVersionRequest>
+                    for DeleteVersionSvc<T> {
                         type Response = super::DeleteVersionResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::DeleteVersionRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::DeleteVersionRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::delete_version(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::delete_version(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3474,8 +4899,14 @@ pub mod node_service_server {
                         let method = DeleteVersionSvc(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);
+                            .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)
                     };
@@ -3484,12 +4915,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/DeleteVersions" => {
                     #[allow(non_camel_case_types)]
                     struct DeleteVersionsSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::DeleteVersionsRequest> for DeleteVersionsSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::DeleteVersionsRequest>
+                    for DeleteVersionsSvc<T> {
                         type Response = super::DeleteVersionsResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::DeleteVersionsRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::DeleteVersionsRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::delete_versions(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::delete_versions(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3502,8 +4944,14 @@ pub mod node_service_server {
                         let method = DeleteVersionsSvc(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);
+                            .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)
                     };
@@ -3512,12 +4960,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/ReadMultiple" => {
                     #[allow(non_camel_case_types)]
                     struct ReadMultipleSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::ReadMultipleRequest> for ReadMultipleSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::ReadMultipleRequest>
+                    for ReadMultipleSvc<T> {
                         type Response = super::ReadMultipleResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::ReadMultipleRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::ReadMultipleRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::read_multiple(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::read_multiple(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3530,8 +4989,14 @@ pub mod node_service_server {
                         let method = ReadMultipleSvc(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);
+                            .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)
                     };
@@ -3540,12 +5005,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/DeleteVolume" => {
                     #[allow(non_camel_case_types)]
                     struct DeleteVolumeSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::DeleteVolumeRequest> for DeleteVolumeSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::DeleteVolumeRequest>
+                    for DeleteVolumeSvc<T> {
                         type Response = super::DeleteVolumeResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::DeleteVolumeRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::DeleteVolumeRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::delete_volume(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::delete_volume(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3558,8 +5034,14 @@ pub mod node_service_server {
                         let method = DeleteVolumeSvc(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);
+                            .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)
                     };
@@ -3568,12 +5050,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/DiskInfo" => {
                     #[allow(non_camel_case_types)]
                     struct DiskInfoSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::DiskInfoRequest> for DiskInfoSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::DiskInfoRequest>
+                    for DiskInfoSvc<T> {
                         type Response = super::DiskInfoResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::DiskInfoRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::DiskInfoRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::disk_info(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::disk_info(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3586,8 +5079,14 @@ pub mod node_service_server {
                         let method = DiskInfoSvc(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);
+                            .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)
                     };
@@ -3596,13 +5095,26 @@ pub mod node_service_server {
                 "/node_service.NodeService/NsScanner" => {
                     #[allow(non_camel_case_types)]
                     struct NsScannerSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::StreamingService<super::NsScannerRequest> for NsScannerSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::StreamingService<super::NsScannerRequest>
+                    for NsScannerSvc<T> {
                         type Response = super::NsScannerResponse;
                         type ResponseStream = T::NsScannerStream;
-                        type Future = BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<tonic::Streaming<super::NsScannerRequest>>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::ResponseStream>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<
+                                tonic::Streaming<super::NsScannerRequest>,
+                            >,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::ns_scanner(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::ns_scanner(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3615,8 +5127,14 @@ pub mod node_service_server {
                         let method = NsScannerSvc(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);
+                            .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.streaming(method, req).await;
                         Ok(res)
                     };
@@ -3625,12 +5143,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/Lock" => {
                     #[allow(non_camel_case_types)]
                     struct LockSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::GenerallyLockRequest> for LockSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::GenerallyLockRequest>
+                    for LockSvc<T> {
                         type Response = super::GenerallyLockResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::GenerallyLockRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GenerallyLockRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::lock(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::lock(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3643,8 +5172,14 @@ pub mod node_service_server {
                         let method = LockSvc(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);
+                            .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)
                     };
@@ -3653,12 +5188,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/UnLock" => {
                     #[allow(non_camel_case_types)]
                     struct UnLockSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::GenerallyLockRequest> for UnLockSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::GenerallyLockRequest>
+                    for UnLockSvc<T> {
                         type Response = super::GenerallyLockResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::GenerallyLockRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GenerallyLockRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::un_lock(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::un_lock(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3671,8 +5217,14 @@ pub mod node_service_server {
                         let method = UnLockSvc(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);
+                            .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)
                     };
@@ -3681,12 +5233,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/RLock" => {
                     #[allow(non_camel_case_types)]
                     struct RLockSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::GenerallyLockRequest> for RLockSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::GenerallyLockRequest>
+                    for RLockSvc<T> {
                         type Response = super::GenerallyLockResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::GenerallyLockRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GenerallyLockRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::r_lock(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::r_lock(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3699,8 +5262,14 @@ pub mod node_service_server {
                         let method = RLockSvc(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);
+                            .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)
                     };
@@ -3709,12 +5278,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/RUnLock" => {
                     #[allow(non_camel_case_types)]
                     struct RUnLockSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::GenerallyLockRequest> for RUnLockSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::GenerallyLockRequest>
+                    for RUnLockSvc<T> {
                         type Response = super::GenerallyLockResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::GenerallyLockRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GenerallyLockRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::r_un_lock(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::r_un_lock(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3727,8 +5307,14 @@ pub mod node_service_server {
                         let method = RUnLockSvc(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);
+                            .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)
                     };
@@ -3737,12 +5323,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/ForceUnLock" => {
                     #[allow(non_camel_case_types)]
                     struct ForceUnLockSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::GenerallyLockRequest> for ForceUnLockSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::GenerallyLockRequest>
+                    for ForceUnLockSvc<T> {
                         type Response = super::GenerallyLockResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::GenerallyLockRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GenerallyLockRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::force_un_lock(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::force_un_lock(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3755,8 +5352,14 @@ pub mod node_service_server {
                         let method = ForceUnLockSvc(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);
+                            .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)
                     };
@@ -3765,12 +5368,23 @@ pub mod node_service_server {
                 "/node_service.NodeService/Refresh" => {
                     #[allow(non_camel_case_types)]
                     struct RefreshSvc<T: NodeService>(pub Arc<T>);
-                    impl<T: NodeService> tonic::server::UnaryService<super::GenerallyLockRequest> for RefreshSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::UnaryService<super::GenerallyLockRequest>
+                    for RefreshSvc<T> {
                         type Response = super::GenerallyLockResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::GenerallyLockRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GenerallyLockRequest>,
+                        ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as NodeService>::refresh(&inner, request).await };
+                            let fut = async move {
+                                <T as NodeService>::refresh(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3783,8 +5397,14 @@ pub mod node_service_server {
                         let method = RefreshSvc(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);
+                            .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)
                     };
@@ -3793,12 +5413,24 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::local_storage_info(&inner, request)
+                                    .await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3811,8 +5443,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -3821,12 +5459,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::server_info(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3839,8 +5488,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -3849,12 +5504,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::get_cpus(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3867,8 +5533,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -3877,12 +5549,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::get_net_info(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3895,8 +5578,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -3905,12 +5594,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::get_partitions(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3923,8 +5623,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -3933,12 +5639,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::get_os_info(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3951,8 +5668,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -3961,12 +5684,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::get_se_linux_info(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -3979,8 +5713,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -3989,12 +5729,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::get_sys_config(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4007,8 +5758,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4017,12 +5774,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::get_sys_errors(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4035,8 +5803,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4045,12 +5819,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::get_mem_info(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4063,8 +5848,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4073,12 +5864,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::get_metrics(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4091,8 +5893,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4101,12 +5909,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::get_proc_info(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4119,8 +5938,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4129,12 +5954,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::start_profiling(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4147,8 +5983,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4157,12 +5999,24 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::download_profile_data(&inner, request)
+                                    .await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4175,8 +6029,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4185,12 +6045,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::get_bucket_stats(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4203,8 +6074,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4213,12 +6090,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::get_sr_metrics(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4231,8 +6119,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4241,12 +6135,24 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::get_all_bucket_stats(&inner, request)
+                                    .await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4259,8 +6165,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4269,12 +6181,24 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::load_bucket_metadata(&inner, request)
+                                    .await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4287,8 +6211,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4297,12 +6227,24 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::delete_bucket_metadata(&inner, request)
+                                    .await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4315,8 +6257,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4325,12 +6273,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::delete_policy(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4343,8 +6302,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4353,12 +6318,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::load_policy(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4371,8 +6347,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4381,12 +6363,24 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::load_policy_mapping(&inner, request)
+                                    .await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4399,8 +6393,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4409,12 +6409,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::delete_user(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4427,8 +6438,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4437,12 +6454,24 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::delete_service_account(&inner, request)
+                                    .await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4455,8 +6484,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4465,12 +6500,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::load_user(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4483,8 +6529,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4493,12 +6545,24 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::load_service_account(&inner, request)
+                                    .await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4511,8 +6575,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4521,12 +6591,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::load_group(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4539,8 +6620,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4549,14 +6636,30 @@ pub mod node_service_server {
                 "/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>
-                    {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::reload_site_replication_config(
+                                        &inner,
+                                        request,
+                                    )
+                                    .await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4569,8 +6672,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4579,12 +6688,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::signal_service(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4597,8 +6717,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4607,12 +6733,24 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::background_heal_status(&inner, request)
+                                    .await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4625,8 +6763,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4635,12 +6779,24 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::get_metacache_listing(&inner, request)
+                                    .await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4653,8 +6809,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4663,12 +6825,27 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::update_metacache_listing(
+                                        &inner,
+                                        request,
+                                    )
+                                    .await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4681,8 +6858,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4691,12 +6874,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::reload_pool_meta(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4709,8 +6903,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4719,12 +6919,23 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::stop_rebalance(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4737,8 +6948,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4747,12 +6964,24 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::load_rebalance_meta(&inner, request)
+                                    .await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4765,8 +6994,14 @@ pub mod node_service_server {
                         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);
+                            .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)
                     };
@@ -4775,12 +7010,29 @@ pub mod node_service_server {
                 "/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> {
+                    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 {
+                        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 };
+                            let fut = async move {
+                                <T as NodeService>::load_transition_tier_config(
+                                        &inner,
+                                        request,
+                                    )
+                                    .await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -4793,20 +7045,36 @@ pub mod node_service_server {
                         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);
+                            .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();
-                    headers.insert(tonic::Status::GRPC_STATUS, (tonic::Code::Unimplemented as i32).into());
-                    headers.insert(http::header::CONTENT_TYPE, tonic::metadata::GRPC_CONTENT_TYPE);
-                    Ok(response)
-                }),
+                _ => {
+                    Box::pin(async move {
+                        let mut response = http::Response::new(empty_body());
+                        let headers = response.headers_mut();
+                        headers
+                            .insert(
+                                tonic::Status::GRPC_STATUS,
+                                (tonic::Code::Unimplemented as i32).into(),
+                            );
+                        headers
+                            .insert(
+                                http::header::CONTENT_TYPE,
+                                tonic::metadata::GRPC_CONTENT_TYPE,
+                            );
+                        Ok(response)
+                    })
+                }
             }
         }
     }
diff --git a/ecstore/src/disk/local.rs b/ecstore/src/disk/local.rs
index 4ad6af74..01f025ba 100644
--- a/ecstore/src/disk/local.rs
+++ b/ecstore/src/disk/local.rs
@@ -19,7 +19,7 @@ use crate::disk::os::{check_path_length, is_empty_dir};
 use crate::disk::{LocalFileReader, LocalFileWriter, STORAGE_FORMAT_FILE};
 use crate::error::{Error, Result};
 use crate::global::{GLOBAL_IsErasureSD, GLOBAL_RootDiskThreshold};
-use crate::heal::data_scanner::{has_active_rules, scan_data_folder, ScannerItem, SizeSummary};
+use crate::heal::data_scanner::{has_active_rules, scan_data_folder, ScannerItem, ShouldSleepFn, SizeSummary};
 use crate::heal::data_scanner_metric::{ScannerMetric, ScannerMetrics};
 use crate::heal::data_usage_cache::{DataUsageCache, DataUsageEntry};
 use crate::heal::error::{ERR_IGNORE_FILE_CONTRIB, ERR_SKIP_FILE};
@@ -1974,6 +1974,7 @@ impl DiskAPI for LocalDisk {
         cache: &DataUsageCache,
         updates: Sender<DataUsageEntry>,
         scan_mode: HealScanMode,
+        we_sleep: ShouldSleepFn,
     ) -> Result<DataUsageCache> {
         self.scanning.fetch_add(1, Ordering::SeqCst);
         defer!(|| { self.scanning.fetch_sub(1, Ordering::SeqCst) });
@@ -2089,6 +2090,7 @@ impl DiskAPI for LocalDisk {
                 })
             }),
             scan_mode,
+            we_sleep,
         )
         .await?;
         data_usage_info.info.last_update = Some(SystemTime::now());
diff --git a/ecstore/src/disk/mod.rs b/ecstore/src/disk/mod.rs
index dd1fc6c0..03b51ba3 100644
--- a/ecstore/src/disk/mod.rs
+++ b/ecstore/src/disk/mod.rs
@@ -19,6 +19,7 @@ use crate::{
     error::{Error, Result},
     file_meta::{merge_file_meta_versions, FileMeta, FileMetaShallowVersion},
     heal::{
+        data_scanner::ShouldSleepFn,
         data_usage_cache::{DataUsageCache, DataUsageEntry},
         heal_commands::{HealScanMode, HealingTracker},
     },
@@ -350,11 +351,12 @@ impl DiskAPI for Disk {
         cache: &DataUsageCache,
         updates: Sender<DataUsageEntry>,
         scan_mode: HealScanMode,
+        we_sleep: ShouldSleepFn,
     ) -> Result<DataUsageCache> {
         info!("ns_scanner");
         match self {
-            Disk::Local(local_disk) => local_disk.ns_scanner(cache, updates, scan_mode).await,
-            Disk::Remote(remote_disk) => remote_disk.ns_scanner(cache, updates, scan_mode).await,
+            Disk::Local(local_disk) => local_disk.ns_scanner(cache, updates, scan_mode, we_sleep).await,
+            Disk::Remote(remote_disk) => remote_disk.ns_scanner(cache, updates, scan_mode, we_sleep).await,
         }
     }
 
@@ -467,6 +469,7 @@ pub trait DiskAPI: Debug + Send + Sync + 'static {
         cache: &DataUsageCache,
         updates: Sender<DataUsageEntry>,
         scan_mode: HealScanMode,
+        we_sleep: ShouldSleepFn,
     ) -> Result<DataUsageCache>;
     async fn healing(&self) -> Option<HealingTracker>;
 }
@@ -1045,7 +1048,7 @@ type NodeClient = NodeServiceClient<
 
 #[derive(Debug)]
 pub struct RemoteFileWriter {
-    pub root: PathBuf,
+    pub endpoint: Endpoint,
     pub volume: String,
     pub path: String,
     pub is_append: bool,
@@ -1054,7 +1057,7 @@ pub struct RemoteFileWriter {
 }
 
 impl RemoteFileWriter {
-    pub async fn new(root: PathBuf, volume: String, path: String, is_append: bool, mut client: NodeClient) -> Result<Self> {
+    pub async fn new(endpoint: Endpoint, volume: String, path: String, is_append: bool, mut client: NodeClient) -> Result<Self> {
         let (tx, rx) = mpsc::channel(128);
         let in_stream = ReceiverStream::new(rx);
 
@@ -1063,7 +1066,7 @@ impl RemoteFileWriter {
         let resp_stream = response.into_inner();
 
         Ok(Self {
-            root,
+            endpoint,
             volume,
             path,
             is_append,
@@ -1081,7 +1084,7 @@ impl Writer for RemoteFileWriter {
 
     async fn write(&mut self, buf: &[u8]) -> Result<()> {
         let request = WriteRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volume: self.volume.to_string(),
             path: self.path.to_string(),
             is_append: self.is_append,
@@ -1236,7 +1239,7 @@ impl Reader for LocalFileReader {
 
 #[derive(Debug)]
 pub struct RemoteFileReader {
-    pub root: PathBuf,
+    pub endpoint: Endpoint,
     pub volume: String,
     pub path: String,
     tx: Sender<ReadAtRequest>,
@@ -1244,7 +1247,7 @@ pub struct RemoteFileReader {
 }
 
 impl RemoteFileReader {
-    pub async fn new(root: PathBuf, volume: String, path: String, mut client: NodeClient) -> Result<Self> {
+    pub async fn new(endpoint: Endpoint, volume: String, path: String, mut client: NodeClient) -> Result<Self> {
         let (tx, rx) = mpsc::channel(128);
         let in_stream = ReceiverStream::new(rx);
 
@@ -1253,7 +1256,7 @@ impl RemoteFileReader {
         let resp_stream = response.into_inner();
 
         Ok(Self {
-            root,
+            endpoint,
             volume,
             path,
             tx,
@@ -1266,7 +1269,7 @@ impl RemoteFileReader {
 impl Reader for RemoteFileReader {
     async fn read_at(&mut self, offset: usize, buf: &mut [u8]) -> Result<usize> {
         let request = ReadAtRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volume: self.volume.to_string(),
             path: self.path.to_string(),
             offset: offset.try_into().unwrap(),
diff --git a/ecstore/src/disk/remote.rs b/ecstore/src/disk/remote.rs
index 618365f6..8c171113 100644
--- a/ecstore/src/disk/remote.rs
+++ b/ecstore/src/disk/remote.rs
@@ -25,6 +25,7 @@ use crate::{
     disk::error::DiskError,
     error::{Error, Result},
     heal::{
+        data_scanner::ShouldSleepFn,
         data_usage_cache::{DataUsageCache, DataUsageEntry},
         heal_commands::{HealScanMode, HealingTracker},
     },
@@ -129,7 +130,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(ReadAllRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volume: volume.to_string(),
             path: path.to_string(),
         });
@@ -151,7 +152,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(WriteAllRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volume: volume.to_string(),
             path: path.to_string(),
             data,
@@ -173,7 +174,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(DeleteRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volume: volume.to_string(),
             path: path.to_string(),
             options,
@@ -195,7 +196,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(VerifyFileRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volume: volume.to_string(),
             path: path.to_string(),
             file_info,
@@ -219,7 +220,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(CheckPartsRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volume: volume.to_string(),
             path: path.to_string(),
             file_info,
@@ -242,7 +243,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(RenamePartRequst {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             src_volume: src_volume.to_string(),
             src_path: src_path.to_string(),
             dst_volume: dst_volume.to_string(),
@@ -264,7 +265,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(RenameFileRequst {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             src_volume: src_volume.to_string(),
             src_path: src_path.to_string(),
             dst_volume: dst_volume.to_string(),
@@ -284,7 +285,7 @@ impl DiskAPI for RemoteDisk {
         info!("create_file");
         Ok(FileWriter::Remote(
             RemoteFileWriter::new(
-                self.root.clone(),
+                self.endpoint.clone(),
                 volume.to_string(),
                 path.to_string(),
                 false,
@@ -300,7 +301,7 @@ impl DiskAPI for RemoteDisk {
         info!("append_file");
         Ok(FileWriter::Remote(
             RemoteFileWriter::new(
-                self.root.clone(),
+                self.endpoint.clone(),
                 volume.to_string(),
                 path.to_string(),
                 true,
@@ -316,7 +317,7 @@ impl DiskAPI for RemoteDisk {
         info!("read_file");
         Ok(FileReader::Remote(
             RemoteFileReader::new(
-                self.root.clone(),
+                self.endpoint.clone(),
                 volume.to_string(),
                 path.to_string(),
                 node_service_time_out_client(&self.addr)
@@ -333,7 +334,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(ListDirRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volume: volume.to_string(),
         });
 
@@ -353,7 +354,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(WalkDirRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             walk_dir_options,
         });
 
@@ -386,7 +387,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(RenameDataRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             src_volume: src_volume.to_string(),
             src_path: src_path.to_string(),
             file_info,
@@ -411,7 +412,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(MakeVolumesRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volumes: volumes.iter().map(|s| (*s).to_string()).collect(),
         });
 
@@ -430,7 +431,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(MakeVolumeRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volume: volume.to_string(),
         });
 
@@ -449,7 +450,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(ListVolumesRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
         });
 
         let response = client.list_volumes(request).await?.into_inner();
@@ -473,7 +474,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(StatVolumeRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volume: volume.to_string(),
         });
 
@@ -495,7 +496,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(DeletePathsRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volume: volume.to_string(),
             paths,
         });
@@ -517,7 +518,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(UpdateMetadataRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volume: volume.to_string(),
             path: path.to_string(),
             file_info,
@@ -540,7 +541,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(WriteMetadataRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volume: volume.to_string(),
             path: path.to_string(),
             file_info,
@@ -569,7 +570,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(ReadVersionRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volume: volume.to_string(),
             path: path.to_string(),
             version_id: version_id.to_string(),
@@ -593,7 +594,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(ReadXlRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volume: volume.to_string(),
             path: path.to_string(),
             read_data,
@@ -625,7 +626,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(DeleteVersionRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volume: volume.to_string(),
             path: path.to_string(),
             file_info,
@@ -659,7 +660,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(DeleteVersionsRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volume: volume.to_string(),
             versions: versions_str,
             opts,
@@ -694,7 +695,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(ReadMultipleRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             read_multiple_req,
         });
 
@@ -719,7 +720,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(DeleteVolumeRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             volume: volume.to_string(),
         });
 
@@ -739,7 +740,7 @@ impl DiskAPI for RemoteDisk {
             .await
             .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
         let request = Request::new(DiskInfoRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             opts,
         });
 
@@ -759,6 +760,7 @@ impl DiskAPI for RemoteDisk {
         cache: &DataUsageCache,
         updates: Sender<DataUsageEntry>,
         scan_mode: HealScanMode,
+        _we_sleep: ShouldSleepFn,
     ) -> Result<DataUsageCache> {
         info!("ns_scanner");
         let cache = serde_json::to_string(cache)?;
@@ -770,7 +772,7 @@ impl DiskAPI for RemoteDisk {
         let in_stream = ReceiverStream::new(rx);
         let mut response = client.ns_scanner(in_stream).await?.into_inner();
         let request = NsScannerRequest {
-            disk: self.root.to_string_lossy().to_string(),
+            disk: self.endpoint.to_string(),
             cache,
             scan_mode: scan_mode as u64,
         };
diff --git a/ecstore/src/endpoints.rs b/ecstore/src/endpoints.rs
index 334c74d6..b1205b87 100644
--- a/ecstore/src/endpoints.rs
+++ b/ecstore/src/endpoints.rs
@@ -1,4 +1,5 @@
-use tracing::warn;
+use tracing::{info, warn};
+use url::Url;
 
 use crate::{
     disk::endpoint::{Endpoint, EndpointType},
diff --git a/ecstore/src/heal/background_heal_ops.rs b/ecstore/src/heal/background_heal_ops.rs
index fa9a1f63..4e49d7f5 100644
--- a/ecstore/src/heal/background_heal_ops.rs
+++ b/ecstore/src/heal/background_heal_ops.rs
@@ -1,3 +1,4 @@
+use madmin::heal_commands::HealResultItem;
 use std::{cmp::Ordering, env, path::PathBuf, sync::Arc, time::Duration};
 use tokio::{
     sync::{
@@ -10,7 +11,7 @@ use tracing::{error, info};
 use uuid::Uuid;
 
 use super::{
-    heal_commands::{HealOpts, HealResultItem},
+    heal_commands::HealOpts,
     heal_ops::{new_bg_heal_sequence, HealSequence},
 };
 use crate::heal::error::ERR_RETRY_HEALING;
diff --git a/ecstore/src/heal/data_scanner.rs b/ecstore/src/heal/data_scanner.rs
index 0f579093..05b883af 100644
--- a/ecstore/src/heal/data_scanner.rs
+++ b/ecstore/src/heal/data_scanner.rs
@@ -62,7 +62,7 @@ use crate::{
     store_api::{FileInfo, ObjectInfo},
 };
 
-const _DATA_SCANNER_SLEEP_PER_FOLDER: Duration = Duration::from_millis(1); // Time to wait between folders.
+const DATA_SCANNER_SLEEP_PER_FOLDER: Duration = Duration::from_millis(1); // Time to wait between folders.
 const DATA_USAGE_UPDATE_DIR_CYCLES: u32 = 16; // Visit all folders every n cycles.
 const DATA_SCANNER_COMPACT_LEAST_OBJECT: u64 = 500; // Compact when there are less than this many objects in a branch.
 const DATA_SCANNER_COMPACT_AT_CHILDREN: u64 = 10000; // Compact when there are this many children in a branch.
@@ -73,7 +73,6 @@ const DATA_SCANNER_START_DELAY: Duration = Duration::from_secs(60); // Time to w
 pub const HEAL_DELETE_DANGLING: bool = true;
 const HEAL_OBJECT_SELECT_PROB: u64 = 1024; // Overall probability of a file being scanned; one in n.
 
-// static SCANNER_SLEEPER: () = new_dynamic_sleeper(2, Duration::from_secs(1), true); // Keep defaults same as config defaults
 static SCANNER_CYCLE: AtomicU64 = AtomicU64::new(DATA_SCANNER_START_DELAY.as_secs());
 static _SCANNER_IDLE_MODE: AtomicU32 = AtomicU32::new(0); // default is throttled when idle
 static SCANNER_EXCESS_OBJECT_VERSIONS: AtomicU64 = AtomicU64::new(100);
@@ -81,9 +80,67 @@ static SCANNER_EXCESS_OBJECT_VERSIONS_TOTAL_SIZE: AtomicU64 = AtomicU64::new(102
 static SCANNER_EXCESS_FOLDERS: AtomicU64 = AtomicU64::new(50_000);
 
 lazy_static! {
+    static ref SCANNER_SLEEPER: RwLock<DynamicSleeper> = RwLock::new(new_dynamic_sleeper(2.0, Duration::from_secs(1), true));
     pub static ref globalHealConfig: Arc<RwLock<Config>> = Arc::new(RwLock::new(Config::default()));
 }
 
+struct DynamicSleeper {
+    factor: f64,
+    max_sleep: Duration,
+    min_sleep: Duration,
+    _is_scanner: bool,
+}
+
+type TimerFn = Pin<Box<dyn Future<Output = ()> + Send>>;
+impl DynamicSleeper {
+    fn timer() -> TimerFn {
+        let t = SystemTime::now();
+        Box::pin(async move {
+            let done_at = SystemTime::now().duration_since(t).unwrap_or_default();
+            SCANNER_SLEEPER.read().await.sleep(done_at).await;
+        })
+    }
+
+    async fn sleep(&self, base: Duration) {
+        let (min_wait, max_wait) = (self.min_sleep, self.max_sleep);
+        let factor = self.factor;
+
+        let want_sleep = {
+            let tmp = base.mul_f64(factor);
+            if tmp < min_wait {
+                return;
+            }
+
+            if max_wait > Duration::from_secs(0) && tmp > max_wait {
+                max_wait
+            } else {
+                tmp
+            }
+        };
+        sleep(want_sleep).await;
+    }
+
+    fn _update(&mut self, factor: f64, max_wait: Duration) -> Result<()> {
+        if (self.factor - factor).abs() < 1e-10 && self.max_sleep == max_wait {
+            return Ok(());
+        }
+
+        self.factor = factor;
+        self.max_sleep = max_wait;
+
+        Ok(())
+    }
+}
+
+fn new_dynamic_sleeper(factor: f64, max_wait: Duration, is_scanner: bool) -> DynamicSleeper {
+    DynamicSleeper {
+        factor,
+        max_sleep: max_wait,
+        min_sleep: Duration::from_micros(100),
+        _is_scanner: is_scanner,
+    }
+}
+
 pub async fn init_data_scanner() {
     tokio::spawn(async move {
         loop {
@@ -457,6 +514,7 @@ struct CachedFolder {
 pub type GetSizeFn =
     Box<dyn Fn(&ScannerItem) -> Pin<Box<dyn Future<Output = Result<SizeSummary>> + Send>> + Send + Sync + 'static>;
 pub type UpdateCurrentPathFn = Arc<dyn Fn(&str) -> Pin<Box<dyn Future<Output = ()> + Send>> + Send + Sync + 'static>;
+pub type ShouldSleepFn = Option<Arc<dyn Fn() -> bool + Send + Sync + 'static>>;
 
 struct FolderScanner {
     root: String,
@@ -474,6 +532,7 @@ struct FolderScanner {
     update_current_path: UpdateCurrentPathFn,
     skip_heal: AtomicBool,
     drive: LocalDrive,
+    we_sleep: ShouldSleepFn,
 }
 
 impl FolderScanner {
@@ -514,6 +573,12 @@ impl FolderScanner {
                 None
             };
 
+            if let Some(should_sleep) = &self.we_sleep {
+                if should_sleep() {
+                    SCANNER_SLEEPER.read().await.sleep(DATA_SCANNER_SLEEP_PER_FOLDER).await;
+                }
+            }
+
             let mut existing_folders = Vec::new();
             let mut new_folders = Vec::new();
             let mut found_objects: bool = false;
@@ -553,6 +618,16 @@ impl FolderScanner {
                         continue;
                     }
 
+                    let _wait = if let Some(should_sleep) = &self.we_sleep {
+                        if should_sleep() {
+                            DynamicSleeper::timer()
+                        } else {
+                            Box::pin(async {})
+                        }
+                    } else {
+                        Box::pin(async {})
+                    };
+
                     let mut item = ScannerItem {
                         path: Path::new(&self.root).join(&ent_name).to_string_lossy().to_string(),
                         bucket,
@@ -1001,6 +1076,7 @@ pub async fn scan_data_folder(
     cache: &DataUsageCache,
     get_size_fn: GetSizeFn,
     heal_scan_mode: HealScanMode,
+    should_sleep: ShouldSleepFn,
 ) -> Result<DataUsageCache> {
     if cache.info.name.is_empty() || cache.info.name == DATA_USAGE_ROOT {
         return Err(Error::from_string("internal error: root scan attempted"));
@@ -1029,6 +1105,7 @@ pub async fn scan_data_folder(
         disks_quorum: disks.len() / 2,
         skip_heal,
         drive: drive.clone(),
+        we_sleep: should_sleep,
     };
 
     if *GLOBAL_IsErasure.read().await || !cache.info.skip_healing {
diff --git a/ecstore/src/heal/heal_commands.rs b/ecstore/src/heal/heal_commands.rs
index 0ce85910..3aee3cd5 100644
--- a/ecstore/src/heal/heal_commands.rs
+++ b/ecstore/src/heal/heal_commands.rs
@@ -24,7 +24,6 @@ use crate::{
 use super::{background_heal_ops::get_local_disks_to_heal, heal_ops::BG_HEALING_UUID};
 
 pub type HealScanMode = usize;
-pub type HealItemType = String;
 
 pub const HEAL_UNKNOWN_SCAN: HealScanMode = 0;
 pub const HEAL_NORMAL_SCAN: HealScanMode = 1;
@@ -66,49 +65,6 @@ pub struct HealOpts {
     pub set: Option<usize>,
 }
 
-#[derive(Clone, Debug, Default, Serialize, Deserialize)]
-pub struct HealDriveInfo {
-    pub uuid: String,
-    pub endpoint: String,
-    pub state: String,
-}
-
-#[derive(Clone, Debug, Default, Serialize, Deserialize)]
-pub struct Infos {
-    #[serde(rename = "drives")]
-    pub drives: Vec<HealDriveInfo>,
-}
-
-#[derive(Clone, Debug, Default, Serialize, Deserialize)]
-pub struct HealResultItem {
-    #[serde(rename = "resultId")]
-    pub result_index: usize,
-    #[serde(rename = "type")]
-    pub heal_item_type: HealItemType,
-    #[serde(rename = "bucket")]
-    pub bucket: String,
-    #[serde(rename = "object")]
-    pub object: String,
-    #[serde(rename = "versionId")]
-    pub version_id: String,
-    #[serde(rename = "detail")]
-    pub detail: String,
-    #[serde(rename = "parityBlocks")]
-    pub parity_blocks: usize,
-    #[serde(rename = "dataBlocks")]
-    pub data_blocks: usize,
-    #[serde(rename = "diskCount")]
-    pub disk_count: usize,
-    #[serde(rename = "setCount")]
-    pub set_count: usize,
-    #[serde(rename = "before")]
-    pub before: Infos,
-    #[serde(rename = "after")]
-    pub after: Infos,
-    #[serde(rename = "objectSize")]
-    pub object_size: usize,
-}
-
 #[derive(Debug, Serialize, Deserialize)]
 pub struct HealStartSuccess {
     #[serde(rename = "clientToken")]
diff --git a/ecstore/src/heal/heal_ops.rs b/ecstore/src/heal/heal_ops.rs
index 53b5551a..b7b694b4 100644
--- a/ecstore/src/heal/heal_ops.rs
+++ b/ecstore/src/heal/heal_ops.rs
@@ -2,19 +2,14 @@ use super::{
     background_heal_ops::HealTask,
     data_scanner::HEAL_DELETE_DANGLING,
     error::ERR_SKIP_FILE,
-    heal_commands::{
-        HealItemType, HealOpts, HealResultItem, HealScanMode, HealStopSuccess, HealingTracker, HEAL_ITEM_BUCKET_METADATA,
-    },
+    heal_commands::{HealOpts, HealScanMode, HealStopSuccess, HealingTracker, HEAL_ITEM_BUCKET_METADATA},
 };
 use crate::store_api::StorageAPI;
 use crate::{
     config::common::CONFIG_PREFIX,
     disk::RUSTFS_META_BUCKET,
     global::GLOBAL_BackgroundHealRoutine,
-    heal::{
-        error::ERR_HEAL_STOP_SIGNALLED,
-        heal_commands::{HealDriveInfo, DRIVE_STATE_OK},
-    },
+    heal::{error::ERR_HEAL_STOP_SIGNALLED, heal_commands::DRIVE_STATE_OK},
 };
 use crate::{
     disk::{endpoint::Endpoint, MetaCacheEntry},
@@ -32,6 +27,7 @@ use crate::{
 use chrono::Utc;
 use futures::join;
 use lazy_static::lazy_static;
+use madmin::heal_commands::{HealDriveInfo, HealItemType, HealResultItem};
 use serde::{Deserialize, Serialize};
 use std::{
     collections::HashMap,
diff --git a/ecstore/src/lib.rs b/ecstore/src/lib.rs
index 244a7d8d..2dbdebad 100644
--- a/ecstore/src/lib.rs
+++ b/ecstore/src/lib.rs
@@ -14,7 +14,7 @@ pub mod heal;
 pub mod metrics_realtime;
 pub mod notification_sys;
 pub mod peer;
-mod peer_rest_client;
+pub mod peer_rest_client;
 mod quorum;
 pub mod set_disk;
 mod sets;
diff --git a/ecstore/src/notification_sys.rs b/ecstore/src/notification_sys.rs
index a36d1462..004bf249 100644
--- a/ecstore/src/notification_sys.rs
+++ b/ecstore/src/notification_sys.rs
@@ -25,8 +25,8 @@ pub fn get_global_notification_sys() -> Option<&'static NotificationSys> {
 }
 
 pub struct NotificationSys {
-    peer_clients: Vec<Option<PeerRestClient>>,
-    all_peer_clients: Vec<Option<PeerRestClient>>,
+    pub peer_clients: Vec<Option<PeerRestClient>>,
+    pub all_peer_clients: Vec<Option<PeerRestClient>>,
 }
 
 impl NotificationSys {
diff --git a/ecstore/src/peer.rs b/ecstore/src/peer.rs
index a5217ba9..e9d02c60 100644
--- a/ecstore/src/peer.rs
+++ b/ecstore/src/peer.rs
@@ -1,5 +1,6 @@
 use async_trait::async_trait;
 use futures::future::join_all;
+use madmin::heal_commands::{HealDriveInfo, HealResultItem};
 use protos::node_service_time_out_client;
 use protos::proto_gen::node_service::{
     DeleteBucketRequest, GetBucketInfoRequest, HealBucketRequest, ListBucketRequest, MakeBucketRequest,
@@ -14,8 +15,7 @@ use crate::disk::error::is_all_buckets_not_found;
 use crate::disk::{DiskAPI, DiskStore};
 use crate::global::GLOBAL_LOCAL_DISK_MAP;
 use crate::heal::heal_commands::{
-    HealDriveInfo, HealOpts, HealResultItem, DRIVE_STATE_CORRUPT, DRIVE_STATE_MISSING, DRIVE_STATE_OFFLINE, DRIVE_STATE_OK,
-    HEAL_ITEM_BUCKET,
+    HealOpts, DRIVE_STATE_CORRUPT, DRIVE_STATE_MISSING, DRIVE_STATE_OFFLINE, DRIVE_STATE_OK, HEAL_ITEM_BUCKET,
 };
 use crate::heal::heal_ops::RUESTFS_RESERVED_BUCKET;
 use crate::quorum::{bucket_op_ignored_errs, reduce_write_quorum_errs};
diff --git a/ecstore/src/peer_rest_client.rs b/ecstore/src/peer_rest_client.rs
index 76aaee69..f6792575 100644
--- a/ecstore/src/peer_rest_client.rs
+++ b/ecstore/src/peer_rest_client.rs
@@ -35,7 +35,7 @@ pub const PEER_RESTSIGNAL: &str = "signal";
 pub const PEER_RESTSUB_SYS: &str = "sub-sys";
 pub const PEER_RESTDRY_RUN: &str = "dry-run";
 
-#[derive(Debug, Clone)]
+#[derive(Clone, Debug)]
 pub struct PeerRestClient {
     pub host: XHost,
     pub grid_host: String,
diff --git a/ecstore/src/set_disk.rs b/ecstore/src/set_disk.rs
index 152f2063..85d5790c 100644
--- a/ecstore/src/set_disk.rs
+++ b/ecstore/src/set_disk.rs
@@ -31,8 +31,8 @@ use crate::{
         data_usage::{DATA_USAGE_CACHE_NAME, DATA_USAGE_ROOT},
         data_usage_cache::{DataUsageCacheInfo, DataUsageEntry, DataUsageEntryInfo},
         heal_commands::{
-            HealDriveInfo, HealOpts, HealResultItem, HealScanMode, HealingTracker, DRIVE_STATE_CORRUPT, DRIVE_STATE_MISSING,
-            DRIVE_STATE_OFFLINE, DRIVE_STATE_OK, HEAL_DEEP_SCAN, HEAL_ITEM_OBJECT, HEAL_NORMAL_SCAN,
+            HealOpts, HealScanMode, HealingTracker, DRIVE_STATE_CORRUPT, DRIVE_STATE_MISSING, DRIVE_STATE_OFFLINE,
+            DRIVE_STATE_OK, HEAL_DEEP_SCAN, HEAL_ITEM_OBJECT, HEAL_NORMAL_SCAN,
         },
         heal_ops::BG_HEALING_UUID,
     },
@@ -64,6 +64,7 @@ use lock::{
     namespace_lock::{new_nslock, NsLockMap},
     LockApi,
 };
+use madmin::heal_commands::{HealDriveInfo, HealResultItem};
 use rand::{
     thread_rng,
     {seq::SliceRandom, Rng},
@@ -2811,7 +2812,7 @@ impl SetDisks {
                             });
                             // Calc usage
                             let before = cache.info.last_update;
-                            let cache = match disk.clone().ns_scanner(&cache, tx, heal_scan_mode).await {
+                            let cache = match disk.clone().ns_scanner(&cache, tx, heal_scan_mode, None).await {
                                 Ok(cache) => cache,
                                 Err(_) => {
                                     if cache.info.last_update > before {
diff --git a/ecstore/src/sets.rs b/ecstore/src/sets.rs
index 000fe458..fb387b63 100644
--- a/ecstore/src/sets.rs
+++ b/ecstore/src/sets.rs
@@ -5,6 +5,7 @@ use common::globals::GLOBAL_Local_Node_Name;
 use futures::future::join_all;
 use http::HeaderMap;
 use lock::{namespace_lock::NsLockMap, new_lock_api, LockApi};
+use madmin::heal_commands::{HealDriveInfo, HealResultItem};
 use tokio::sync::RwLock;
 use uuid::Uuid;
 
@@ -18,8 +19,7 @@ use crate::{
     error::{Error, Result},
     global::{is_dist_erasure, GLOBAL_LOCAL_DISK_SET_DRIVES},
     heal::heal_commands::{
-        HealDriveInfo, HealOpts, HealResultItem, DRIVE_STATE_CORRUPT, DRIVE_STATE_MISSING, DRIVE_STATE_OFFLINE, DRIVE_STATE_OK,
-        HEAL_ITEM_METADATA,
+        HealOpts, DRIVE_STATE_CORRUPT, DRIVE_STATE_MISSING, DRIVE_STATE_OFFLINE, DRIVE_STATE_OK, HEAL_ITEM_METADATA,
     },
     set_disk::SetDisks,
     store_api::{
diff --git a/ecstore/src/store.rs b/ecstore/src/store.rs
index 148837f5..c117c997 100644
--- a/ecstore/src/store.rs
+++ b/ecstore/src/store.rs
@@ -12,7 +12,7 @@ use crate::global::{
 };
 use crate::heal::data_usage::{DataUsageInfo, DATA_USAGE_ROOT};
 use crate::heal::data_usage_cache::{DataUsageCache, DataUsageCacheInfo};
-use crate::heal::heal_commands::{HealOpts, HealResultItem, HealScanMode, HEAL_ITEM_METADATA};
+use crate::heal::heal_commands::{HealOpts, HealScanMode, HEAL_ITEM_METADATA};
 use crate::heal::heal_ops::{HealEntryFn, HealSequence};
 use crate::new_object_layer_fn;
 use crate::notification_sys::get_global_notification_sys;
@@ -45,6 +45,7 @@ use futures::future::join_all;
 use glob::Pattern;
 use http::HeaderMap;
 use lazy_static::lazy_static;
+use madmin::heal_commands::HealResultItem;
 use rand::Rng;
 use s3s::dto::{BucketVersioningStatus, ObjectLockConfiguration, ObjectLockEnabled, VersioningConfiguration};
 use std::cmp::Ordering;
diff --git a/ecstore/src/store_api.rs b/ecstore/src/store_api.rs
index 715d2181..48a860fe 100644
--- a/ecstore/src/store_api.rs
+++ b/ecstore/src/store_api.rs
@@ -2,12 +2,14 @@ use crate::heal::heal_ops::HealSequence;
 use crate::{
     disk::DiskStore,
     error::{Error, Result},
-    heal::heal_commands::{HealOpts, HealResultItem},
+    heal::heal_commands::HealOpts,
     utils::path::decode_dir_object,
     xhttp,
 };
 use futures::StreamExt;
 use http::HeaderMap;
+use madmin::heal_commands::HealResultItem;
+use madmin::info_commands::DiskMetrics;
 use rmp_serde::Serializer;
 use s3s::{dto::StreamingBlob, Body};
 use serde::{Deserialize, Serialize};
diff --git a/ecstore/src/utils/mod.rs b/ecstore/src/utils/mod.rs
index 467d8cdf..65aac72b 100644
--- a/ecstore/src/utils/mod.rs
+++ b/ecstore/src/utils/mod.rs
@@ -6,6 +6,5 @@ pub mod hash;
 pub mod net;
 pub mod os;
 pub mod path;
-pub mod time;
 pub mod wildcard;
 pub mod xml;
diff --git a/ecstore/src/utils/time.rs b/ecstore/src/utils/time.rs
deleted file mode 100644
index 791db2d4..00000000
--- a/ecstore/src/utils/time.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-use std::time::Duration;
-
-use tracing::info;
-
-pub fn parse_duration(s: &str) -> Option<Duration> {
-    if s.ends_with("ms") {
-        if let Ok(s) = s.trim_end_matches("ms").parse::<u64>() {
-            return Some(Duration::from_millis(s));
-        }
-    } else if s.ends_with("s") {
-        if let Ok(s) = s.trim_end_matches('s').parse::<u64>() {
-            return Some(Duration::from_secs(s));
-        }
-    } else if s.ends_with("m") {
-        if let Ok(s) = s.trim_end_matches('m').parse::<u64>() {
-            return Some(Duration::from_secs(s * 60));
-        }
-    } else if s.ends_with("h") {
-        if let Ok(s) = s.trim_end_matches('h').parse::<u64>() {
-            return Some(Duration::from_secs(s * 60 * 60));
-        }
-    }
-    info!("can not parse duration, s: {}", s);
-    None
-}
-
-#[cfg(test)]
-mod test {
-    use std::time::Duration;
-
-    use super::parse_duration;
-
-    #[test]
-    fn test_parse_dur() {
-        let s = String::from("3s");
-        let dur = parse_duration(&s);
-        println!("{:?}", dur);
-        assert_eq!(Some(Duration::from_secs(3)), dur);
-
-        let s = String::from("3ms");
-        let dur = parse_duration(&s);
-        println!("{:?}", dur);
-        assert_eq!(Some(Duration::from_millis(3)), dur);
-
-        let s = String::from("3m");
-        let dur = parse_duration(&s);
-        println!("{:?}", dur);
-        assert_eq!(Some(Duration::from_secs(3 * 60)), dur);
-
-        let s = String::from("3h");
-        let dur = parse_duration(&s);
-        println!("{:?}", dur);
-        assert_eq!(Some(Duration::from_secs(3 * 60 * 60)), dur);
-    }
-}
diff --git a/madmin/Cargo.toml b/madmin/Cargo.toml
index 9893a41d..5a32ec15 100644
--- a/madmin/Cargo.toml
+++ b/madmin/Cargo.toml
@@ -12,6 +12,9 @@ workspace = true
 [dependencies]
 chrono.workspace = true
 common.workspace = true
+humantime.workspace = true
+hyper.workspace = true
 psutil = "3.3.0"
 serde.workspace = true
 time.workspace =true
+tracing.workspace = true
diff --git a/madmin/src/heal_commands.rs b/madmin/src/heal_commands.rs
new file mode 100644
index 00000000..eec724ac
--- /dev/null
+++ b/madmin/src/heal_commands.rs
@@ -0,0 +1,46 @@
+use serde::{Deserialize, Serialize};
+
+pub type HealItemType = String;
+
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+pub struct HealDriveInfo {
+    pub uuid: String,
+    pub endpoint: String,
+    pub state: String,
+}
+
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+pub struct Infos {
+    #[serde(rename = "drives")]
+    pub drives: Vec<HealDriveInfo>,
+}
+
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+pub struct HealResultItem {
+    #[serde(rename = "resultId")]
+    pub result_index: usize,
+    #[serde(rename = "type")]
+    pub heal_item_type: HealItemType,
+    #[serde(rename = "bucket")]
+    pub bucket: String,
+    #[serde(rename = "object")]
+    pub object: String,
+    #[serde(rename = "versionId")]
+    pub version_id: String,
+    #[serde(rename = "detail")]
+    pub detail: String,
+    #[serde(rename = "parityBlocks")]
+    pub parity_blocks: usize,
+    #[serde(rename = "dataBlocks")]
+    pub data_blocks: usize,
+    #[serde(rename = "diskCount")]
+    pub disk_count: usize,
+    #[serde(rename = "setCount")]
+    pub set_count: usize,
+    #[serde(rename = "before")]
+    pub before: Infos,
+    #[serde(rename = "after")]
+    pub after: Infos,
+    #[serde(rename = "objectSize")]
+    pub object_size: usize,
+}
diff --git a/madmin/src/lib.rs b/madmin/src/lib.rs
index fd416c42..4f8f29ed 100644
--- a/madmin/src/lib.rs
+++ b/madmin/src/lib.rs
@@ -1,6 +1,10 @@
+pub mod heal_commands;
 pub mod health;
 pub mod info_commands;
 pub mod metrics;
 pub mod net;
+pub mod service_commands;
+pub mod trace;
+pub mod utils;
 
 pub use info_commands::*;
diff --git a/madmin/src/service_commands.rs b/madmin/src/service_commands.rs
new file mode 100644
index 00000000..9db8b57d
--- /dev/null
+++ b/madmin/src/service_commands.rs
@@ -0,0 +1,103 @@
+use std::{collections::HashMap, time::Duration};
+
+use hyper::Uri;
+
+use crate::{trace::TraceType, utils::parse_duration};
+
+#[derive(Debug, Default)]
+pub struct ServiceTraceOpts {
+    s3: bool,
+    internal: bool,
+    storage: bool,
+    os: bool,
+    scanner: bool,
+    decommission: bool,
+    healing: bool,
+    batch_replication: bool,
+    batch_key_rotation: bool,
+    batch_expire: bool,
+    batch_all: bool,
+    rebalance: bool,
+    replication_resync: bool,
+    bootstrap: bool,
+    ftp: bool,
+    ilm: bool,
+    only_errors: bool,
+    threshold: Duration,
+}
+
+impl ServiceTraceOpts {
+    fn trace_types(&self) -> TraceType {
+        let mut tt = TraceType::default();
+        tt.set_if(self.s3, &TraceType::S3);
+        tt.set_if(self.internal, &TraceType::INTERNAL);
+        tt.set_if(self.storage, &TraceType::STORAGE);
+        tt.set_if(self.os, &TraceType::OS);
+        tt.set_if(self.scanner, &TraceType::SCANNER);
+        tt.set_if(self.decommission, &TraceType::DECOMMISSION);
+        tt.set_if(self.healing, &TraceType::HEALING);
+
+        if self.batch_all {
+            tt.set_if(true, &TraceType::BATCH_REPLICATION);
+            tt.set_if(true, &TraceType::BATCH_KEY_ROTATION);
+            tt.set_if(true, &TraceType::BATCH_EXPIRE);
+        } else {
+            tt.set_if(self.batch_replication, &TraceType::BATCH_REPLICATION);
+            tt.set_if(self.batch_key_rotation, &TraceType::BATCH_KEY_ROTATION);
+            tt.set_if(self.batch_expire, &TraceType::BATCH_EXPIRE);
+        }
+
+        tt.set_if(self.rebalance, &TraceType::REBALANCE);
+        tt.set_if(self.replication_resync, &TraceType::REPLICATION_RESYNC);
+        tt.set_if(self.bootstrap, &TraceType::BOOTSTRAP);
+        tt.set_if(self.ftp, &TraceType::FTP);
+        tt.set_if(self.ilm, &TraceType::ILM);
+
+        tt
+    }
+
+    pub fn parse_params(&mut self, uri: &Uri) -> Result<(), String> {
+        let query_pairs: HashMap<_, _> = uri
+            .query()
+            .unwrap_or("")
+            .split('&')
+            .filter_map(|pair| {
+                let mut split = pair.split('=');
+                let key = split.next()?.to_string();
+                let value = split.next().map(|v| v.to_string()).unwrap_or_else(|| "false".to_string());
+                Some((key, value))
+            })
+            .collect();
+
+        self.s3 = query_pairs.get("s3").map_or(false, |v| v == "true");
+        self.os = query_pairs.get("os").map_or(false, |v| v == "true");
+        self.scanner = query_pairs.get("scanner").map_or(false, |v| v == "true");
+        self.decommission = query_pairs.get("decommission").map_or(false, |v| v == "true");
+        self.healing = query_pairs.get("healing").map_or(false, |v| v == "true");
+        self.batch_replication = query_pairs.get("batch-replication").map_or(false, |v| v == "true");
+        self.batch_key_rotation = query_pairs.get("batch-keyrotation").map_or(false, |v| v == "true");
+        self.batch_expire = query_pairs.get("batch-expire").map_or(false, |v| v == "true");
+        if query_pairs.get("all").map_or(false, |v| v == "true") {
+            self.s3 = true;
+            self.internal = true;
+            self.storage = true;
+            self.os = true;
+        }
+
+        self.rebalance = query_pairs.get("rebalance").map_or(false, |v| v == "true");
+        self.storage = query_pairs.get("storage").map_or(false, |v| v == "true");
+        self.internal = query_pairs.get("internal").map_or(false, |v| v == "true");
+        self.only_errors = query_pairs.get("err").map_or(false, |v| v == "true");
+        self.replication_resync = query_pairs.get("replication-resync").map_or(false, |v| v == "true");
+        self.bootstrap = query_pairs.get("bootstrap").map_or(false, |v| v == "true");
+        self.ftp = query_pairs.get("ftp").map_or(false, |v| v == "true");
+        self.ilm = query_pairs.get("ilm").map_or(false, |v| v == "true");
+
+        if let Some(threshold) = query_pairs.get("threshold") {
+            let duration = parse_duration(threshold)?;
+            self.threshold = duration;
+        }
+
+        Ok(())
+    }
+}
diff --git a/madmin/src/trace.rs b/madmin/src/trace.rs
new file mode 100644
index 00000000..702362f8
--- /dev/null
+++ b/madmin/src/trace.rs
@@ -0,0 +1,172 @@
+use std::{collections::HashMap, time::Duration};
+
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+
+use crate::heal_commands::HealResultItem;
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct TraceType(u64);
+
+impl TraceType {
+    // 定义一些常量
+    pub const OS: TraceType = TraceType(1 << 0);
+    pub const STORAGE: TraceType = TraceType(1 << 1);
+    pub const S3: TraceType = TraceType(1 << 2);
+    pub const INTERNAL: TraceType = TraceType(1 << 3);
+    pub const SCANNER: TraceType = TraceType(1 << 4);
+    pub const DECOMMISSION: TraceType = TraceType(1 << 5);
+    pub const HEALING: TraceType = TraceType(1 << 6);
+    pub const BATCH_REPLICATION: TraceType = TraceType(1 << 7);
+    pub const BATCH_KEY_ROTATION: TraceType = TraceType(1 << 8);
+    pub const BATCH_EXPIRE: TraceType = TraceType(1 << 9);
+    pub const REBALANCE: TraceType = TraceType(1 << 10);
+    pub const REPLICATION_RESYNC: TraceType = TraceType(1 << 11);
+    pub const BOOTSTRAP: TraceType = TraceType(1 << 12);
+    pub const FTP: TraceType = TraceType(1 << 13);
+    pub const ILM: TraceType = TraceType(1 << 14);
+
+    // MetricsAll must be last.
+    pub const ALL: TraceType = TraceType((1 << 15) - 1);
+
+    pub fn new(t: u64) -> Self {
+        Self(t)
+    }
+}
+
+impl Default for TraceType {
+    fn default() -> Self {
+        Self(0)
+    }
+}
+
+impl TraceType {
+    pub fn contains(&self, x: &TraceType) -> bool {
+        (self.0 & x.0) == x.0
+    }
+
+    pub fn overlaps(&self, x: &TraceType) -> bool {
+        (self.0 & x.0) != 0
+    }
+
+    pub fn single_type(&self) -> bool {
+        todo!()
+    }
+
+    pub fn merge(&mut self, other: &TraceType) {
+        self.0 = self.0 | other.0
+    }
+
+    pub fn set_if(&mut self, b: bool, other: &TraceType) {
+        if b {
+            self.0 = self.0 | other.0
+        }
+    }
+
+    pub fn mask(&self) -> u64 {
+        self.0
+    }
+}
+
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+pub struct TraceInfo {
+    #[serde(rename = "type")]
+    trace_type: u64,
+    #[serde(rename = "nodename")]
+    node_name: String,
+    #[serde(rename = "funcname")]
+    func_name: String,
+    #[serde(rename = "time")]
+    time: DateTime<Utc>,
+    #[serde(rename = "path")]
+    path: String,
+    #[serde(rename = "dur")]
+    duration: Duration,
+    #[serde(rename = "bytes", skip_serializing_if = "Option::is_none")]
+    bytes: Option<i64>,
+    #[serde(rename = "msg", skip_serializing_if = "Option::is_none")]
+    message: Option<String>,
+    #[serde(rename = "error", skip_serializing_if = "Option::is_none")]
+    error: Option<String>,
+    #[serde(rename = "custom", skip_serializing_if = "Option::is_none")]
+    custom: Option<HashMap<String, String>>,
+    #[serde(rename = "http", skip_serializing_if = "Option::is_none")]
+    http: Option<TraceHTTPStats>,
+    #[serde(rename = "healResult", skip_serializing_if = "Option::is_none")]
+    heal_result: Option<HealResultItem>,
+}
+
+impl TraceInfo {
+    pub fn mask(&self) -> u64 {
+        TraceType::new(self.trace_type).mask()
+    }
+}
+
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+pub struct TraceInfoLegacy {
+    trace_info: TraceInfo,
+    #[serde(rename = "request")]
+    req_info: Option<TraceRequestInfo>,
+    #[serde(rename = "response")]
+    resp_info: Option<TraceResponseInfo>,
+    #[serde(rename = "stats")]
+    call_stats: Option<TraceCallStats>,
+    #[serde(rename = "storageStats")]
+    storage_stats: Option<StorageStats>,
+    #[serde(rename = "osStats")]
+    os_stats: Option<OSStats>,
+}
+
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+pub struct StorageStats {
+    path: String,
+    duration: Duration,
+}
+
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+pub struct OSStats {
+    path: String,
+    duration: Duration,
+}
+
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+pub struct TraceHTTPStats {
+    req_info: TraceRequestInfo,
+    resp_info: TraceResponseInfo,
+    call_stats: TraceCallStats,
+}
+
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+pub struct TraceCallStats {
+    input_bytes: i32,
+    output_bytes: i32,
+    latency: Duration,
+    time_to_first_byte: Duration,
+}
+
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+pub struct TraceRequestInfo {
+    time: DateTime<Utc>,
+    proto: String,
+    method: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    path: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    raw_query: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    headers: Option<HashMap<String, String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    body: Option<Vec<u8>>,
+    client: String,
+}
+
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+pub struct TraceResponseInfo {
+    time: DateTime<Utc>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    headers: Option<HashMap<String, String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    body: Option<Vec<u8>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    status_code: Option<i32>,
+}
diff --git a/madmin/src/utils.rs b/madmin/src/utils.rs
new file mode 100644
index 00000000..a25b4f66
--- /dev/null
+++ b/madmin/src/utils.rs
@@ -0,0 +1,37 @@
+use std::time::Duration;
+
+pub fn parse_duration(s: &str) -> Result<Duration, String> {
+    // Implement your own duration parsing logic here
+    // For example, you could use the humantime crate or a custom parser
+    humantime::parse_duration(s).map_err(|e| e.to_string())
+}
+
+#[cfg(test)]
+mod test {
+    use std::time::Duration;
+
+    use super::parse_duration;
+
+    #[test]
+    fn test_parse_dur() {
+        let s = String::from("3s");
+        let dur = parse_duration(&s);
+        println!("{:?}", dur);
+        assert_eq!(Ok(Duration::from_secs(3)), dur);
+
+        let s = String::from("3ms");
+        let dur = parse_duration(&s);
+        println!("{:?}", dur);
+        assert_eq!(Ok(Duration::from_millis(3)), dur);
+
+        let s = String::from("3m");
+        let dur = parse_duration(&s);
+        println!("{:?}", dur);
+        assert_eq!(Ok(Duration::from_secs(3 * 60)), dur);
+
+        let s = String::from("3h");
+        let dur = parse_duration(&s);
+        println!("{:?}", dur);
+        assert_eq!(Ok(Duration::from_secs(3 * 60 * 60)), dur);
+    }
+}
diff --git a/rustfs/src/admin/handlers.rs b/rustfs/src/admin/handlers.rs
index 14e8fd1c..297fff8f 100644
--- a/rustfs/src/admin/handlers.rs
+++ b/rustfs/src/admin/handlers.rs
@@ -15,13 +15,13 @@ use ecstore::peer::is_reserved_or_invalid_bucket;
 use ecstore::store::is_valid_object_prefix;
 use ecstore::store_api::StorageAPI;
 use ecstore::utils::path::path_join;
-use ecstore::utils::time::parse_duration;
 use ecstore::utils::xml;
 use ecstore::GLOBAL_Endpoints;
 use futures::{Stream, StreamExt};
 use http::Uri;
 use hyper::StatusCode;
 use madmin::metrics::RealtimeMetrics;
+use madmin::utils::parse_duration;
 use matchit::Params;
 use s3s::stream::{ByteStream, DynByteStream};
 use s3s::{
@@ -45,6 +45,7 @@ use tokio_stream::wrappers::ReceiverStream;
 use tracing::{error, info, warn};
 
 pub mod service_account;
+pub mod trace;
 
 #[derive(Deserialize, Debug, Default)]
 #[serde(rename_all = "PascalCase", default)]
@@ -370,8 +371,8 @@ impl Operation for MetricsHandler {
         info!("mp: {:?}", mp);
 
         let tick = match parse_duration(&mp.tick) {
-            Some(i) => i,
-            None => std_Duration::from_secs(1),
+            Ok(i) => i,
+            Err(_) => std_Duration::from_secs(1),
         };
 
         let mut n = mp.n;
diff --git a/rustfs/src/admin/handlers/trace.rs b/rustfs/src/admin/handlers/trace.rs
new file mode 100644
index 00000000..0134c4fd
--- /dev/null
+++ b/rustfs/src/admin/handlers/trace.rs
@@ -0,0 +1,36 @@
+use ecstore::{peer_rest_client::PeerRestClient, GLOBAL_Endpoints};
+use http::StatusCode;
+use hyper::Uri;
+use madmin::service_commands::ServiceTraceOpts;
+use matchit::Params;
+use s3s::{s3_error, Body, S3Request, S3Response, S3Result};
+use tracing::warn;
+
+use crate::admin::router::Operation;
+
+fn extract_trace_options(uri: &Uri) -> S3Result<ServiceTraceOpts> {
+    let mut st_opts = ServiceTraceOpts::default();
+    st_opts
+        .parse_params(uri)
+        .map_err(|_| s3_error!(InvalidRequest, "invalid params"))?;
+
+    Ok(st_opts)
+}
+
+pub struct Trace {}
+
+#[async_trait::async_trait]
+impl Operation for Trace {
+    async fn call(&self, req: S3Request<Body>, _params: Params<'_, '_>) -> S3Result<S3Response<(StatusCode, Body)>> {
+        warn!("handle Trace");
+
+        let _trace_opts = extract_trace_options(&req.uri)?;
+
+        // let (tx, rx) = mpsc::channel(10000);
+        let _perrs = match GLOBAL_Endpoints.get() {
+            Some(ep) => PeerRestClient::new_clients(ep.clone()).await,
+            None => (Vec::new(), Vec::new()),
+        };
+        return Err(s3_error!(NotImplemented));
+    }
+}
diff --git a/rustfs/src/grpc.rs b/rustfs/src/grpc.rs
index 25c3391d..881b11c6 100644
--- a/rustfs/src/grpc.rs
+++ b/rustfs/src/grpc.rs
@@ -1349,7 +1349,7 @@ impl Node for NodeService {
                                 }
                             }
                         });
-                        let data_usage_cache = disk.ns_scanner(&cache, updates_tx, request.scan_mode as usize).await;
+                        let data_usage_cache = disk.ns_scanner(&cache, updates_tx, request.scan_mode as usize, None).await;
                         let _ = task.await;
                         match data_usage_cache {
                             Ok(data_usage_cache) => {