From fac0feeeaab156929599155907839f1d91c1e1ac Mon Sep 17 00:00:00 2001
From: junxiang Mu <1948535941@qq.com>
Date: Tue, 17 Dec 2024 15:51:46 +0800
Subject: [PATCH] add down object heal

Signed-off-by: junxiang Mu <1948535941@qq.com>
---
 .../generated/flatbuffers_generated/models.rs |  207 +-
 .../src/generated/proto_gen/node_service.rs   | 3832 +++++++++++++----
 ecstore/src/erasure.rs                        |   25 +-
 ecstore/src/global.rs                         |    2 +
 ecstore/src/heal/background_heal_ops.rs       |   43 +-
 ecstore/src/heal/mod.rs                       |    1 +
 ecstore/src/heal/mrf.rs                       |  124 +
 ecstore/src/set_disk.rs                       |   72 +-
 ecstore/src/store.rs                          |    2 +
 iam/src/policy/action.rs                      |    2 +-
 10 files changed, 3406 insertions(+), 904 deletions(-)
 create mode 100644 ecstore/src/heal/mrf.rs

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 58aaa10f..9e372e5f 100644
--- a/common/protos/src/generated/proto_gen/node_service.rs
+++ b/common/protos/src/generated/proto_gen/node_service.rs
@@ -622,7 +622,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 {
@@ -786,7 +789,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>,
 }
@@ -1053,9 +1059,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>,
@@ -1086,16 +1098,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))
         }
@@ -1138,9 +1156,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"));
@@ -1149,13 +1173,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"));
@@ -1164,13 +1197,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"));
@@ -1179,13 +1221,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"));
@@ -1194,13 +1245,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"));
@@ -1209,13 +1269,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"));
@@ -1224,13 +1293,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"));
@@ -1239,13 +1317,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"));
@@ -1258,9 +1345,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"));
@@ -1269,13 +1362,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"));
@@ -1284,13 +1386,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"));
@@ -1299,13 +1410,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"));
@@ -1314,13 +1434,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"));
@@ -1333,9 +1462,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"));
@@ -1344,13 +1479,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"));
@@ -1360,13 +1504,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"));
@@ -1375,13 +1528,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"));
@@ -1390,13 +1552,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"));
@@ -1405,13 +1576,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"));
@@ -1420,13 +1600,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"));
@@ -1435,13 +1624,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"));
@@ -1450,13 +1648,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"));
@@ -1465,13 +1672,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"));
@@ -1480,13 +1696,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"));
@@ -1495,13 +1720,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"));
@@ -1510,13 +1744,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"));
@@ -1525,13 +1768,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"));
@@ -1544,9 +1796,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"));
@@ -1555,13 +1813,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"));
@@ -1570,13 +1837,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"));
@@ -1585,13 +1861,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"));
@@ -1600,13 +1885,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"));
@@ -1615,13 +1909,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"));
@@ -1630,13 +1933,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"));
@@ -1645,13 +1957,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"));
@@ -1660,13 +1981,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"));
@@ -1675,13 +2005,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"));
@@ -1690,13 +2029,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"));
@@ -1705,13 +2053,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"));
@@ -1720,13 +2077,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"));
@@ -1735,13 +2101,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"));
@@ -1750,13 +2125,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"));
@@ -1765,13 +2149,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"));
@@ -1780,13 +2173,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"));
@@ -1795,13 +2197,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"));
@@ -1810,13 +2221,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"));
@@ -1825,13 +2245,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"));
@@ -1840,13 +2269,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"));
@@ -1855,13 +2293,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"));
@@ -1870,13 +2317,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"));
@@ -1885,13 +2341,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"));
@@ -1900,13 +2365,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"));
@@ -1915,13 +2389,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"));
@@ -1930,28 +2413,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"));
@@ -1960,13 +2463,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"));
@@ -1975,58 +2487,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"));
@@ -2035,13 +2589,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"));
@@ -2050,28 +2613,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"));
@@ -2080,28 +2663,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"));
@@ -2110,28 +2713,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"));
@@ -2140,16 +2763,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 () {};
@@ -2157,13 +2794,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"));
@@ -2172,58 +2818,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"));
@@ -2232,13 +2920,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"));
@@ -2247,38 +2944,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]
@@ -2291,23 +3019,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>,
@@ -2315,7 +3058,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>,
@@ -2323,33 +3069,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) {};
@@ -2368,39 +3133,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>,
@@ -2408,25 +3200,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(
@@ -2436,35 +3245,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>,
@@ -2472,137 +3305,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> {
@@ -2625,7 +3557,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,
         {
@@ -2669,7 +3604,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 {
@@ -2677,12 +3615,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)
                         }
                     }
@@ -2695,8 +3642,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)
                     };
@@ -2705,12 +3658,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)
                         }
                     }
@@ -2723,8 +3687,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)
                     };
@@ -2733,12 +3703,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)
                         }
                     }
@@ -2751,8 +3732,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)
                     };
@@ -2761,12 +3748,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)
                         }
                     }
@@ -2779,8 +3777,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)
                     };
@@ -2789,12 +3793,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)
                         }
                     }
@@ -2807,8 +3822,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)
                     };
@@ -2817,12 +3838,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)
                         }
                     }
@@ -2835,8 +3867,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)
                     };
@@ -2845,12 +3883,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)
                         }
                     }
@@ -2863,8 +3912,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)
                     };
@@ -2873,12 +3928,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)
                         }
                     }
@@ -2891,8 +3957,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)
                     };
@@ -2901,12 +3973,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)
                         }
                     }
@@ -2919,8 +4002,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)
                     };
@@ -2929,12 +4018,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)
                         }
                     }
@@ -2947,8 +4047,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)
                     };
@@ -2957,12 +4063,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)
                         }
                     }
@@ -2975,8 +4092,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)
                     };
@@ -2985,12 +4108,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)
                         }
                     }
@@ -3003,8 +4137,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)
                     };
@@ -3013,12 +4153,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)
                         }
                     }
@@ -3031,8 +4182,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)
                     };
@@ -3041,12 +4198,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)
                         }
                     }
@@ -3059,8 +4225,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)
                     };
@@ -3069,13 +4241,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)
                         }
                     }
@@ -3088,8 +4273,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)
                     };
@@ -3098,13 +4289,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)
                         }
                     }
@@ -3117,8 +4321,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)
                     };
@@ -3127,12 +4337,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)
                         }
                     }
@@ -3145,8 +4366,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)
                     };
@@ -3155,12 +4382,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)
                         }
                     }
@@ -3173,8 +4411,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)
                     };
@@ -3183,12 +4427,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)
                         }
                     }
@@ -3201,8 +4456,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)
                     };
@@ -3211,12 +4472,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)
                         }
                     }
@@ -3229,8 +4501,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)
                     };
@@ -3239,12 +4517,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)
                         }
                     }
@@ -3257,8 +4546,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)
                     };
@@ -3267,12 +4562,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)
                         }
                     }
@@ -3285,8 +4591,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)
                     };
@@ -3295,12 +4607,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)
                         }
                     }
@@ -3313,8 +4636,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)
                     };
@@ -3323,12 +4652,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)
                         }
                     }
@@ -3341,8 +4681,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)
                     };
@@ -3351,12 +4697,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)
                         }
                     }
@@ -3369,8 +4726,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)
                     };
@@ -3379,12 +4742,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)
                         }
                     }
@@ -3397,8 +4771,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)
                     };
@@ -3407,12 +4787,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)
                         }
                     }
@@ -3425,8 +4816,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)
                     };
@@ -3435,12 +4832,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)
                         }
                     }
@@ -3453,8 +4861,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)
                     };
@@ -3463,12 +4877,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)
                         }
                     }
@@ -3481,8 +4906,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)
                     };
@@ -3491,12 +4922,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)
                         }
                     }
@@ -3509,8 +4951,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)
                     };
@@ -3519,12 +4967,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)
                         }
                     }
@@ -3537,8 +4996,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)
                     };
@@ -3547,12 +5012,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)
                         }
                     }
@@ -3565,8 +5041,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)
                     };
@@ -3575,12 +5057,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)
                         }
                     }
@@ -3593,8 +5086,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)
                     };
@@ -3603,13 +5102,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)
                         }
                     }
@@ -3622,8 +5134,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)
                     };
@@ -3632,12 +5150,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)
                         }
                     }
@@ -3650,8 +5179,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)
                     };
@@ -3660,12 +5195,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)
                         }
                     }
@@ -3678,8 +5224,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)
                     };
@@ -3688,12 +5240,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)
                         }
                     }
@@ -3706,8 +5269,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)
                     };
@@ -3716,12 +5285,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)
                         }
                     }
@@ -3734,8 +5314,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)
                     };
@@ -3744,12 +5330,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)
                         }
                     }
@@ -3762,8 +5359,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)
                     };
@@ -3772,12 +5375,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)
                         }
                     }
@@ -3790,8 +5404,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)
                     };
@@ -3800,12 +5420,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)
                         }
                     }
@@ -3818,8 +5450,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)
                     };
@@ -3828,12 +5466,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)
                         }
                     }
@@ -3846,8 +5495,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)
                     };
@@ -3856,12 +5511,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)
                         }
                     }
@@ -3874,8 +5540,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)
                     };
@@ -3884,12 +5556,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)
                         }
                     }
@@ -3902,8 +5585,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)
                     };
@@ -3912,12 +5601,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)
                         }
                     }
@@ -3930,8 +5630,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)
                     };
@@ -3940,12 +5646,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)
                         }
                     }
@@ -3958,8 +5675,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)
                     };
@@ -3968,12 +5691,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)
                         }
                     }
@@ -3986,8 +5720,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)
                     };
@@ -3996,12 +5736,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)
                         }
                     }
@@ -4014,8 +5765,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)
                     };
@@ -4024,12 +5781,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)
                         }
                     }
@@ -4042,8 +5810,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)
                     };
@@ -4052,12 +5826,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)
                         }
                     }
@@ -4070,8 +5855,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)
                     };
@@ -4080,12 +5871,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)
                         }
                     }
@@ -4098,8 +5900,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)
                     };
@@ -4108,12 +5916,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)
                         }
                     }
@@ -4126,8 +5945,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)
                     };
@@ -4136,12 +5961,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)
                         }
                     }
@@ -4154,8 +5990,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)
                     };
@@ -4164,12 +6006,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)
                         }
                     }
@@ -4182,8 +6036,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)
                     };
@@ -4192,12 +6052,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)
                         }
                     }
@@ -4210,8 +6081,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)
                     };
@@ -4220,12 +6097,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)
                         }
                     }
@@ -4238,8 +6126,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)
                     };
@@ -4248,12 +6142,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)
                         }
                     }
@@ -4266,8 +6172,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)
                     };
@@ -4276,12 +6188,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)
                         }
                     }
@@ -4294,8 +6218,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)
                     };
@@ -4304,12 +6234,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)
                         }
                     }
@@ -4322,8 +6264,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)
                     };
@@ -4332,12 +6280,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)
                         }
                     }
@@ -4350,8 +6309,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)
                     };
@@ -4360,12 +6325,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)
                         }
                     }
@@ -4378,8 +6354,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)
                     };
@@ -4388,12 +6370,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)
                         }
                     }
@@ -4406,8 +6400,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)
                     };
@@ -4416,12 +6416,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)
                         }
                     }
@@ -4434,8 +6445,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)
                     };
@@ -4444,12 +6461,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)
                         }
                     }
@@ -4462,8 +6491,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)
                     };
@@ -4472,12 +6507,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)
                         }
                     }
@@ -4490,8 +6536,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)
                     };
@@ -4500,12 +6552,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)
                         }
                     }
@@ -4518,8 +6582,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)
                     };
@@ -4528,12 +6598,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)
                         }
                     }
@@ -4546,8 +6627,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)
                     };
@@ -4556,14 +6643,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)
                         }
                     }
@@ -4576,8 +6679,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)
                     };
@@ -4586,12 +6695,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)
                         }
                     }
@@ -4604,8 +6724,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)
                     };
@@ -4614,12 +6740,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)
                         }
                     }
@@ -4632,8 +6770,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)
                     };
@@ -4642,12 +6786,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)
                         }
                     }
@@ -4660,8 +6816,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)
                     };
@@ -4670,12 +6832,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)
                         }
                     }
@@ -4688,8 +6865,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)
                     };
@@ -4698,12 +6881,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)
                         }
                     }
@@ -4716,8 +6910,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)
                     };
@@ -4726,12 +6926,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)
                         }
                     }
@@ -4744,8 +6955,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)
                     };
@@ -4754,12 +6971,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)
                         }
                     }
@@ -4772,8 +7001,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)
                     };
@@ -4782,12 +7017,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)
                         }
                     }
@@ -4800,20 +7052,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/erasure.rs b/ecstore/src/erasure.rs
index 02ca900b..6ca7a25d 100644
--- a/ecstore/src/erasure.rs
+++ b/ecstore/src/erasure.rs
@@ -212,9 +212,9 @@ impl Erasure {
         offset: usize,
         length: usize,
         total_length: usize,
-    ) -> Result<usize> {
+    ) -> (usize, Option<Error>) {
         if length == 0 {
-            return Ok(0);
+            return (0, None);
         }
 
         let mut reader = ShardReader::new(readers, self, offset, total_length);
@@ -247,15 +247,24 @@ impl Erasure {
 
             // debug!("decode {} block_offset {},block_length {} ", block_idx, block_offset, block_length);
 
-            let mut bufs = reader.read().await?;
+            let mut bufs = match reader.read().await {
+                Ok(bufs) => bufs,
+                Err(err) => return (bytes_writed, Some(err)),
+            };
 
             if self.parity_shards > 0 {
-                self.decode_data(&mut bufs)?;
+                if let Err(err) = self.decode_data(&mut bufs) {
+                    return (bytes_writed, Some(err));
+                }
             }
 
-            let writed_n = self
+            let writed_n = match self
                 .write_data_blocks(writer, bufs, self.data_shards, block_offset, block_length)
-                .await?;
+                .await
+            {
+                Ok(n) => n,
+                Err(err) => return (bytes_writed, Some(err)),
+            };
 
             bytes_writed += writed_n;
 
@@ -264,10 +273,10 @@ impl Erasure {
 
         if bytes_writed != length {
             // debug!("bytes_writed != length: {} != {} ", bytes_writed, length);
-            return Err(Error::msg("erasure decode less data"));
+            return (bytes_writed, Some(Error::msg("erasure decode less data")));
         }
 
-        Ok(bytes_writed)
+        (bytes_writed, None)
     }
 
     async fn write_data_blocks(
diff --git a/ecstore/src/global.rs b/ecstore/src/global.rs
index f5a817c4..65012804 100644
--- a/ecstore/src/global.rs
+++ b/ecstore/src/global.rs
@@ -6,6 +6,7 @@ use std::{
 use tokio::sync::RwLock;
 use uuid::Uuid;
 
+use crate::heal::mrf::MRFState;
 use crate::{
     disk::DiskStore,
     endpoints::{EndpointServerPools, PoolEndpoints, SetupType},
@@ -34,6 +35,7 @@ lazy_static! {
     pub static ref GLOBAL_BackgroundHealRoutine: Arc<HealRoutine> = HealRoutine::new();
     pub static ref GLOBAL_BackgroundHealState: Arc<AllHealState> = AllHealState::new(false);
     pub static ref GLOBAL_ALlHealState: Arc<AllHealState> = AllHealState::new(false);
+    pub static ref GLOBAL_MRFState: Arc<MRFState> = Arc::new(MRFState::new());
     static ref globalDeploymentIDPtr: RwLock<Uuid> = RwLock::new(Uuid::nil());
 }
 
diff --git a/ecstore/src/heal/background_heal_ops.rs b/ecstore/src/heal/background_heal_ops.rs
index 4e49d7f5..033432ea 100644
--- a/ecstore/src/heal/background_heal_ops.rs
+++ b/ecstore/src/heal/background_heal_ops.rs
@@ -1,6 +1,7 @@
 use madmin::heal_commands::HealResultItem;
 use std::{cmp::Ordering, env, path::PathBuf, sync::Arc, time::Duration};
 use tokio::{
+    spawn,
     sync::{
         mpsc::{self, Receiver, Sender},
         RwLock,
@@ -14,7 +15,10 @@ use super::{
     heal_commands::HealOpts,
     heal_ops::{new_bg_heal_sequence, HealSequence},
 };
+use crate::global::GLOBAL_MRFState;
 use crate::heal::error::ERR_RETRY_HEALING;
+use crate::heal::heal_commands::{HealScanMode, HEAL_ITEM_BUCKET};
+use crate::heal::heal_ops::{HealSource, BG_HEALING_UUID};
 use crate::{
     config::RUSTFS_CONFIG_PREFIX,
     disk::{endpoint::Endpoint, error::DiskError, DiskAPI, DiskInfoOptions, BUCKET_META_PREFIX, RUSTFS_META_BUCKET},
@@ -42,18 +46,21 @@ pub async fn init_auto_heal() {
             GLOBAL_BackgroundHealState
                 .push_heal_local_disks(&get_local_disks_to_heal().await)
                 .await;
-            tokio::spawn(async {
+            spawn(async {
                 monitor_local_disks_and_heal().await;
             });
         }
     }
+    spawn(async {
+        GLOBAL_MRFState.heal_routine().await;
+    });
 }
 
 async fn init_background_healing() {
     let bg_seq = Arc::new(new_bg_heal_sequence());
     for _ in 0..GLOBAL_BackgroundHealRoutine.workers {
         let bg_seq_clone = bg_seq.clone();
-        tokio::spawn(async {
+        spawn(async {
             GLOBAL_BackgroundHealRoutine.add_worker(bg_seq_clone).await;
         });
     }
@@ -92,13 +99,14 @@ async fn monitor_local_disks_and_heal() {
         interval.tick().await;
         let heal_disks = GLOBAL_BackgroundHealState.get_heal_local_disk_endpoints().await;
         if heal_disks.is_empty() {
+            info!("heal local disks is empty");
             interval.reset();
             continue;
         }
 
         let store = new_object_layer_fn().expect("errServerNotInitialized");
         if let (_, Some(err)) = store.heal_format(false).await.expect("heal format failed") {
-            if let Some(DiskError::NoHealRequired) = err.downcast_ref() {
+            if let Some(DiskError::NoHealRequired) = err.downcast_ref::<DiskError>() {
             } else {
                 info!("heal format err: {}", err.to_string());
                 interval.reset();
@@ -108,7 +116,7 @@ async fn monitor_local_disks_and_heal() {
 
         for disk in heal_disks.into_ref().iter() {
             let disk_clone = disk.clone();
-            tokio::spawn(async move {
+            spawn(async move {
                 GLOBAL_BackgroundHealState
                     .set_disk_healing_status(disk_clone.clone(), true)
                     .await;
@@ -420,3 +428,30 @@ async fn heal_disk_format(opts: HealOpts) -> Result<(HealResultItem, Option<Erro
     }
     Ok((res, err))
 }
+
+pub(crate) async fn heal_bucket(bucket: &str) -> Result<()> {
+    let (bg_seq, ok) = GLOBAL_BackgroundHealState.get_heal_sequence_by_token(BG_HEALING_UUID).await;
+    if ok {
+        // bg_seq must be Some when ok is true
+        return bg_seq
+            .unwrap()
+            .queue_heal_task(
+                HealSource {
+                    bucket: bucket.to_string(),
+                    ..Default::default()
+                },
+                HEAL_ITEM_BUCKET.to_string(),
+            )
+            .await;
+    }
+    Ok(())
+}
+
+pub(crate) async fn heal_object(bucket: &str, object: &str, version_id: &str, scan_mode: HealScanMode) -> Result<()> {
+    let (bg_seq, ok) = GLOBAL_BackgroundHealState.get_heal_sequence_by_token(BG_HEALING_UUID).await;
+    if ok {
+        // bg_seq must be Some when ok is true
+        return HealSequence::heal_object(bg_seq.unwrap(), bucket, object, version_id, scan_mode).await;
+    }
+    Ok(())
+}
diff --git a/ecstore/src/heal/mod.rs b/ecstore/src/heal/mod.rs
index f4a8e486..47e00086 100644
--- a/ecstore/src/heal/mod.rs
+++ b/ecstore/src/heal/mod.rs
@@ -6,3 +6,4 @@ pub mod data_usage_cache;
 pub mod error;
 pub mod heal_commands;
 pub mod heal_ops;
+pub mod mrf;
diff --git a/ecstore/src/heal/mrf.rs b/ecstore/src/heal/mrf.rs
new file mode 100644
index 00000000..c2375abf
--- /dev/null
+++ b/ecstore/src/heal/mrf.rs
@@ -0,0 +1,124 @@
+use crate::disk::{BUCKET_META_PREFIX, RUSTFS_META_BUCKET};
+use crate::heal::background_heal_ops::{heal_bucket, heal_object};
+use crate::heal::heal_commands::{HEAL_DEEP_SCAN, HEAL_NORMAL_SCAN};
+use crate::utils::path::SLASH_SEPARATOR;
+use chrono::{DateTime, TimeDelta, Utc};
+use lazy_static::lazy_static;
+use regex::Regex;
+use std::ops::Sub;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::time::Duration;
+use tokio::sync::mpsc::{Receiver, Sender};
+use tokio::sync::RwLock;
+use tokio::time::sleep;
+use tracing::error;
+use uuid::Uuid;
+
+pub const MRF_OPS_QUEUE_SIZE: u64 = 100000;
+pub const HEAL_DIR: &'static str = ".heal";
+pub const HEAL_MRFMETA_FORMAT: u64 = 1;
+pub const HEAL_MRFMETA_VERSION_V1: u64 = 1;
+
+lazy_static! {
+    pub static ref HEAL_MRF_DIR: String =
+        format!("{}{}{}{}{}", BUCKET_META_PREFIX, SLASH_SEPARATOR, HEAL_DIR, SLASH_SEPARATOR, "mrf");
+    static ref PATTERNS: Vec<Regex> = vec![
+        Regex::new(r"^buckets/.*/.metacache/.*").unwrap(),
+        Regex::new(r"^tmp/.*").unwrap(),
+        Regex::new(r"^multipart/.*").unwrap(),
+        Regex::new(r"^tmp-old/.*").unwrap(),
+    ];
+}
+
+#[derive(Default)]
+pub struct PartialOperation {
+    pub bucket: String,
+    pub object: String,
+    pub version_id: Option<String>,
+    pub versions: Vec<u8>,
+    pub set_index: usize,
+    pub pool_index: usize,
+    pub queued: DateTime<Utc>,
+    pub bitrot_scan: bool,
+}
+
+pub struct MRFState {
+    tx: Sender<PartialOperation>,
+    rx: RwLock<Receiver<PartialOperation>>,
+    closed: AtomicBool,
+    closing: AtomicBool,
+}
+
+impl MRFState {
+    pub fn new() -> MRFState {
+        let (tx, rx) = tokio::sync::mpsc::channel(MRF_OPS_QUEUE_SIZE as usize);
+        MRFState {
+            tx,
+            rx: RwLock::new(rx),
+            closed: Default::default(),
+            closing: Default::default(),
+        }
+    }
+
+    pub async fn add_partial(&self, op: PartialOperation) {
+        if self.closed.load(Ordering::SeqCst) || self.closing.load(Ordering::SeqCst) {
+            return;
+        }
+        let _ = self.tx.send(op).await;
+    }
+
+    pub async fn heal_routine(&self) {
+        loop {
+            // rx used only there,
+            if let Some(op) = self.rx.write().await.recv().await {
+                if op.bucket == RUSTFS_META_BUCKET {
+                    for pattern in &*PATTERNS {
+                        if pattern.is_match(&op.object) {
+                            return;
+                        }
+                    }
+                }
+
+                let now = Utc::now();
+                if now.sub(op.queued).num_seconds() < 1 {
+                    sleep(Duration::from_secs(1)).await;
+                }
+
+                let scan_mode = if op.bitrot_scan { HEAL_DEEP_SCAN } else { HEAL_NORMAL_SCAN };
+                if op.object.is_empty() {
+                    if let Err(err) = heal_bucket(&op.bucket).await {
+                        error!("heal bucket failed, bucket: {}, err: {:?}", op.bucket, err);
+                    }
+                } else {
+                    if op.versions.is_empty() {
+                        if let Err(err) =
+                            heal_object(&op.bucket, &op.object, &op.version_id.clone().unwrap_or_default(), scan_mode).await
+                        {
+                            error!("heal object failed, bucket: {}, object: {}, err: {:?}", op.bucket, op.object, err);
+                        }
+                    } else {
+                        let vers = op.versions.len() / 16;
+                        if vers > 0 {
+                            for i in 0..vers {
+                                let start = i * 16;
+                                let end = start + 16;
+                                if let Err(err) = heal_object(
+                                    &op.bucket,
+                                    &op.object,
+                                    &Uuid::from_slice(&op.versions[start..end]).expect("").to_string(),
+                                    scan_mode,
+                                )
+                                .await
+                                {
+                                    error!("heal object failed, bucket: {}, object: {}, err: {:?}", op.bucket, op.object, err);
+                                }
+                            }
+                        }
+                    }
+                }
+            } else {
+                return;
+            }
+        }
+    }
+}
diff --git a/ecstore/src/set_disk.rs b/ecstore/src/set_disk.rs
index 4bbc64c0..8e5b1f35 100644
--- a/ecstore/src/set_disk.rs
+++ b/ecstore/src/set_disk.rs
@@ -6,7 +6,10 @@ use std::{
     time::Duration,
 };
 
+use crate::config::error::is_not_found;
+use crate::global::GLOBAL_MRFState;
 use crate::heal::heal_ops::{HealEntryFn, HealSequence};
+use crate::heal::mrf::PartialOperation;
 use crate::{
     bitrot::{bitrot_verify, close_bitrot_writers, new_bitrot_filereader, new_bitrot_filewriter, BitrotFileWriter},
     cache_value::metacache_set::{list_path_raw, ListPathRawOptions},
@@ -56,6 +59,7 @@ use crate::{
     heal::data_scanner::{globalHealConfig, HEAL_DELETE_DANGLING},
     store_api::ListObjectVersionsInfo,
 };
+use chrono::Utc;
 use futures::future::join_all;
 use glob::Pattern;
 use http::HeaderMap;
@@ -1621,6 +1625,19 @@ impl SetDisks {
         let (op_online_disks, mot_time, etag) = Self::list_online_disks(&disks, &parts_metadata, &errs, read_quorum as usize);
 
         let fi = Self::pick_valid_fileinfo(&parts_metadata, mot_time, etag, read_quorum as usize)?;
+        if errs.iter().any(|err| err.is_some()) {
+            GLOBAL_MRFState
+                .add_partial(PartialOperation {
+                    bucket: fi.volume.to_string(),
+                    object: fi.name.to_string(),
+                    queued: Utc::now(),
+                    version_id: fi.version_id.map(|v| v.to_string()),
+                    set_index: self.set_index,
+                    pool_index: self.pool_index,
+                    ..Default::default()
+                })
+                .await;
+        }
         // debug!("get_object_fileinfo pick fi {:?}", &fi);
 
         // let online_disks: Vec<Option<DiskStore>> = op_online_disks.iter().filter(|v| v.is_some()).cloned().collect();
@@ -1639,6 +1656,8 @@ impl SetDisks {
         fi: FileInfo,
         files: Vec<FileInfo>,
         disks: &[Option<DiskStore>],
+        set_index: usize,
+        pool_index: usize,
     ) -> Result<()> {
         let (disks, files) = Self::shuffle_disks_and_parts_metadata_by_index(disks, &files, &fi);
 
@@ -1724,10 +1743,34 @@ impl SetDisks {
             //     "read part {} part_offset {},part_length {},part_size {}  ",
             //     part_number, part_offset, part_length, part_size
             // );
-            let _n = erasure
+            let (written, mut err) = erasure
                 .decode(writer, readers, part_offset as usize, part_length, part_size)
-                .await?;
-
+                .await;
+            if let Some(e) = err.as_ref() {
+                if written == part_length {
+                    match e.downcast_ref::<DiskError>() {
+                        Some(DiskError::FileNotFound) | Some(DiskError::FileCorrupt) => {
+                            GLOBAL_MRFState
+                                .add_partial(PartialOperation {
+                                    bucket: bucket.to_string(),
+                                    object: object.to_string(),
+                                    queued: Utc::now(),
+                                    version_id: fi.version_id.map(|v| v.to_string()),
+                                    set_index,
+                                    pool_index,
+                                    bitrot_scan: !is_not_found(e),
+                                    ..Default::default()
+                                })
+                                .await;
+                            err = None;
+                        }
+                        _ => {}
+                    }
+                }
+            }
+            if let Some(err) = err {
+                return Err(err);
+            }
             // debug!("ec decode {} writed size {}", part_number, n);
 
             total_readed += part_length as i64;
@@ -3378,8 +3421,14 @@ impl ObjectIO for SetDisks {
         // let disks = disks.clone();
         let bucket = String::from(bucket);
         let object = String::from(object);
+        let set_index = self.set_index.clone();
+        let pool_index = self.pool_index.clone();
         tokio::spawn(async move {
-            if let Err(e) = Self::get_object_with_fileinfo(&bucket, &object, offset, length, &mut wd, fi, files, &disks).await {
+            if let Err(e) = Self::get_object_with_fileinfo(
+                &bucket, &object, offset, length, &mut wd, fi, files, &disks, set_index, pool_index,
+            )
+            .await
+            {
                 error!("get_object_with_fileinfo err {:?}", e);
             };
         });
@@ -4438,7 +4487,7 @@ impl StorageAPI for SetDisks {
             }
         }
 
-        let (online_disks, _, op_old_dir) = Self::rename_data(
+        let (online_disks, versions, op_old_dir) = Self::rename_data(
             &shuffle_disks,
             RUSTFS_META_MULTIPART_BUCKET,
             &upload_id_path,
@@ -4467,6 +4516,19 @@ impl StorageAPI for SetDisks {
             self.commit_rename_data_dir(&shuffle_disks, bucket, object, &old_dir.to_string(), write_quorum)
                 .await?;
         }
+        if let Some(versions) = versions {
+            GLOBAL_MRFState
+                .add_partial(PartialOperation {
+                    bucket: bucket.to_string(),
+                    object: object.to_string(),
+                    queued: Utc::now(),
+                    versions,
+                    set_index: self.set_index,
+                    pool_index: self.pool_index,
+                    ..Default::default()
+                })
+                .await;
+        }
 
         let _ = self.delete_all(RUSTFS_META_MULTIPART_BUCKET, &upload_id_path).await;
 
diff --git a/ecstore/src/store.rs b/ecstore/src/store.rs
index a09cc7f3..01d70086 100644
--- a/ecstore/src/store.rs
+++ b/ecstore/src/store.rs
@@ -671,8 +671,10 @@ impl ECStore {
         want_cycle: usize,
         heal_scan_mode: HealScanMode,
     ) -> Result<()> {
+        info!("ns_scanner updates - {}", want_cycle);
         let all_buckets = self.list_bucket(&BucketOptions::default()).await?;
         if all_buckets.is_empty() {
+            info!("No buckets found");
             let _ = updates.send(DataUsageInfo::default()).await;
             return Ok(());
         }
diff --git a/iam/src/policy/action.rs b/iam/src/policy/action.rs
index 0ae53c3b..24e2d135 100644
--- a/iam/src/policy/action.rs
+++ b/iam/src/policy/action.rs
@@ -56,7 +56,7 @@ impl Action {
 }
 
 impl Action {
-    const S3_PREFIX: &str = "s3:";
+    const S3_PREFIX: &'static str = "s3:";
     const ADMIN_PREFIX: &str = "admin:";
     const STS_PREFIX: &str = "sts:";
     const KMS_PREFIX: &str = "kms:";