diff --git a/Cargo.lock b/Cargo.lock
index 0b4fae4b..2ba596d6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -183,9 +183,19 @@ name = "api"
 version = "0.0.1"
 dependencies = [
  "async-trait",
+ "bytes",
+ "chrono",
  "datafusion",
+ "ecstore",
  "futures",
+ "futures-core",
+ "http",
+ "object_store",
+ "s3s",
  "snafu",
+ "tokio",
+ "tracing",
+ "url",
 ]
 
 [[package]]
@@ -5711,7 +5721,7 @@ dependencies = [
  "crypto",
  "futures",
  "ipnetwork",
- "itertools",
+ "itertools 0.14.0",
  "jsonwebtoken",
  "lazy_static",
  "log",
@@ -5989,9 +5999,14 @@ name = "query"
 version = "0.0.1"
 dependencies = [
  "api",
+ "async-recursion",
  "async-trait",
  "datafusion",
  "derive_builder",
+ "futures",
+ "parking_lot 0.12.3",
+ "s3s",
+ "snafu",
  "tokio",
  "tracing",
 ]
@@ -6190,22 +6205,6 @@ version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
 
-[[package]]
-name = "reader"
-version = "0.0.1"
-dependencies = [
- "bytes",
- "futures",
- "hex-simd",
- "md-5",
- "pin-project-lite",
- "s3s",
- "sha2 0.11.0-pre.4",
- "thiserror 2.0.11",
- "tokio",
- "tracing",
-]
-
 [[package]]
 name = "recursive"
 version = "0.1.1"
@@ -6524,6 +6523,7 @@ dependencies = [
 name = "rustfs"
 version = "0.1.0"
 dependencies = [
+ "api",
  "async-trait",
  "atoi",
  "axum",
@@ -6533,6 +6533,8 @@ dependencies = [
  "common",
  "const-str",
  "crypto",
+ "csv",
+ "datafusion",
  "ecstore",
  "flatbuffers",
  "futures",
@@ -6560,6 +6562,7 @@ dependencies = [
  "prost-types",
  "protobuf",
  "protos",
+ "query",
  "rmp-serde",
  "rust-embed",
  "s3s",
diff --git a/Cargo.toml b/Cargo.toml
index e581661c..28d28347 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -31,6 +31,7 @@ all = "warn"
 
 [workspace.dependencies]
 madmin = { path = "./madmin" }
+async-recursion = "1.0.5"
 async-trait = "0.1.86"
 backon = "1.3.0"
 bytes = "1.9.0"
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 000d5b48..88f7b3ab 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<tonic::codec::Streaming<super::WalkDirResponse>>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<tonic::codec::Streaming<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) {};
@@ -2362,7 +3127,9 @@ pub mod node_service_server {
             request: tonic::Request<super::ListDirRequest>,
         ) -> std::result::Result<tonic::Response<super::ListDirResponse>, tonic::Status>;
         /// Server streaming response type for the WalkDir method.
-        type WalkDirStream: tonic::codegen::tokio_stream::Stream<Item = std::result::Result<super::WalkDirResponse, tonic::Status>>
+        type WalkDirStream: tonic::codegen::tokio_stream::Stream<
+                Item = std::result::Result<super::WalkDirResponse, tonic::Status>,
+            >
             + std::marker::Send
             + 'static;
         async fn walk_dir(
@@ -2372,39 +3139,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>,
@@ -2412,25 +3206,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(
@@ -2440,35 +3251,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>,
@@ -2476,137 +3311,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> {
@@ -2629,7 +3563,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,
         {
@@ -2673,7 +3610,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 {
@@ -2681,12 +3621,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)
                         }
                     }
@@ -2699,8 +3648,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)
                     };
@@ -2709,12 +3664,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)
                         }
                     }
@@ -2727,8 +3693,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)
                     };
@@ -2737,12 +3709,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)
                         }
                     }
@@ -2755,8 +3738,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)
                     };
@@ -2765,12 +3754,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)
                         }
                     }
@@ -2783,8 +3783,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)
                     };
@@ -2793,12 +3799,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)
                         }
                     }
@@ -2811,8 +3828,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)
                     };
@@ -2821,12 +3844,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)
                         }
                     }
@@ -2839,8 +3873,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)
                     };
@@ -2849,12 +3889,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)
                         }
                     }
@@ -2867,8 +3918,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)
                     };
@@ -2877,12 +3934,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)
                         }
                     }
@@ -2895,8 +3963,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)
                     };
@@ -2905,12 +3979,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)
                         }
                     }
@@ -2923,8 +4008,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)
                     };
@@ -2933,12 +4024,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)
                         }
                     }
@@ -2951,8 +4053,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)
                     };
@@ -2961,12 +4069,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)
                         }
                     }
@@ -2979,8 +4098,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)
                     };
@@ -2989,12 +4114,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)
                         }
                     }
@@ -3007,8 +4143,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)
                     };
@@ -3017,12 +4159,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)
                         }
                     }
@@ -3035,8 +4188,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)
                     };
@@ -3045,12 +4204,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)
                         }
                     }
@@ -3063,8 +4231,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)
                     };
@@ -3073,13 +4247,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)
                         }
                     }
@@ -3092,8 +4279,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)
                     };
@@ -3102,13 +4295,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)
                         }
                     }
@@ -3121,8 +4327,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)
                     };
@@ -3131,12 +4343,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)
                         }
                     }
@@ -3149,8 +4372,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)
                     };
@@ -3159,13 +4388,24 @@ 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::ServerStreamingService<super::WalkDirRequest> for WalkDirSvc<T> {
+                    impl<
+                        T: NodeService,
+                    > tonic::server::ServerStreamingService<super::WalkDirRequest>
+                    for WalkDirSvc<T> {
                         type Response = super::WalkDirResponse;
                         type ResponseStream = T::WalkDirStream;
-                        type Future = BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
-                        fn call(&mut self, request: tonic::Request<super::WalkDirRequest>) -> Self::Future {
+                        type Future = BoxFuture<
+                            tonic::Response<Self::ResponseStream>,
+                            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)
                         }
                     }
@@ -3178,8 +4418,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.server_streaming(method, req).await;
                         Ok(res)
                     };
@@ -3188,12 +4434,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)
                         }
                     }
@@ -3206,8 +4463,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)
                     };
@@ -3216,12 +4479,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)
                         }
                     }
@@ -3234,8 +4508,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)
                     };
@@ -3244,12 +4524,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)
                         }
                     }
@@ -3262,8 +4553,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)
                     };
@@ -3272,12 +4569,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)
                         }
                     }
@@ -3290,8 +4598,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)
                     };
@@ -3300,12 +4614,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)
                         }
                     }
@@ -3318,8 +4643,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)
                     };
@@ -3328,12 +4659,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)
                         }
                     }
@@ -3346,8 +4688,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)
                     };
@@ -3356,12 +4704,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)
                         }
                     }
@@ -3374,8 +4733,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)
                     };
@@ -3384,12 +4749,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)
                         }
                     }
@@ -3402,8 +4778,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)
                     };
@@ -3412,12 +4794,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)
                         }
                     }
@@ -3430,8 +4823,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)
                     };
@@ -3440,12 +4839,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)
                         }
                     }
@@ -3458,8 +4868,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)
                     };
@@ -3468,12 +4884,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)
                         }
                     }
@@ -3486,8 +4913,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)
                     };
@@ -3496,12 +4929,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)
                         }
                     }
@@ -3514,8 +4958,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)
                     };
@@ -3524,12 +4974,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)
                         }
                     }
@@ -3542,8 +5003,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)
                     };
@@ -3552,12 +5019,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)
                         }
                     }
@@ -3570,8 +5048,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)
                     };
@@ -3580,12 +5064,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)
                         }
                     }
@@ -3598,8 +5093,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)
                     };
@@ -3608,13 +5109,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)
                         }
                     }
@@ -3627,8 +5141,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)
                     };
@@ -3637,12 +5157,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)
                         }
                     }
@@ -3655,8 +5186,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)
                     };
@@ -3665,12 +5202,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)
                         }
                     }
@@ -3683,8 +5231,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)
                     };
@@ -3693,12 +5247,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)
                         }
                     }
@@ -3711,8 +5276,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)
                     };
@@ -3721,12 +5292,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)
                         }
                     }
@@ -3739,8 +5321,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)
                     };
@@ -3749,12 +5337,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)
                         }
                     }
@@ -3767,8 +5366,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)
                     };
@@ -3777,12 +5382,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)
                         }
                     }
@@ -3795,8 +5411,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)
                     };
@@ -3805,12 +5427,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)
                         }
                     }
@@ -3823,8 +5457,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)
                     };
@@ -3833,12 +5473,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)
                         }
                     }
@@ -3851,8 +5502,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)
                     };
@@ -3861,12 +5518,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)
                         }
                     }
@@ -3879,8 +5547,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)
                     };
@@ -3889,12 +5563,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)
                         }
                     }
@@ -3907,8 +5592,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)
                     };
@@ -3917,12 +5608,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)
                         }
                     }
@@ -3935,8 +5637,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)
                     };
@@ -3945,12 +5653,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)
                         }
                     }
@@ -3963,8 +5682,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)
                     };
@@ -3973,12 +5698,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)
                         }
                     }
@@ -3991,8 +5727,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)
                     };
@@ -4001,12 +5743,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)
                         }
                     }
@@ -4019,8 +5772,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)
                     };
@@ -4029,12 +5788,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)
                         }
                     }
@@ -4047,8 +5817,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)
                     };
@@ -4057,12 +5833,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)
                         }
                     }
@@ -4075,8 +5862,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)
                     };
@@ -4085,12 +5878,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)
                         }
                     }
@@ -4103,8 +5907,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)
                     };
@@ -4113,12 +5923,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)
                         }
                     }
@@ -4131,8 +5952,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)
                     };
@@ -4141,12 +5968,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)
                         }
                     }
@@ -4159,8 +5997,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)
                     };
@@ -4169,12 +6013,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)
                         }
                     }
@@ -4187,8 +6043,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)
                     };
@@ -4197,12 +6059,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)
                         }
                     }
@@ -4215,8 +6088,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)
                     };
@@ -4225,12 +6104,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)
                         }
                     }
@@ -4243,8 +6133,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)
                     };
@@ -4253,12 +6149,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)
                         }
                     }
@@ -4271,8 +6179,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)
                     };
@@ -4281,12 +6195,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)
                         }
                     }
@@ -4299,8 +6225,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)
                     };
@@ -4309,12 +6241,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)
                         }
                     }
@@ -4327,8 +6271,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)
                     };
@@ -4337,12 +6287,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)
                         }
                     }
@@ -4355,8 +6316,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)
                     };
@@ -4365,12 +6332,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)
                         }
                     }
@@ -4383,8 +6361,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)
                     };
@@ -4393,12 +6377,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)
                         }
                     }
@@ -4411,8 +6407,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)
                     };
@@ -4421,12 +6423,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)
                         }
                     }
@@ -4439,8 +6452,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)
                     };
@@ -4449,12 +6468,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)
                         }
                     }
@@ -4467,8 +6498,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)
                     };
@@ -4477,12 +6514,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)
                         }
                     }
@@ -4495,8 +6543,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)
                     };
@@ -4505,12 +6559,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)
                         }
                     }
@@ -4523,8 +6589,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)
                     };
@@ -4533,12 +6605,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)
                         }
                     }
@@ -4551,8 +6634,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)
                     };
@@ -4561,14 +6650,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)
                         }
                     }
@@ -4581,8 +6686,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)
                     };
@@ -4591,12 +6702,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)
                         }
                     }
@@ -4609,8 +6731,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)
                     };
@@ -4619,12 +6747,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)
                         }
                     }
@@ -4637,8 +6777,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)
                     };
@@ -4647,12 +6793,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)
                         }
                     }
@@ -4665,8 +6823,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)
                     };
@@ -4675,12 +6839,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)
                         }
                     }
@@ -4693,8 +6872,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)
                     };
@@ -4703,12 +6888,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)
                         }
                     }
@@ -4721,8 +6917,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)
                     };
@@ -4731,12 +6933,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)
                         }
                     }
@@ -4749,8 +6962,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)
                     };
@@ -4759,12 +6978,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)
                         }
                     }
@@ -4777,8 +7008,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)
                     };
@@ -4787,12 +7024,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)
                         }
                     }
@@ -4805,20 +7059,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/rustfs/Cargo.toml b/rustfs/Cargo.toml
index f0c8d118..fea12acb 100644
--- a/rustfs/Cargo.toml
+++ b/rustfs/Cargo.toml
@@ -20,6 +20,8 @@ log.workspace = true
 async-trait.workspace = true
 bytes.workspace = true
 clap.workspace = true
+csv = "1.3.1"
+datafusion = { workspace = true }
 common.workspace = true
 ecstore.workspace = true
 policy.workspace =true
@@ -69,6 +71,8 @@ const-str = { version = "0.6.1", features = ["std", "proc"] }
 atoi = "2.0.0"
 serde_urlencoded = "0.7.1"
 crypto = { path = "../crypto" }
+query = { path = "../s3select/query" }
+api = { path = "../s3select/api" }
 iam = { path = "../iam" }
 jsonwebtoken = "9.3.0"
 tower-http = { version = "0.6.2", features = ["cors"] }
diff --git a/rustfs/src/storage/ecfs.rs b/rustfs/src/storage/ecfs.rs
index 51cf0ea9..65544be5 100644
--- a/rustfs/src/storage/ecfs.rs
+++ b/rustfs/src/storage/ecfs.rs
@@ -4,8 +4,11 @@ use super::options::extract_metadata;
 use super::options::put_opts;
 use crate::auth::get_condition_values;
 use crate::storage::access::ReqInfo;
+use api::query::Context;
+use api::query::Query;
 use bytes::Bytes;
 use common::error::Result;
+use datafusion::arrow::json::writer::JsonArray;
 use ecstore::bucket::error::BucketMetadataError;
 use ecstore::bucket::metadata::BUCKET_LIFECYCLE_CONFIG;
 use ecstore::bucket::metadata::BUCKET_NOTIFICATION_CONFIG;
@@ -39,6 +42,9 @@ use ecstore::xhttp;
 use futures::pin_mut;
 use futures::{Stream, StreamExt};
 use http::HeaderMap;
+use iam::policy::action::Action;
+use api::server::dbms::DatabaseManagerSystem;
+use iam::policy::action::S3Action;
 use lazy_static::lazy_static;
 use log::warn;
 use policy::auth;
@@ -47,6 +53,7 @@ use policy::policy::action::S3Action;
 use policy::policy::BucketPolicy;
 use policy::policy::BucketPolicyArgs;
 use policy::policy::Validator;
+use query::instance::make_cnosdbms;
 use s3s::dto::*;
 use s3s::s3_error;
 use s3s::S3Error;
@@ -54,6 +61,8 @@ use s3s::S3ErrorCode;
 use s3s::S3Result;
 use s3s::S3;
 use s3s::{S3Request, S3Response};
+use tokio::sync::mpsc;
+use tokio_stream::wrappers::ReceiverStream;
 use std::fmt::Debug;
 use std::str::FromStr;
 use tokio_util::io::ReaderStream;
@@ -1859,6 +1868,70 @@ impl S3 for FS {
         }
         Ok(S3Response::new(PutObjectAclOutput::default()))
     }
+
+    async fn select_object_content(
+        &self,
+        req: S3Request<SelectObjectContentInput>,
+    ) -> S3Result<S3Response<SelectObjectContentOutput>> {
+        info!("handle select_object_content");
+
+        let input = req.input;
+        info!("{:?}", input);
+
+        let db = make_cnosdbms(input).await.map_err(|_| {
+            s3_error!(InternalError)
+        })?;
+        let query = Query::new(Context {input: input.clone()}, input.request.expression);
+        let result = db.execute(&query).await.map_err(|_| {
+            s3_error!(InternalError)
+        })?;
+
+        let results = result.result().chunk_result().await.unwrap().to_vec();
+
+        let mut buffer = Vec::new();
+        if input.request.output_serialization.csv.is_some() {
+            let mut csv_writer = CsvWriterBuilder::new().with_header(false).build(&mut buffer);
+            for batch in results {
+                csv_writer
+                    .write(&batch)
+                    .map_err(|e| s3_error!(InternalError, "cann't encode output to csv. e: {}", e.to_string()))?;
+            }
+        } else if input.request.output_serialization.json.is_some() {
+            let mut json_writer = JsonWriterBuilder::new()
+                .with_explicit_nulls(true)
+                .build::<_, JsonArray>(&mut buffer);
+            for batch in results {
+                json_writer
+                    .write(&batch)
+                    .map_err(|e| s3_error!(InternalError, "cann't encode output to json. e: {}", e.to_string()))?;
+            }
+            json_writer
+                .finish()
+                .map_err(|e| s3_error!(InternalError, "writer output into json error, e: {}", e.to_string()))?;
+        } else {
+            return Err(s3_error!(InvalidArgument, "unknow output format"));
+        }
+
+        let (tx, rx) = mpsc::channel::<S3Result<SelectObjectContentEvent>>(2);
+        let stream = ReceiverStream::new(rx);
+        tokio::spawn(async move {
+            let _ = tx
+                .send(Ok(SelectObjectContentEvent::Cont(ContinuationEvent::default())))
+                .await;
+            let _ = tx
+                .send(Ok(SelectObjectContentEvent::Records(RecordsEvent {
+                    payload: Some(Bytes::from(buffer)),
+                })))
+                .await;
+            let _ = tx.send(Ok(SelectObjectContentEvent::End(EndEvent::default()))).await;
+
+            drop(tx);
+        });
+
+        Ok(S3Response::new(SelectObjectContentOutput {
+            payload: Some(SelectObjectContentEventStream::new(stream)),
+        }))
+    }
 }
 
 #[allow(dead_code)]
diff --git a/s3select/api/Cargo.toml b/s3select/api/Cargo.toml
index 26f65bac..0f147396 100644
--- a/s3select/api/Cargo.toml
+++ b/s3select/api/Cargo.toml
@@ -5,6 +5,16 @@ edition.workspace = true
 
 [dependencies]
 async-trait.workspace = true
+bytes.workspace = true
+chrono.workspace = true
 datafusion = { workspace = true }
+ecstore.workspace = true
 futures = { workspace = true }
-snafu = { workspace = true, features = ["backtrace"] }
\ No newline at end of file
+futures-core = "0.3.31"
+http.workspace = true
+object_store = "0.11.2"
+s3s.workspace = true
+snafu = { workspace = true, features = ["backtrace"] }
+tokio.workspace = true
+tracing.workspace = true
+url.workspace = true
\ No newline at end of file
diff --git a/s3select/api/src/lib.rs b/s3select/api/src/lib.rs
index acf65393..9c61128b 100644
--- a/s3select/api/src/lib.rs
+++ b/s3select/api/src/lib.rs
@@ -1,8 +1,9 @@
 use std::fmt::Display;
 
-use datafusion::common::DataFusionError;
+use datafusion::{common::DataFusionError, sql::sqlparser::parser::ParserError};
 use snafu::{Backtrace, Location, Snafu};
 
+pub mod object_store;
 pub mod query;
 pub mod server;
 
@@ -16,6 +17,21 @@ pub enum QueryError {
         location: Location,
         backtrace: Backtrace,
     },
+
+    #[snafu(display("This feature is not implemented: {}", err))]
+    NotImplemented { err: String },
+
+    #[snafu(display("Multi-statement not allow, found num:{}, sql:{}", num, sql))]
+    MultiStatement { num: usize, sql: String },
+
+    #[snafu(display("Failed to build QueryDispatcher. err: {}", err))]
+    BuildQueryDispatcher { err: String },
+
+    #[snafu(display("The query has been canceled"))]
+    Cancel,
+
+    #[snafu(display("{}", source))]
+    Parser { source: ParserError },
 }
 
 impl From<DataFusionError> for QueryError {
diff --git a/s3select/api/src/object_store.rs b/s3select/api/src/object_store.rs
new file mode 100644
index 00000000..c10a26fa
--- /dev/null
+++ b/s3select/api/src/object_store.rs
@@ -0,0 +1,150 @@
+use async_trait::async_trait;
+use bytes::Bytes;
+use chrono::Utc;
+use ecstore::new_object_layer_fn;
+use ecstore::store::ECStore;
+use ecstore::store_api::ObjectIO;
+use ecstore::store_api::ObjectOptions;
+use ecstore::StorageAPI;
+use futures::stream;
+use futures::StreamExt;
+use futures_core::stream::BoxStream;
+use http::HeaderMap;
+use object_store::path::Path;
+use object_store::Attributes;
+use object_store::GetOptions;
+use object_store::GetResult;
+use object_store::ListResult;
+use object_store::MultipartUpload;
+use object_store::ObjectMeta;
+use object_store::ObjectStore;
+use object_store::PutMultipartOpts;
+use object_store::PutOptions;
+use object_store::PutPayload;
+use object_store::PutResult;
+use object_store::{Error as o_Error, Result};
+use s3s::dto::SelectObjectContentInput;
+use s3s::s3_error;
+use s3s::S3Result;
+use std::ops::Range;
+use std::sync::Arc;
+use tracing::info;
+
+#[derive(Debug)]
+pub struct EcObjectStore {
+    input: SelectObjectContentInput,
+
+    store: Arc<ECStore>,
+}
+
+impl EcObjectStore {
+    pub fn new(input: SelectObjectContentInput) -> S3Result<Self> {
+        let Some(store) = new_object_layer_fn() else {
+            return Err(s3_error!(InternalError, "ec store not inited"));
+        };
+
+        Ok(Self { input, store })
+    }
+}
+
+impl std::fmt::Display for EcObjectStore {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("EcObjectStore")
+    }
+}
+
+#[async_trait]
+impl ObjectStore for EcObjectStore {
+    async fn put_opts(&self, _location: &Path, _payload: PutPayload, _opts: PutOptions) -> Result<PutResult> {
+        unimplemented!()
+    }
+
+    async fn put_multipart_opts(&self, _location: &Path, _opts: PutMultipartOpts) -> Result<Box<dyn MultipartUpload>> {
+        unimplemented!()
+    }
+
+    async fn get_opts(&self, location: &Path, _options: GetOptions) -> Result<GetResult> {
+        info!("{:?}", location);
+        let opts = ObjectOptions::default();
+        let h = HeaderMap::new();
+        let reader = self
+            .store
+            .get_object_reader(&self.input.bucket, &self.input.key, None, h, &opts)
+            .await
+            .map_err(|_| o_Error::NotFound {
+                path: format!("{}/{}", self.input.bucket, self.input.key),
+                source: "can not get object info".into(),
+            })?;
+
+        let stream = stream::unfold(reader.stream, |mut blob| async move {
+            match blob.next().await {
+                Some(Ok(chunk)) => {
+                    let bytes = Bytes::from(chunk);
+                    Some((Ok(bytes), blob))
+                }
+                _ => None,
+            }
+        })
+        .boxed();
+        let meta = ObjectMeta {
+            location: location.clone(),
+            last_modified: Utc::now(),
+            size: reader.object_info.size,
+            e_tag: reader.object_info.etag,
+            version: None,
+        };
+        let attributes = Attributes::default();
+
+        Ok(GetResult {
+            payload: object_store::GetResultPayload::Stream(stream),
+            meta,
+            range: 0..reader.object_info.size,
+            attributes,
+        })
+    }
+
+    async fn get_ranges(&self, _location: &Path, _ranges: &[Range<usize>]) -> Result<Vec<Bytes>> {
+        unimplemented!()
+    }
+
+    async fn head(&self, location: &Path) -> Result<ObjectMeta> {
+        info!("{:?}", location);
+        let opts = ObjectOptions::default();
+        let info = self
+            .store
+            .get_object_info(&self.input.bucket, &self.input.key, &opts)
+            .await
+            .map_err(|_| o_Error::NotFound {
+                path: format!("{}/{}", self.input.bucket, self.input.key),
+                source: "can not get object info".into(),
+            })?;
+
+        Ok(ObjectMeta {
+            location: location.clone(),
+            last_modified: Utc::now(),
+            size: info.size,
+            e_tag: info.etag,
+            version: None,
+        })
+    }
+
+    async fn delete(&self, _location: &Path) -> Result<()> {
+        unimplemented!()
+    }
+
+    fn list(&self, _prefix: Option<&Path>) -> BoxStream<'_, Result<ObjectMeta>> {
+        unimplemented!()
+    }
+
+    async fn list_with_delimiter(&self, _prefix: Option<&Path>) -> Result<ListResult> {
+        unimplemented!()
+    }
+
+    async fn copy(&self, _from: &Path, _to: &Path) -> Result<()> {
+        unimplemented!()
+    }
+
+    async fn copy_if_not_exists(&self, _from: &Path, _too: &Path) -> Result<()> {
+        unimplemented!()
+    }
+}
diff --git a/s3select/api/src/query/analyzer.rs b/s3select/api/src/query/analyzer.rs
new file mode 100644
index 00000000..db849566
--- /dev/null
+++ b/s3select/api/src/query/analyzer.rs
@@ -0,0 +1,12 @@
+use std::sync::Arc;
+
+use datafusion::logical_expr::LogicalPlan;
+
+use super::session::SessionCtx;
+use crate::QueryResult;
+
+pub type AnalyzerRef = Arc<dyn Analyzer + Send + Sync>;
+
+pub trait Analyzer {
+    fn analyze(&self, plan: &LogicalPlan, session: &SessionCtx) -> QueryResult<LogicalPlan>;
+}
diff --git a/s3select/api/src/query/dispatcher.rs b/s3select/api/src/query/dispatcher.rs
index baa1885f..433ddf01 100644
--- a/s3select/api/src/query/dispatcher.rs
+++ b/s3select/api/src/query/dispatcher.rs
@@ -12,10 +12,6 @@ use super::{
 
 #[async_trait]
 pub trait QueryDispatcher: Send + Sync {
-    async fn start(&self) -> QueryResult<()>;
-
-    fn stop(&self);
-
     // fn create_query_id(&self) -> QueryId;
 
     // fn query_info(&self, id: &QueryId);
diff --git a/s3select/api/src/query/execution.rs b/s3select/api/src/query/execution.rs
index 94d9b46c..10c48acc 100644
--- a/s3select/api/src/query/execution.rs
+++ b/s3select/api/src/query/execution.rs
@@ -43,18 +43,6 @@ pub trait QueryExecution: Send + Sync {
     async fn start(&self) -> QueryResult<Output>;
     // 停止
     fn cancel(&self) -> QueryResult<()>;
-    // query状态
-    // 查询计划
-    // 静态信息
-    // fn info(&self) -> QueryInfo;
-    // 运行时信息
-    // fn status(&self) -> QueryStatus;
-    // sql
-    // 资源占用（cpu时间/内存/吞吐量等）
-    // 是否需要持久化query信息
-    fn need_persist(&self) -> bool {
-        false
-    }
 }
 
 pub enum Output {
diff --git a/s3select/api/src/query/logical_planner.rs b/s3select/api/src/query/logical_planner.rs
index 325be6c8..cef844b3 100644
--- a/s3select/api/src/query/logical_planner.rs
+++ b/s3select/api/src/query/logical_planner.rs
@@ -1,6 +1,12 @@
+use async_trait::async_trait;
 use datafusion::arrow::datatypes::SchemaRef;
 use datafusion::logical_expr::LogicalPlan as DFPlan;
 
+use crate::QueryResult;
+
+use super::ast::ExtStatement;
+use super::session::SessionCtx;
+
 #[derive(Clone)]
 pub enum Plan {
     // only support query sql
@@ -27,3 +33,8 @@ impl QueryPlan {
         matches!(self.df_plan, DFPlan::Explain(_) | DFPlan::Analyze(_))
     }
 }
+
+#[async_trait]
+pub trait LogicalPlanner {
+    async fn create_logical_plan(&self, statement: ExtStatement, session: &SessionCtx) -> QueryResult<Plan>;
+}
diff --git a/s3select/api/src/query/mod.rs b/s3select/api/src/query/mod.rs
index e93fc575..6ddd2dc8 100644
--- a/s3select/api/src/query/mod.rs
+++ b/s3select/api/src/query/mod.rs
@@ -1,15 +1,22 @@
+use s3s::dto::SelectObjectContentInput;
+
+pub mod analyzer;
 pub mod ast;
 pub mod datasource;
 pub mod dispatcher;
 pub mod execution;
 pub mod function;
 pub mod logical_planner;
+pub mod optimizer;
 pub mod parser;
+pub mod physical_planner;
+pub mod scheduler;
 pub mod session;
 
 #[derive(Clone)]
 pub struct Context {
     // maybe we need transfer some info?
+    pub input: SelectObjectContentInput,
 }
 
 #[derive(Clone)]
@@ -17,3 +24,18 @@ pub struct Query {
     context: Context,
     content: String,
 }
+
+impl Query {
+    #[inline(always)]
+    pub fn new(context: Context, content: String) -> Self {
+        Self { context, content }
+    }
+
+    pub fn context(&self) -> &Context {
+        &self.context
+    }
+
+    pub fn content(&self) -> &str {
+        self.content.as_str()
+    }
+}
diff --git a/s3select/api/src/query/optimizer.rs b/s3select/api/src/query/optimizer.rs
new file mode 100644
index 00000000..c2392eb9
--- /dev/null
+++ b/s3select/api/src/query/optimizer.rs
@@ -0,0 +1,15 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use datafusion::physical_plan::ExecutionPlan;
+
+use super::logical_planner::QueryPlan;
+use super::session::SessionCtx;
+use crate::QueryResult;
+
+pub type OptimizerRef = Arc<dyn Optimizer + Send + Sync>;
+
+#[async_trait]
+pub trait Optimizer {
+    async fn optimize(&self, plan: &QueryPlan, session: &SessionCtx) -> QueryResult<Arc<dyn ExecutionPlan>>;
+}
diff --git a/s3select/api/src/query/physical_planner.rs b/s3select/api/src/query/physical_planner.rs
new file mode 100644
index 00000000..c71787e9
--- /dev/null
+++ b/s3select/api/src/query/physical_planner.rs
@@ -0,0 +1,21 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use datafusion::logical_expr::LogicalPlan;
+use datafusion::physical_plan::ExecutionPlan;
+use datafusion::physical_planner::ExtensionPlanner;
+
+use super::session::SessionCtx;
+use crate::QueryResult;
+
+#[async_trait]
+pub trait PhysicalPlanner {
+    /// Given a `LogicalPlan`, create an `ExecutionPlan` suitable for execution
+    async fn create_physical_plan(
+        &self,
+        logical_plan: &LogicalPlan,
+        session_state: &SessionCtx,
+    ) -> QueryResult<Arc<dyn ExecutionPlan>>;
+
+    fn inject_physical_transform_rule(&mut self, rule: Arc<dyn ExtensionPlanner + Send + Sync>);
+}
diff --git a/s3select/api/src/query/scheduler.rs b/s3select/api/src/query/scheduler.rs
new file mode 100644
index 00000000..3dd49c22
--- /dev/null
+++ b/s3select/api/src/query/scheduler.rs
@@ -0,0 +1,32 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use datafusion::common::Result;
+use datafusion::execution::context::TaskContext;
+use datafusion::physical_plan::{ExecutionPlan, SendableRecordBatchStream};
+
+pub type SchedulerRef = Arc<dyn Scheduler + Send + Sync>;
+
+#[async_trait]
+pub trait Scheduler {
+    /// Schedule the provided [`ExecutionPlan`] on this [`Scheduler`].
+    ///
+    /// Returns a [`ExecutionResults`] that can be used to receive results as they are produced,
+    /// as a [`futures::Stream`] of [`RecordBatch`]
+    async fn schedule(&self, plan: Arc<dyn ExecutionPlan>, context: Arc<TaskContext>) -> Result<ExecutionResults>;
+}
+
+pub struct ExecutionResults {
+    stream: SendableRecordBatchStream,
+}
+
+impl ExecutionResults {
+    pub fn new(stream: SendableRecordBatchStream) -> Self {
+        Self { stream }
+    }
+
+    /// Returns a [`SendableRecordBatchStream`] of this execution
+    pub fn stream(self) -> SendableRecordBatchStream {
+        self.stream
+    }
+}
diff --git a/s3select/api/src/query/session.rs b/s3select/api/src/query/session.rs
index d387ff71..23e80e3c 100644
--- a/s3select/api/src/query/session.rs
+++ b/s3select/api/src/query/session.rs
@@ -1,10 +1,17 @@
 use std::sync::Arc;
 
-use datafusion::execution::context::SessionState;
+use datafusion::{
+    execution::{context::SessionState, runtime_env::RuntimeEnvBuilder, SessionStateBuilder},
+    prelude::SessionContext,
+};
+
+use crate::{object_store::EcObjectStore, QueryError, QueryResult};
+
+use super::Context;
 
 #[derive(Clone)]
 pub struct SessionCtx {
-    desc: Arc<SessionCtxDesc>,
+    _desc: Arc<SessionCtxDesc>,
     inner: SessionState,
 }
 
@@ -18,3 +25,33 @@ impl SessionCtx {
 pub struct SessionCtxDesc {
     // maybe we need some info
 }
+
+#[derive(Default)]
+pub struct SessionCtxFactory {}
+
+impl SessionCtxFactory {
+    pub fn create_session_ctx(&self, context: &Context) -> QueryResult<SessionCtx> {
+        let df_session_ctx = self.build_df_session_context(context)?;
+
+        Ok(SessionCtx {
+            _desc: Arc::new(SessionCtxDesc {}),
+            inner: df_session_ctx.state(),
+        })
+    }
+
+    fn build_df_session_context(&self, context: &Context) -> QueryResult<SessionContext> {
+        let path = format!("s3://{}", context.input.bucket);
+        let store_url = url::Url::parse(&path).unwrap();
+        let store = EcObjectStore::new(context.input.clone()).map_err(|_| QueryError::NotImplemented { err: String::new() })?;
+
+        let rt = RuntimeEnvBuilder::new().build()?;
+        let df_session_state = SessionStateBuilder::new()
+            .with_runtime_env(Arc::new(rt))
+            .with_object_store(&store_url, Arc::new(store))
+            .with_default_features()
+            .build();
+        let df_session_ctx = SessionContext::new_with_state(df_session_state);
+
+        Ok(df_session_ctx)
+    }
+}
diff --git a/s3select/api/src/server/dbms.rs b/s3select/api/src/server/dbms.rs
index dc9e195d..85d32055 100644
--- a/s3select/api/src/server/dbms.rs
+++ b/s3select/api/src/server/dbms.rs
@@ -30,7 +30,6 @@ impl QueryHandle {
 
 #[async_trait]
 pub trait DatabaseManagerSystem {
-    async fn start(&self) -> QueryResult<()>;
     async fn execute(&self, query: &Query) -> QueryResult<QueryHandle>;
     async fn build_query_state_machine(&self, query: Query) -> QueryResult<QueryStateMachineRef>;
     async fn build_logical_plan(&self, query_state_machine: QueryStateMachineRef) -> QueryResult<Option<Plan>>;
@@ -39,5 +38,4 @@ pub trait DatabaseManagerSystem {
         logical_plan: Plan,
         query_state_machine: QueryStateMachineRef,
     ) -> QueryResult<QueryHandle>;
-    fn metrics(&self) -> String;
 }
diff --git a/s3select/query/Cargo.toml b/s3select/query/Cargo.toml
index 218f5cee..61b0b07b 100644
--- a/s3select/query/Cargo.toml
+++ b/s3select/query/Cargo.toml
@@ -5,8 +5,13 @@ edition.workspace = true
 
 [dependencies]
 api = { path = "../api" }
+async-recursion = { workspace = true }
 async-trait.workspace = true
 datafusion = { workspace = true }
 derive_builder = { workspace = true }
+futures = { workspace = true }
+parking_lot = { version = "0.12.1" }
+s3s.workspace = true
+snafu = { workspace = true, features = ["backtrace"] }
 tokio = { workspace = true }
 tracing = { workspace = true }
\ No newline at end of file
diff --git a/s3select/query/src/data_source/data_source.rs b/s3select/query/src/data_source/data_source.rs
index a2c32f94..77df6e81 100644
--- a/s3select/query/src/data_source/data_source.rs
+++ b/s3select/query/src/data_source/data_source.rs
@@ -1,4 +1,5 @@
 use std::any::Any;
+use std::borrow::Cow;
 use std::fmt::Display;
 use std::sync::Arc;
 use std::write;
@@ -10,7 +11,6 @@ use datafusion::datasource::listing::ListingTable;
 use datafusion::datasource::{provider_as_source, TableProvider};
 use datafusion::error::DataFusionError;
 use datafusion::logical_expr::{LogicalPlan, LogicalPlanBuilder, TableProviderFilterPushDown, TableSource};
-use datafusion::physical_plan::ExecutionPlan;
 use datafusion::prelude::Expr;
 use datafusion::sql::TableReference;
 use tracing::debug;
@@ -28,11 +28,9 @@ pub struct TableSourceAdapter {
 impl TableSourceAdapter {
     pub fn try_new(
         table_ref: impl Into<TableReference>,
-        database_name: impl Into<String>,
         table_name: impl Into<String>,
         table_handle: impl Into<TableHandle>,
     ) -> Result<Self, DataFusionError> {
-        let database_name = database_name.into();
         let table_name: String = table_name.into();
 
         let table_handle = table_handle.into();
@@ -46,7 +44,7 @@ impl TableSourceAdapter {
             TableHandle::TableProvider(t) => {
                 let table_source = provider_as_source(t.clone());
                 if let Some(plan) = table_source.get_logical_plan() {
-                    LogicalPlanBuilder::from(plan.clone()).build()?
+                    LogicalPlanBuilder::from(plan.into_owned()).build()?
                 } else {
                     LogicalPlanBuilder::scan(table_ref, table_source, None)?.build()?
                 }
@@ -91,8 +89,8 @@ impl TableSource for TableSourceAdapter {
     }
 
     /// Called by [`InlineTableScan`]
-    fn get_logical_plan(&self) -> Option<&LogicalPlan> {
-        Some(&self.plan)
+    fn get_logical_plan(&self) -> Option<Cow<LogicalPlan>> {
+        Some(Cow::Owned(self.plan.clone()))
     }
 }
 
diff --git a/s3select/query/src/dispatcher/manager.rs b/s3select/query/src/dispatcher/manager.rs
index bde400f4..effe17bf 100644
--- a/s3select/query/src/dispatcher/manager.rs
+++ b/s3select/query/src/dispatcher/manager.rs
@@ -1,51 +1,62 @@
 use std::{
     collections::HashMap,
+    pin::Pin,
     sync::{Arc, Mutex},
+    task::{Context, Poll},
 };
 
 use api::{
     query::{
+        ast::ExtStatement,
         dispatcher::QueryDispatcher,
         execution::{Output, QueryStateMachine},
         function::FuncMetaManagerRef,
-        logical_planner::Plan,
+        logical_planner::{LogicalPlanner, Plan},
         parser::Parser,
+        session::{SessionCtx, SessionCtxFactory},
         Query,
     },
     QueryError, QueryResult,
 };
 use async_trait::async_trait;
+use datafusion::{
+    arrow::{datatypes::SchemaRef, record_batch::RecordBatch},
+    config::CsvOptions,
+    datasource::{
+        file_format::{csv::CsvFormat, json::JsonFormat, parquet::ParquetFormat},
+        listing::{ListingOptions, ListingTable, ListingTableConfig, ListingTableUrl},
+    },
+    error::Result as DFResult,
+    execution::{RecordBatchStream, SendableRecordBatchStream},
+};
+use futures::{Stream, StreamExt};
+use s3s::dto::SelectObjectContentInput;
 use tokio::task::JoinHandle;
 
-use crate::metadata::TableHandleProviderRef;
+use crate::{
+    execution::factory::QueryExecutionFactoryRef,
+    metadata::{
+        base_table::BaseTableProvider,
+        ContextProviderExtension, MetadataProvider, TableHandleProviderRef,
+    },
+    sql::logical::planner::DefaultLogicalPlanner,
+};
 
 #[derive(Clone)]
 pub struct SimpleQueryDispatcher {
+    input: SelectObjectContentInput,
     // client for default tenant
     default_table_provider: TableHandleProviderRef,
-    // memory pool
-    // memory_pool: MemoryPoolRef,
-    // query tracker
+    session_factory: Arc<SessionCtxFactory>,
     // parser
     parser: Arc<dyn Parser + Send + Sync>,
     // get query execution factory
     query_execution_factory: QueryExecutionFactoryRef,
     func_manager: FuncMetaManagerRef,
-
-    async_task_joinhandle: Arc<Mutex<HashMap<String, JoinHandle<()>>>>,
-    failed_task_joinhandle: Arc<Mutex<HashMap<String, JoinHandle<()>>>>,
 }
 
 #[async_trait]
 impl QueryDispatcher for SimpleQueryDispatcher {
-    async fn start(&self) -> QueryResult<()> {
-        self.execute_persister_query(self.coord.node_id()).await
-    }
-
-    fn stop(&self) {
-        // TODO
-    }
-
     async fn execute_query(&self, query: &Query) -> QueryResult<Output> {
         let query_state_machine = { self.build_query_state_machine(query.clone()).await? };
 
@@ -66,7 +77,6 @@ impl QueryDispatcher for SimpleQueryDispatcher {
 
         let logical_planner = DefaultLogicalPlanner::new(&scheme_provider);
 
-        let span_recorder = session.get_child_span("parse sql");
         let statements = self.parser.parse(query.content())?;
 
         // not allow multi statement
@@ -82,8 +92,6 @@ impl QueryDispatcher for SimpleQueryDispatcher {
             None => return Ok(None),
         };
 
-        drop(span_recorder);
-
         let logical_plan = self
             .statement_to_logical_plan(stmt, &logical_planner, query_state_machine)
             .await?;
@@ -95,9 +103,7 @@ impl QueryDispatcher for SimpleQueryDispatcher {
     }
 
     async fn build_query_state_machine(&self, query: Query) -> QueryResult<Arc<QueryStateMachine>> {
-        let session = self
-            .session_factory
-            .create_session_ctx(query.context(), self.memory_pool.clone(), self.coord.clone())?;
+        let session = self.session_factory.create_session_ctx(query.context())?;
 
         let query_state_machine = Arc::new(QueryStateMachine::begin(query, session));
         Ok(query_state_machine)
@@ -114,7 +120,7 @@ impl SimpleQueryDispatcher {
         // begin analyze
         query_state_machine.begin_analyze();
         let logical_plan = logical_planner
-            .create_logical_plan(stmt, &query_state_machine.session, self.coord.get_config().query.auth_enabled)
+            .create_logical_plan(stmt, &query_state_machine.session)
             .await?;
         query_state_machine.end_analyze();
 
@@ -127,79 +133,85 @@ impl SimpleQueryDispatcher {
             .create_query_execution(logical_plan, query_state_machine.clone())
             .await?;
 
-        // TrackedQuery.drop() is called implicitly when the value goes out of scope,
-        self.query_tracker
-            .try_track_query(query_state_machine.query_id, execution)
-            .await?
-            .start()
-            .await
+        match execution.start().await {
+            Ok(Output::StreamData(stream)) => Ok(Output::StreamData(Box::pin(TrackedRecordBatchStream { inner: stream }))),
+            Ok(nil @ Output::Nil(_)) => Ok(nil),
+            Err(err) => Err(err),
+        }
     }
 
     async fn build_scheme_provider(&self, session: &SessionCtx) -> QueryResult<MetadataProvider> {
-        let meta_client = self.build_current_session_meta_client(session).await?;
-        let current_session_table_provider = self.build_table_handle_provider(meta_client.clone())?;
-        let metadata_provider = MetadataProvider::new(
-            self.coord.clone(),
-            meta_client,
-            current_session_table_provider,
-            self.default_table_provider.clone(),
-            self.func_manager.clone(),
-            self.query_tracker.clone(),
-            session.clone(),
-        );
+        let path = format!("s3://{}/{}", self.input.bucket, self.input.key);
+        let table_path = ListingTableUrl::parse(path)?;
+        let listing_options = if self.input.request.input_serialization.csv.is_some() {
+            let file_format = CsvFormat::default().with_options(CsvOptions::default().with_has_header(false));
+            ListingOptions::new(Arc::new(file_format)).with_file_extension(".csv")
+        } else if self.input.request.input_serialization.parquet.is_some() {
+            let file_format = ParquetFormat::new();
+            ListingOptions::new(Arc::new(file_format)).with_file_extension(".parquet")
+        } else if self.input.request.input_serialization.json.is_some() {
+            let file_format = JsonFormat::default();
+            ListingOptions::new(Arc::new(file_format)).with_file_extension(".json")
+        } else {
+            return Err(QueryError::NotImplemented {
+                err: "not support this file type".to_string(),
+            });
+        };
+
+        let resolve_schema = listing_options.infer_schema(session.inner(), &table_path).await?;
+        let config = ListingTableConfig::new(table_path)
+            .with_listing_options(listing_options)
+            .with_schema(resolve_schema);
+        let provider = Arc::new(ListingTable::try_new(config)?);
+        let current_session_table_provider = self.build_table_handle_provider()?;
+        let metadata_provider =
+            MetadataProvider::new(provider, current_session_table_provider, self.func_manager.clone(), session.clone());
 
         Ok(metadata_provider)
     }
 
-    async fn build_current_session_meta_client(&self, session: &SessionCtx) -> QueryResult<MetaClientRef> {
-        let meta_client = self
-            .coord
-            .tenant_meta(session.tenant())
-            .await
-            .ok_or_else(|| MetaError::TenantNotFound {
-                tenant: session.tenant().to_string(),
-            })
-            .context(MetaSnafu)?;
-
-        Ok(meta_client)
-    }
-
-    fn build_table_handle_provider(&self, meta_client: MetaClientRef) -> QueryResult<TableHandleProviderRef> {
-        let current_session_table_provider: Arc<BaseTableProvider> = Arc::new(BaseTableProvider::new(
-            self.coord.clone(),
-            self.split_manager.clone(),
-            meta_client,
-            self.stream_provider_manager.clone(),
-        ));
+    fn build_table_handle_provider(&self) -> QueryResult<TableHandleProviderRef> {
+        let current_session_table_provider: Arc<BaseTableProvider> = Arc::new(BaseTableProvider::default());
 
         Ok(current_session_table_provider)
     }
 }
 
+pub struct TrackedRecordBatchStream {
+    inner: SendableRecordBatchStream,
+}
+
+impl RecordBatchStream for TrackedRecordBatchStream {
+    fn schema(&self) -> SchemaRef {
+        self.inner.schema()
+    }
+}
+
+impl Stream for TrackedRecordBatchStream {
+    type Item = DFResult<RecordBatch>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        self.inner.poll_next_unpin(cx)
+    }
+}
+
 #[derive(Default, Clone)]
 pub struct SimpleQueryDispatcherBuilder {
-    coord: Option<CoordinatorRef>,
+    input: Option<SelectObjectContentInput>,
     default_table_provider: Option<TableHandleProviderRef>,
-    split_manager: Option<SplitManagerRef>,
     session_factory: Option<Arc<SessionCtxFactory>>,
     parser: Option<Arc<dyn Parser + Send + Sync>>,
 
     query_execution_factory: Option<QueryExecutionFactoryRef>,
-    query_tracker: Option<Arc<QueryTracker>>,
-    memory_pool: Option<MemoryPoolRef>, // memory
 
     func_manager: Option<FuncMetaManagerRef>,
-    stream_provider_manager: Option<StreamProviderManagerRef>,
-    span_ctx: Option<SpanContext>,
-    auth_cache: Option<Arc<AuthCache<AuthCacheKey, User>>>,
 }
 
 impl SimpleQueryDispatcherBuilder {
-    pub fn with_coord(mut self, coord: CoordinatorRef) -> Self {
-        self.coord = Some(coord);
+    pub fn with_input(mut self, input: SelectObjectContentInput) -> Self {
+        self.input = Some(input);
         self
     }
-
     pub fn with_default_table_provider(mut self, default_table_provider: TableHandleProviderRef) -> Self {
         self.default_table_provider = Some(default_table_provider);
         self
@@ -210,11 +222,6 @@ impl SimpleQueryDispatcherBuilder {
         self
     }
 
-    pub fn with_split_manager(mut self, split_manager: SplitManagerRef) -> Self {
-        self.split_manager = Some(split_manager);
-        self
-    }
-
     pub fn with_parser(mut self, parser: Arc<dyn Parser + Send + Sync>) -> Self {
         self.parser = Some(parser);
         self
@@ -225,43 +232,14 @@ impl SimpleQueryDispatcherBuilder {
         self
     }
 
-    pub fn with_query_tracker(mut self, query_tracker: Arc<QueryTracker>) -> Self {
-        self.query_tracker = Some(query_tracker);
-        self
-    }
-
-    pub fn with_memory_pool(mut self, memory_pool: MemoryPoolRef) -> Self {
-        self.memory_pool = Some(memory_pool);
-        self
-    }
-
     pub fn with_func_manager(mut self, func_manager: FuncMetaManagerRef) -> Self {
         self.func_manager = Some(func_manager);
         self
     }
 
-    pub fn with_stream_provider_manager(mut self, stream_provider_manager: StreamProviderManagerRef) -> Self {
-        self.stream_provider_manager = Some(stream_provider_manager);
-        self
-    }
-
-    pub fn with_span_ctx(mut self, span_ctx: Option<SpanContext>) -> Self {
-        self.span_ctx = span_ctx;
-        self
-    }
-
-    pub fn with_auth_cache(mut self, auth_cache: Arc<AuthCache<AuthCacheKey, User>>) -> Self {
-        self.auth_cache = Some(auth_cache);
-        self
-    }
-
     pub fn build(self) -> QueryResult<Arc<SimpleQueryDispatcher>> {
-        let coord = self.coord.ok_or_else(|| QueryError::BuildQueryDispatcher {
-            err: "lost of coord".to_string(),
-        })?;
-
-        let split_manager = self.split_manager.ok_or_else(|| QueryError::BuildQueryDispatcher {
-            err: "lost of split manager".to_string(),
+        let input = self.input.ok_or_else(|| QueryError::BuildQueryDispatcher {
+            err: "lost of input".to_string(),
         })?;
 
         let session_factory = self.session_factory.ok_or_else(|| QueryError::BuildQueryDispatcher {
@@ -276,56 +254,23 @@ impl SimpleQueryDispatcherBuilder {
             err: "lost of query_execution_factory".to_string(),
         })?;
 
-        let query_tracker = self.query_tracker.ok_or_else(|| QueryError::BuildQueryDispatcher {
-            err: "lost of query_tracker".to_string(),
-        })?;
-
         let func_manager = self.func_manager.ok_or_else(|| QueryError::BuildQueryDispatcher {
             err: "lost of func_manager".to_string(),
         })?;
 
-        let stream_provider_manager = self.stream_provider_manager.ok_or_else(|| QueryError::BuildQueryDispatcher {
-            err: "lost of stream_provider_manager".to_string(),
-        })?;
-
-        let memory_pool = self.memory_pool.ok_or_else(|| QueryError::BuildQueryDispatcher {
-            err: "lost of memory pool".to_string(),
-        })?;
-
         let default_table_provider = self.default_table_provider.ok_or_else(|| QueryError::BuildQueryDispatcher {
             err: "lost of default_table_provider".to_string(),
         })?;
 
-        let span_ctx = self.span_ctx;
-
-        let auth_cache = self.auth_cache.ok_or_else(|| QueryError::BuildQueryDispatcher {
-            err: "lost of auth_cache".to_string(),
-        })?;
-
         let dispatcher = Arc::new(SimpleQueryDispatcher {
-            coord,
+            input,
             default_table_provider,
-            split_manager,
             session_factory,
-            memory_pool,
             parser,
             query_execution_factory,
-            query_tracker,
             func_manager,
-            stream_provider_manager,
-            span_ctx,
-            async_task_joinhandle: Arc::new(Mutex::new(HashMap::new())),
-            failed_task_joinhandle: Arc::new(Mutex::new(HashMap::new())),
-            auth_cache,
         });
 
-        let meta_task_receiver = dispatcher
-            .coord
-            .meta_manager()
-            .take_resourceinfo_rx()
-            .expect("meta resource channel only has one consumer");
-        tokio::spawn(SimpleQueryDispatcher::recv_meta_modify(dispatcher.clone(), meta_task_receiver));
-
         Ok(dispatcher)
     }
 }
diff --git a/s3select/query/src/execution/factory.rs b/s3select/query/src/execution/factory.rs
index f6352eaf..9960d68a 100644
--- a/s3select/query/src/execution/factory.rs
+++ b/s3select/query/src/execution/factory.rs
@@ -1,42 +1,29 @@
 use std::sync::Arc;
 
-use api::query::execution::QueryExecutionFactory;
+use api::{
+    query::{
+        execution::{QueryExecutionFactory, QueryExecutionRef, QueryStateMachineRef},
+        logical_planner::Plan,
+        optimizer::Optimizer,
+        scheduler::SchedulerRef,
+    },
+    QueryError,
+};
+use async_trait::async_trait;
+
+use super::query::SqlQueryExecution;
 
 pub type QueryExecutionFactoryRef = Arc<dyn QueryExecutionFactory + Send + Sync>;
 
 pub struct SqlQueryExecutionFactory {
     optimizer: Arc<dyn Optimizer + Send + Sync>,
     scheduler: SchedulerRef,
-    query_tracker: Arc<QueryTracker>,
-    trigger_executor_factory: TriggerExecutorFactoryRef,
-    runtime: Arc<DedicatedExecutor>,
-    stream_checker_manager: StreamCheckerManagerRef,
 }
 
 impl SqlQueryExecutionFactory {
     #[inline(always)]
-    pub fn new(
-        optimizer: Arc<dyn Optimizer + Send + Sync>,
-        scheduler: SchedulerRef,
-        query_tracker: Arc<QueryTracker>,
-        stream_checker_manager: StreamCheckerManagerRef,
-        config: Arc<QueryOptions>,
-    ) -> Self {
-        // Only do periodic scheduling, no need for many threads
-        let trigger_executor_runtime = DedicatedExecutor::new("stream-trigger", config.stream_trigger_cpu);
-        let trigger_executor_factory = Arc::new(TriggerExecutorFactory::new(Arc::new(trigger_executor_runtime)));
-
-        // perform stream-related preparations, not actual operator execution
-        let runtime = Arc::new(DedicatedExecutor::new("stream-executor", config.stream_executor_cpu));
-
-        Self {
-            optimizer,
-            scheduler,
-            query_tracker,
-            trigger_executor_factory,
-            runtime,
-            stream_checker_manager,
-        }
+    pub fn new(optimizer: Arc<dyn Optimizer + Send + Sync>, scheduler: SchedulerRef) -> Self {
+        Self { optimizer, scheduler }
     }
 }
 
@@ -48,62 +35,12 @@ impl QueryExecutionFactory for SqlQueryExecutionFactory {
         state_machine: QueryStateMachineRef,
     ) -> Result<QueryExecutionRef, QueryError> {
         match plan {
-            Plan::Query(query_plan) => {
-                // 获取执行计划中所有涉及到的stream source
-                let stream_providers = extract_stream_providers(&query_plan);
-
-                // (含有流表, explain, dml)
-                match (!stream_providers.is_empty(), query_plan.is_explain(), is_dml(&query_plan)) {
-                    (false, _, _) | (true, true, _) => Ok(Arc::new(SqlQueryExecution::new(
-                        state_machine,
-                        query_plan,
-                        self.optimizer.clone(),
-                        self.scheduler.clone(),
-                    ))),
-                    (true, false, true) => {
-                        // 流操作
-                        // stream source + dml + !explain
-                        let options = state_machine.session.inner().config().into();
-                        let exec = MicroBatchStreamExecutionBuilder::new(MicroBatchStreamExecutionDesc {
-                            plan: Arc::new(query_plan),
-                            options,
-                        })
-                        .with_stream_providers(stream_providers)
-                        .build(
-                            state_machine,
-                            self.scheduler.clone(),
-                            self.trigger_executor_factory.clone(),
-                            self.runtime.clone(),
-                        )
-                        .await?;
-
-                        Ok(Arc::new(exec))
-                    }
-                    (true, false, false) => {
-                        // stream source + !dml + !explain
-                        Err(QueryError::NotImplemented {
-                            err: "Stream table can only be used as source table in insert select statements.".to_string(),
-                        })
-                    }
-                }
-            }
-            Plan::DDL(ddl_plan) => Ok(Arc::new(DDLExecution::new(state_machine, self.stream_checker_manager.clone(), ddl_plan))),
-            Plan::DML(dml_plan) => Ok(Arc::new(DMLExecution::new(state_machine, dml_plan))),
-            Plan::SYSTEM(sys_plan) => Ok(Arc::new(SystemExecution::new(state_machine, sys_plan, self.query_tracker.clone()))),
+            Plan::Query(query_plan) => Ok(Arc::new(SqlQueryExecution::new(
+                state_machine,
+                query_plan,
+                self.optimizer.clone(),
+                self.scheduler.clone(),
+            ))),
         }
     }
 }
-
-fn is_dml(query_plan: &QueryPlan) -> bool {
-    match &query_plan.df_plan {
-        LogicalPlan::Dml(_) => true,
-        LogicalPlan::Extension(Extension { node }) => downcast_plan_node::<TableWriterMergePlanNode>(node.as_ref()).is_some(),
-        _ => false,
-    }
-}
-
-impl Drop for SqlQueryExecutionFactory {
-    fn drop(&mut self) {
-        self.runtime.shutdown();
-    }
-}
diff --git a/s3select/query/src/execution/mod.rs b/s3select/query/src/execution/mod.rs
index a106d20e..807faf3e 100644
--- a/s3select/query/src/execution/mod.rs
+++ b/s3select/query/src/execution/mod.rs
@@ -1 +1,3 @@
 pub mod factory;
+pub mod query;
+pub mod scheduler;
diff --git a/s3select/query/src/execution/query.rs b/s3select/query/src/execution/query.rs
new file mode 100644
index 00000000..15d6ef83
--- /dev/null
+++ b/s3select/query/src/execution/query.rs
@@ -0,0 +1,92 @@
+use std::sync::Arc;
+
+use api::query::execution::{Output, QueryExecution, QueryStateMachineRef};
+use api::query::logical_planner::QueryPlan;
+use api::query::optimizer::Optimizer;
+use api::query::scheduler::SchedulerRef;
+use api::{QueryError, QueryResult};
+use async_trait::async_trait;
+use futures::stream::AbortHandle;
+use parking_lot::Mutex;
+use tracing::debug;
+
+pub struct SqlQueryExecution {
+    query_state_machine: QueryStateMachineRef,
+    plan: QueryPlan,
+    optimizer: Arc<dyn Optimizer + Send + Sync>,
+    scheduler: SchedulerRef,
+
+    abort_handle: Mutex<Option<AbortHandle>>,
+}
+
+impl SqlQueryExecution {
+    pub fn new(
+        query_state_machine: QueryStateMachineRef,
+        plan: QueryPlan,
+        optimizer: Arc<dyn Optimizer + Send + Sync>,
+        scheduler: SchedulerRef,
+    ) -> Self {
+        Self {
+            query_state_machine,
+            plan,
+            optimizer,
+            scheduler,
+            abort_handle: Mutex::new(None),
+        }
+    }
+
+    async fn start(&self) -> QueryResult<Output> {
+        // begin optimize
+        self.query_state_machine.begin_optimize();
+        let physical_plan = self.optimizer.optimize(&self.plan, &self.query_state_machine.session).await?;
+        self.query_state_machine.end_optimize();
+
+        // begin schedule
+        self.query_state_machine.begin_schedule();
+        let stream = self
+            .scheduler
+            .schedule(physical_plan.clone(), self.query_state_machine.session.inner().task_ctx())
+            .await?
+            .stream();
+
+        debug!("Success build result stream.");
+        self.query_state_machine.end_schedule();
+
+        Ok(Output::StreamData(stream))
+    }
+}
+
+#[async_trait]
+impl QueryExecution for SqlQueryExecution {
+    async fn start(&self) -> QueryResult<Output> {
+        let (task, abort_handle) = futures::future::abortable(self.start());
+
+        {
+            *self.abort_handle.lock() = Some(abort_handle);
+        }
+
+        task.await.map_err(|_| QueryError::Cancel)?
+    }
+
+    fn cancel(&self) -> QueryResult<()> {
+        debug!(
+            "cancel sql query execution: sql: {}, state: {:?}",
+            self.query_state_machine.query.content(),
+            self.query_state_machine.state()
+        );
+
+        // change state
+        self.query_state_machine.cancel();
+        // stop future task
+        if let Some(e) = self.abort_handle.lock().as_ref() {
+            e.abort()
+        };
+
+        debug!(
+            "canceled sql query execution: sql: {}, state: {:?}",
+            self.query_state_machine.query.content(),
+            self.query_state_machine.state()
+        );
+        Ok(())
+    }
+}
diff --git a/s3select/query/src/execution/scheduler/local.rs b/s3select/query/src/execution/scheduler/local.rs
new file mode 100644
index 00000000..e105d4b9
--- /dev/null
+++ b/s3select/query/src/execution/scheduler/local.rs
@@ -0,0 +1,22 @@
+use std::sync::Arc;
+
+use api::query::scheduler::{ExecutionResults, Scheduler};
+use async_trait::async_trait;
+use datafusion::error::DataFusionError;
+use datafusion::execution::context::TaskContext;
+use datafusion::physical_plan::{execute_stream, ExecutionPlan};
+
+pub struct LocalScheduler {}
+
+#[async_trait]
+impl Scheduler for LocalScheduler {
+    async fn schedule(
+        &self,
+        plan: Arc<dyn ExecutionPlan>,
+        context: Arc<TaskContext>,
+    ) -> Result<ExecutionResults, DataFusionError> {
+        let stream = execute_stream(plan, context)?;
+
+        Ok(ExecutionResults::new(stream))
+    }
+}
diff --git a/s3select/query/src/execution/scheduler/mod.rs b/s3select/query/src/execution/scheduler/mod.rs
new file mode 100644
index 00000000..27099624
--- /dev/null
+++ b/s3select/query/src/execution/scheduler/mod.rs
@@ -0,0 +1 @@
+pub mod local;
diff --git a/s3select/query/src/instance.rs b/s3select/query/src/instance.rs
index e27eea21..781a88f6 100644
--- a/s3select/query/src/instance.rs
+++ b/s3select/query/src/instance.rs
@@ -1,12 +1,22 @@
 use std::sync::Arc;
 
 use api::{
-    query::{dispatcher::QueryDispatcher, execution::QueryStateMachineRef, logical_planner::Plan, Query},
+    query::{
+        dispatcher::QueryDispatcher, execution::QueryStateMachineRef, logical_planner::Plan, session::SessionCtxFactory, Query,
+    },
     server::dbms::{DatabaseManagerSystem, QueryHandle},
     QueryResult,
 };
 use async_trait::async_trait;
 use derive_builder::Builder;
+use s3s::dto::SelectObjectContentInput;
+
+use crate::{
+    dispatcher::manager::SimpleQueryDispatcherBuilder,
+    execution::{factory::SqlQueryExecutionFactory, scheduler::local::LocalScheduler},
+    metadata::base_table::BaseTableProvider,
+    sql::{optimizer::CascadeOptimizerBuilder, parser::DefaultParser},
+};
 
 #[derive(Builder)]
 pub struct RustFSms<D: QueryDispatcher> {
@@ -19,10 +29,6 @@ impl<D> DatabaseManagerSystem for RustFSms<D>
 where
     D: QueryDispatcher,
 {
-    async fn start(&self) -> QueryResult<()> {
-        self.query_dispatcher.start().await
-    }
-
     async fn execute(&self, query: &Query) -> QueryResult<QueryHandle> {
         let result = self.query_dispatcher.execute_query(query).await?;
 
@@ -54,15 +60,31 @@ where
 
         Ok(QueryHandle::new(query.clone(), result))
     }
-
-    fn metrics(&self) -> String {
-        let infos = self.query_dispatcher.running_query_infos();
-        let status = self.query_dispatcher.running_query_status();
-
-        format!(
-            "infos: {}\nstatus: {}\n",
-            infos.iter().map(|e| format!("{:?}", e)).collect::<Vec<_>>().join(","),
-            status.iter().map(|e| format!("{:?}", e)).collect::<Vec<_>>().join(",")
-        )
-    }
+}
+
+pub async fn make_cnosdbms(input: SelectObjectContentInput) -> QueryResult<impl DatabaseManagerSystem> {
+    // TODO session config need load global system config
+    let session_factory = Arc::new(SessionCtxFactory {});
+    let parser = Arc::new(DefaultParser::default());
+    let optimizer = Arc::new(CascadeOptimizerBuilder::default().build());
+    // TODO wrap, and num_threads configurable
+    let scheduler = Arc::new(LocalScheduler {});
+
+    let query_execution_factory = Arc::new(SqlQueryExecutionFactory::new(optimizer, scheduler));
+
+    let default_table_provider = Arc::new(BaseTableProvider::default());
+
+    let query_dispatcher = SimpleQueryDispatcherBuilder::default()
+        .with_input(input)
+        .with_default_table_provider(default_table_provider)
+        .with_session_factory(session_factory)
+        .with_parser(parser)
+        .with_query_execution_factory(query_execution_factory)
+        .build()?;
+
+    let mut builder = RustFSmsBuilder::default();
+
+    let db_server = builder.query_dispatcher(query_dispatcher).build().expect("build db server");
+
+    Ok(db_server)
 }
diff --git a/s3select/query/src/metadata/base_table.rs b/s3select/query/src/metadata/base_table.rs
index 2a518088..4796678b 100644
--- a/s3select/query/src/metadata/base_table.rs
+++ b/s3select/query/src/metadata/base_table.rs
@@ -1,63 +1,17 @@
 use std::sync::Arc;
 
 use datafusion::common::Result as DFResult;
-use datafusion::config::{CsvOptions, JsonOptions};
-use datafusion::datasource::file_format::csv::CsvFormat;
-use datafusion::datasource::file_format::json::JsonFormat;
-use datafusion::datasource::file_format::parquet::ParquetFormat;
-use datafusion::datasource::listing::{ListingOptions, ListingTable, ListingTableConfig, ListingTableUrl};
-use datafusion::error::DataFusionError;
-use datafusion::execution::SessionState;
+use datafusion::datasource::listing::ListingTable;
 
 use crate::data_source::data_source::TableHandle;
 
 use super::TableHandleProvider;
 
-pub enum FileType {
-    Csv,
-    Parquet,
-    Json,
-    Unknown,
-}
-
 #[derive(Default)]
-pub struct BaseTableProvider {
-    file_type: FileType,
-}
-
-impl BaseTableProvider {
-    pub fn new(file_type: FileType) -> Self {
-        Self { file_type }
-    }
-}
+pub struct BaseTableProvider {}
 
 impl TableHandleProvider for BaseTableProvider {
-    async fn build_table_handle(&self, session_state: &SessionState, table_name: &str) -> DFResult<TableHandle> {
-        let table_path = ListingTableUrl::parse(table_name)?;
-        let listing_options = match self.file_type {
-            FileType::Csv => {
-                let file_format = CsvFormat::default().with_options(CsvOptions::default().with_has_header(false));
-                ListingOptions::new(Arc::new(file_format)).with_file_extension(".csv")
-            }
-            FileType::Parquet => {
-                let file_format = ParquetFormat::new();
-                ListingOptions::new(Arc::new(file_format)).with_file_extension(".parquet")
-            }
-            FileType::Json => {
-                let file_format = JsonFormat::default();
-                ListingOptions::new(Arc::new(file_format)).with_file_extension(".json")
-            }
-            FileType::Unknown => {
-                return Err(DataFusionError::NotImplemented("not support this file type".to_string()));
-            }
-        };
-
-        let resolve_schema = listing_options.infer_schema(session_state, &table_path).await?;
-        let config = ListingTableConfig::new(table_path)
-            .with_listing_options(listing_options)
-            .with_schema(resolve_schema);
-        let provider = Arc::new(ListingTable::try_new(config)?);
-
+    fn build_table_handle(&self, provider: Arc<ListingTable>) -> DFResult<TableHandle> {
         Ok(TableHandle::External(provider))
     }
 }
diff --git a/s3select/query/src/metadata/mod.rs b/s3select/query/src/metadata/mod.rs
index 5f60298a..e592460e 100644
--- a/s3select/query/src/metadata/mod.rs
+++ b/s3select/query/src/metadata/mod.rs
@@ -5,10 +5,12 @@ use api::ResolvedTable;
 use async_trait::async_trait;
 use datafusion::arrow::datatypes::DataType;
 use datafusion::common::Result as DFResult;
+use datafusion::datasource::listing::ListingTable;
 use datafusion::error::DataFusionError;
 use datafusion::execution::SessionState;
 use datafusion::logical_expr::var_provider::is_system_variables;
 use datafusion::logical_expr::{AggregateUDF, ScalarUDF, TableSource, WindowUDF};
+use datafusion::sql::ResolvedTableReference;
 use datafusion::variable::VarType;
 use datafusion::{
     config::ConfigOptions,
@@ -21,16 +23,17 @@ pub mod base_table;
 
 #[async_trait]
 pub trait ContextProviderExtension: ContextProvider {
-    fn get_table_source(&self, name: TableReference) -> datafusion::common::Result<Arc<TableSourceAdapter>>;
+    fn get_table_source_(&self, name: TableReference) -> datafusion::common::Result<Arc<TableSourceAdapter>>;
 }
 
 pub type TableHandleProviderRef = Arc<dyn TableHandleProvider + Send + Sync>;
 
 pub trait TableHandleProvider {
-    fn build_table_handle(&self, session_state: &SessionState, table_name: &str) -> DFResult<TableHandle>;
+    fn build_table_handle(&self, provider: Arc<ListingTable>) -> DFResult<TableHandle>;
 }
 
 pub struct MetadataProvider {
+    provider: Arc<ListingTable>,
     session: SessionCtx,
     config_options: ConfigOptions,
     func_manager: FuncMetaManagerRef,
@@ -40,11 +43,13 @@ pub struct MetadataProvider {
 impl MetadataProvider {
     #[allow(clippy::too_many_arguments)]
     pub fn new(
+        provider: Arc<ListingTable>,
         current_session_table_provider: TableHandleProviderRef,
         func_manager: FuncMetaManagerRef,
         session: SessionCtx,
     ) -> Self {
         Self {
+            provider,
             current_session_table_provider,
             config_options: session.inner().config_options().clone(),
             session,
@@ -52,43 +57,22 @@ impl MetadataProvider {
         }
     }
 
-    fn build_table_handle(&self, name: &ResolvedTable) -> datafusion::common::Result<TableHandle> {
-        let table_name = name.table();
-
-        self.current_session_table_provider.build_table_handle(table_name)
+    fn build_table_handle(&self) -> datafusion::common::Result<TableHandle> {
+        self.current_session_table_provider
+            .build_table_handle(self.provider.clone())
     }
+
+    async fn init(&self) {}
 }
 
-#[async_trait::async_trait]
 impl ContextProviderExtension for MetadataProvider {
-    fn get_table_source(&self, table_ref: TableReference) -> datafusion::common::Result<Arc<TableSourceAdapter>> {
-        let name = table_ref
-            .clone()
-            .resolve_object(self.session.tenant(), self.session.default_database())?;
+    fn get_table_source_(&self, table_ref: TableReference) -> datafusion::common::Result<Arc<TableSourceAdapter>> {
+        let name = table_ref.clone().resolve("", "");
+        let table_name = &*name.table;
 
-        let table_name = name.table();
-        let database_name = name.database();
-        let tenant_name = name.tenant();
+        let table_handle = self.build_table_handle()?;
 
-        // Cannot query across tenants
-        if self.session.tenant() != tenant_name {
-            return Err(DataFusionError::Plan(format!(
-                "Tenant conflict, the current connection's tenant is {}",
-                self.session.tenant()
-            )));
-        }
-
-        // save access table
-        self.access_databases.write().push_table(database_name, table_name);
-
-        let table_handle = self.build_table_handle(&name)?;
-
-        Ok(Arc::new(TableSourceAdapter::try_new(
-            table_ref.to_owned_reference(),
-            database_name,
-            table_name,
-            table_handle,
-        )?))
+        Ok(Arc::new(TableSourceAdapter::try_new(table_ref.clone(), table_name, table_handle)?))
     }
 }
 
@@ -132,7 +116,7 @@ impl ContextProvider for MetadataProvider {
     }
 
     fn get_table_source(&self, name: TableReference) -> DFResult<Arc<dyn TableSource>> {
-        Ok(self.get_table_source(name)?)
+        Ok(self.get_table_source_(name)?)
     }
 
     fn udf_names(&self) -> Vec<String> {
diff --git a/s3select/query/src/sql/analyzer.rs b/s3select/query/src/sql/analyzer.rs
new file mode 100644
index 00000000..6507c842
--- /dev/null
+++ b/s3select/query/src/sql/analyzer.rs
@@ -0,0 +1,33 @@
+use api::query::analyzer::Analyzer;
+use api::query::session::SessionCtx;
+use api::QueryResult;
+use datafusion::logical_expr::LogicalPlan;
+use datafusion::optimizer::analyzer::Analyzer as DFAnalyzer;
+
+pub struct DefaultAnalyzer {
+    inner: DFAnalyzer,
+}
+
+impl DefaultAnalyzer {
+    pub fn new() -> Self {
+        let analyzer = DFAnalyzer::default();
+        // we can add analyzer rule at here
+
+        Self { inner: analyzer }
+    }
+}
+
+impl Default for DefaultAnalyzer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Analyzer for DefaultAnalyzer {
+    fn analyze(&self, plan: &LogicalPlan, session: &SessionCtx) -> QueryResult<LogicalPlan> {
+        let plan = self
+            .inner
+            .execute_and_check(plan.to_owned(), session.inner().config_options(), |_, _| {})?;
+        Ok(plan)
+    }
+}
diff --git a/s3select/query/src/sql/dialect.rs b/s3select/query/src/sql/dialect.rs
new file mode 100644
index 00000000..33297093
--- /dev/null
+++ b/s3select/query/src/sql/dialect.rs
@@ -0,0 +1,18 @@
+use datafusion::sql::sqlparser::dialect::Dialect;
+
+#[derive(Debug, Default)]
+pub struct RustFsDialect;
+
+impl Dialect for RustFsDialect {
+    fn is_identifier_start(&self, ch: char) -> bool {
+        ch.is_alphabetic() || ch == '_' || ch == '#' || ch == '@'
+    }
+
+    fn is_identifier_part(&self, ch: char) -> bool {
+        ch.is_alphabetic() || ch.is_ascii_digit() || ch == '@' || ch == '$' || ch == '#' || ch == '_'
+    }
+
+    fn supports_group_by_expr(&self) -> bool {
+        true
+    }
+}
diff --git a/s3select/query/src/sql/logical/mod.rs b/s3select/query/src/sql/logical/mod.rs
index 5e480858..1ecfae43 100644
--- a/s3select/query/src/sql/logical/mod.rs
+++ b/s3select/query/src/sql/logical/mod.rs
@@ -1 +1,2 @@
+pub mod optimizer;
 pub mod planner;
diff --git a/s3select/query/src/sql/logical/optimizer.rs b/s3select/query/src/sql/logical/optimizer.rs
new file mode 100644
index 00000000..375667ca
--- /dev/null
+++ b/s3select/query/src/sql/logical/optimizer.rs
@@ -0,0 +1,115 @@
+use std::sync::Arc;
+
+use api::{
+    query::{analyzer::AnalyzerRef, logical_planner::QueryPlan, session::SessionCtx},
+    QueryResult,
+};
+use datafusion::{
+    execution::SessionStateBuilder,
+    logical_expr::LogicalPlan,
+    optimizer::{
+        common_subexpr_eliminate::CommonSubexprEliminate, decorrelate_predicate_subquery::DecorrelatePredicateSubquery,
+        eliminate_cross_join::EliminateCrossJoin, eliminate_duplicated_expr::EliminateDuplicatedExpr,
+        eliminate_filter::EliminateFilter, eliminate_join::EliminateJoin, eliminate_limit::EliminateLimit,
+        eliminate_outer_join::EliminateOuterJoin, extract_equijoin_predicate::ExtractEquijoinPredicate,
+        filter_null_join_keys::FilterNullJoinKeys, propagate_empty_relation::PropagateEmptyRelation,
+        push_down_filter::PushDownFilter, push_down_limit::PushDownLimit,
+        replace_distinct_aggregate::ReplaceDistinctWithAggregate, scalar_subquery_to_join::ScalarSubqueryToJoin,
+        simplify_expressions::SimplifyExpressions, single_distinct_to_groupby::SingleDistinctToGroupBy,
+        unwrap_cast_in_comparison::UnwrapCastInComparison, OptimizerRule,
+    },
+};
+use tracing::debug;
+
+use crate::sql::analyzer::DefaultAnalyzer;
+
+const PUSH_DOWN_PROJECTION_INDEX: usize = 24;
+
+pub trait LogicalOptimizer: Send + Sync {
+    fn optimize(&self, plan: &QueryPlan, session: &SessionCtx) -> QueryResult<LogicalPlan>;
+
+    fn inject_optimizer_rule(&mut self, optimizer_rule: Arc<dyn OptimizerRule + Send + Sync>);
+}
+
+pub struct DefaultLogicalOptimizer {
+    // fit datafusion
+    // TODO refactor
+    analyzer: AnalyzerRef,
+    rules: Vec<Arc<dyn OptimizerRule + Send + Sync>>,
+}
+
+impl DefaultLogicalOptimizer {
+    #[allow(dead_code)]
+    fn with_optimizer_rules(mut self, rules: Vec<Arc<dyn OptimizerRule + Send + Sync>>) -> Self {
+        self.rules = rules;
+        self
+    }
+}
+
+impl Default for DefaultLogicalOptimizer {
+    fn default() -> Self {
+        let analyzer = Arc::new(DefaultAnalyzer::default());
+
+        // additional optimizer rule
+        let rules: Vec<Arc<dyn OptimizerRule + Send + Sync>> = vec![
+            // df default rules start
+            Arc::new(SimplifyExpressions::new()),
+            Arc::new(UnwrapCastInComparison::new()),
+            Arc::new(ReplaceDistinctWithAggregate::new()),
+            Arc::new(EliminateJoin::new()),
+            Arc::new(DecorrelatePredicateSubquery::new()),
+            Arc::new(ScalarSubqueryToJoin::new()),
+            Arc::new(ExtractEquijoinPredicate::new()),
+            // simplify expressions does not simplify expressions in subqueries, so we
+            // run it again after running the optimizations that potentially converted
+            // subqueries to joins
+            Arc::new(SimplifyExpressions::new()),
+            Arc::new(EliminateDuplicatedExpr::new()),
+            Arc::new(EliminateFilter::new()),
+            Arc::new(EliminateCrossJoin::new()),
+            Arc::new(CommonSubexprEliminate::new()),
+            Arc::new(EliminateLimit::new()),
+            Arc::new(PropagateEmptyRelation::new()),
+            Arc::new(FilterNullJoinKeys::default()),
+            Arc::new(EliminateOuterJoin::new()),
+            // Filters can't be pushed down past Limits, we should do PushDownFilter after PushDownLimit
+            Arc::new(PushDownLimit::new()),
+            Arc::new(PushDownFilter::new()),
+            Arc::new(SingleDistinctToGroupBy::new()),
+            // The previous optimizations added expressions and projections,
+            // that might benefit from the following rules
+            Arc::new(SimplifyExpressions::new()),
+            Arc::new(UnwrapCastInComparison::new()),
+            Arc::new(CommonSubexprEliminate::new()),
+            // PushDownProjection can pushdown Projections through Limits, do PushDownLimit again.
+            Arc::new(PushDownLimit::new()),
+            // df default rules end
+            // custom rules can add at here
+        ];
+
+        Self { analyzer, rules }
+    }
+}
+
+impl LogicalOptimizer for DefaultLogicalOptimizer {
+    fn optimize(&self, plan: &QueryPlan, session: &SessionCtx) -> QueryResult<LogicalPlan> {
+        let analyzed_plan = { self.analyzer.analyze(&plan.df_plan, session).map(|p| p).map_err(|e| e)? };
+
+        debug!("Analyzed logical plan:\n{}\n", plan.df_plan.display_indent_schema(),);
+
+        let optimizeed_plan = {
+            SessionStateBuilder::new_from_existing(session.inner().clone())
+                .with_optimizer_rules(self.rules.clone())
+                .build()
+                .optimize(&analyzed_plan)
+                .map(|p| p)
+                .map_err(|e| e)?
+        };
+
+        Ok(optimizeed_plan)
+    }
+
+    fn inject_optimizer_rule(&mut self, optimizer_rule: Arc<dyn OptimizerRule + Send + Sync>) {
+        self.rules.push(optimizer_rule);
+    }
+}
diff --git a/s3select/query/src/sql/mod.rs b/s3select/query/src/sql/mod.rs
index 74b97905..151fc83d 100644
--- a/s3select/query/src/sql/mod.rs
+++ b/s3select/query/src/sql/mod.rs
@@ -1,3 +1,7 @@
+pub mod analyzer;
+pub mod dialect;
 pub mod logical;
+pub mod optimizer;
+pub mod parser;
 pub mod physical;
 pub mod planner;
diff --git a/s3select/query/src/sql/optimizer.rs b/s3select/query/src/sql/optimizer.rs
new file mode 100644
index 00000000..2b546547
--- /dev/null
+++ b/s3select/query/src/sql/optimizer.rs
@@ -0,0 +1,89 @@
+use std::sync::Arc;
+
+use api::{
+    query::{logical_planner::QueryPlan, optimizer::Optimizer, physical_planner::PhysicalPlanner, session::SessionCtx},
+    QueryResult,
+};
+use async_trait::async_trait;
+use datafusion::physical_plan::{displayable, ExecutionPlan};
+use tracing::debug;
+
+use super::{
+    logical::optimizer::{DefaultLogicalOptimizer, LogicalOptimizer},
+    physical::{optimizer::PhysicalOptimizer, planner::DefaultPhysicalPlanner},
+};
+
+pub struct CascadeOptimizer {
+    logical_optimizer: Arc<dyn LogicalOptimizer + Send + Sync>,
+    physical_planner: Arc<dyn PhysicalPlanner + Send + Sync>,
+    physical_optimizer: Arc<dyn PhysicalOptimizer + Send + Sync>,
+}
+
+#[async_trait]
+impl Optimizer for CascadeOptimizer {
+    async fn optimize(&self, plan: &QueryPlan, session: &SessionCtx) -> QueryResult<Arc<dyn ExecutionPlan>> {
+        debug!("Original logical plan:\n{}\n", plan.df_plan.display_indent_schema(),);
+
+        let optimized_logical_plan = self.logical_optimizer.optimize(plan, session)?;
+
+        debug!("Final logical plan:\n{}\n", optimized_logical_plan.display_indent_schema(),);
+
+        let physical_plan = {
+            self.physical_planner
+                .create_physical_plan(&optimized_logical_plan, session)
+                .await
+                .map(|p| p)
+                .map_err(|err| err)?
+        };
+
+        debug!("Original physical plan:\n{}\n", displayable(physical_plan.as_ref()).indent(false));
+
+        let optimized_physical_plan = {
+            self.physical_optimizer
+                .optimize(physical_plan, session)
+                .map(|p| p)
+                .map_err(|err| err)?
+        };
+
+        Ok(optimized_physical_plan)
+    }
+}
+
+#[derive(Default)]
+pub struct CascadeOptimizerBuilder {
+    logical_optimizer: Option<Arc<dyn LogicalOptimizer + Send + Sync>>,
+    physical_planner: Option<Arc<dyn PhysicalPlanner + Send + Sync>>,
+    physical_optimizer: Option<Arc<dyn PhysicalOptimizer + Send + Sync>>,
+}
+
+impl CascadeOptimizerBuilder {
+    pub fn with_logical_optimizer(mut self, logical_optimizer: Arc<dyn LogicalOptimizer + Send + Sync>) -> Self {
+        self.logical_optimizer = Some(logical_optimizer);
+        self
+    }
+
+    pub fn with_physical_planner(mut self, physical_planner: Arc<dyn PhysicalPlanner + Send + Sync>) -> Self {
+        self.physical_planner = Some(physical_planner);
+        self
+    }
+
+    pub fn with_physical_optimizer(mut self, physical_optimizer: Arc<dyn PhysicalOptimizer + Send + Sync>) -> Self {
+        self.physical_optimizer = Some(physical_optimizer);
+        self
+    }
+
+    pub fn build(self) -> CascadeOptimizer {
+        let default_logical_optimizer = Arc::new(DefaultLogicalOptimizer::default());
+        let default_physical_planner = Arc::new(DefaultPhysicalPlanner::default());
+
+        let logical_optimizer = self.logical_optimizer.unwrap_or(default_logical_optimizer);
+        let physical_planner = self.physical_planner.unwrap_or_else(|| default_physical_planner.clone());
+        let physical_optimizer = self.physical_optimizer.unwrap_or(default_physical_planner);
+
+        CascadeOptimizer {
+            logical_optimizer,
+            physical_planner,
+            physical_optimizer,
+        }
+    }
+}
diff --git a/s3select/query/src/sql/parser.rs b/s3select/query/src/sql/parser.rs
new file mode 100644
index 00000000..80f8d0db
--- /dev/null
+++ b/s3select/query/src/sql/parser.rs
@@ -0,0 +1,97 @@
+use std::{collections::VecDeque, fmt::Display};
+
+use api::{
+    query::{ast::ExtStatement, parser::Parser as RustFsParser},
+    ParserSnafu,
+};
+use datafusion::sql::sqlparser::{
+    dialect::Dialect,
+    parser::{Parser, ParserError},
+    tokenizer::{Token, Tokenizer},
+};
+use snafu::ResultExt;
+
+use super::dialect::RustFsDialect;
+
+pub type Result<T, E = ParserError> = std::result::Result<T, E>;
+
+// Use `Parser::expected` instead, if possible
+macro_rules! parser_err {
+    ($MSG:expr) => {
+        Err(ParserError::ParserError($MSG.to_string()))
+    };
+}
+
+#[derive(Default)]
+pub struct DefaultParser {}
+
+impl RustFsParser for DefaultParser {
+    fn parse(&self, sql: &str) -> api::QueryResult<VecDeque<ExtStatement>> {
+        ExtParser::parse_sql(sql).context(ParserSnafu)
+    }
+}
+
+/// SQL Parser
+pub struct ExtParser<'a> {
+    parser: Parser<'a>,
+}
+
+impl<'a> ExtParser<'a> {
+    /// Parse the specified tokens with dialect
+    fn new_with_dialect(sql: &str, dialect: &'a dyn Dialect) -> Result<Self> {
+        let mut tokenizer = Tokenizer::new(dialect, sql);
+        let tokens = tokenizer.tokenize()?;
+        Ok(ExtParser {
+            parser: Parser::new(dialect).with_tokens(tokens),
+        })
+    }
+
+    /// Parse a SQL statement and produce a set of statements
+    pub fn parse_sql(sql: &str) -> Result<VecDeque<ExtStatement>> {
+        let dialect = &RustFsDialect {};
+        ExtParser::parse_sql_with_dialect(sql, dialect)
+    }
+
+    /// Parse a SQL statement and produce a set of statements
+    pub fn parse_sql_with_dialect(sql: &str, dialect: &dyn Dialect) -> Result<VecDeque<ExtStatement>> {
+        let mut parser = ExtParser::new_with_dialect(sql, dialect)?;
+        let mut stmts = VecDeque::new();
+        let mut expecting_statement_delimiter = false;
+        loop {
+            // ignore empty statements (between successive statement delimiters)
+            while parser.parser.consume_token(&Token::SemiColon) {
+                expecting_statement_delimiter = false;
+            }
+
+            if parser.parser.peek_token() == Token::EOF {
+                break;
+            }
+            if expecting_statement_delimiter {
+                return parser.expected("end of statement", parser.parser.peek_token());
+            }
+
+            let statement = parser.parse_statement()?;
+            stmts.push_back(statement);
+            expecting_statement_delimiter = true;
+        }
+
+        // debug!("Parser sql: {}, stmts: {:#?}", sql, stmts);
+
+        Ok(stmts)
+    }
+
+    /// Parse a new expression
+    fn parse_statement(&mut self) -> Result<ExtStatement> {
+        match self.parser.peek_token().token {
+            Token::Word(w) => match w.keyword {
+                _ => Ok(ExtStatement::SqlStatement(Box::new(self.parser.parse_statement()?))),
+            },
+            _ => Ok(ExtStatement::SqlStatement(Box::new(self.parser.parse_statement()?))),
+        }
+    }
+
+    // Report unexpected token
+    fn expected<T>(&self, expected: &str, found: impl Display) -> Result<T> {
+        parser_err!(format!("Expected {}, found: {}", expected, found))
+    }
+}
diff --git a/s3select/query/src/sql/physical/mod.rs b/s3select/query/src/sql/physical/mod.rs
index 8b137891..1ecfae43 100644
--- a/s3select/query/src/sql/physical/mod.rs
+++ b/s3select/query/src/sql/physical/mod.rs
@@ -1 +1,2 @@
-
+pub mod optimizer;
+pub mod planner;
diff --git a/s3select/query/src/sql/physical/optimizer.rs b/s3select/query/src/sql/physical/optimizer.rs
new file mode 100644
index 00000000..12f16e3d
--- /dev/null
+++ b/s3select/query/src/sql/physical/optimizer.rs
@@ -0,0 +1,12 @@
+use std::sync::Arc;
+
+use api::query::session::SessionCtx;
+use api::QueryResult;
+use datafusion::physical_optimizer::PhysicalOptimizerRule;
+use datafusion::physical_plan::ExecutionPlan;
+
+pub trait PhysicalOptimizer {
+    fn optimize(&self, plan: Arc<dyn ExecutionPlan>, session: &SessionCtx) -> QueryResult<Arc<dyn ExecutionPlan>>;
+
+    fn inject_optimizer_rule(&mut self, optimizer_rule: Arc<dyn PhysicalOptimizerRule + Send + Sync>);
+}
diff --git a/s3select/query/src/sql/physical/planner.rs b/s3select/query/src/sql/physical/planner.rs
new file mode 100644
index 00000000..254c198d
--- /dev/null
+++ b/s3select/query/src/sql/physical/planner.rs
@@ -0,0 +1,104 @@
+use std::sync::Arc;
+
+use api::query::physical_planner::PhysicalPlanner;
+use api::query::session::SessionCtx;
+use api::QueryResult;
+use async_trait::async_trait;
+use datafusion::execution::SessionStateBuilder;
+use datafusion::logical_expr::LogicalPlan;
+use datafusion::physical_optimizer::aggregate_statistics::AggregateStatistics;
+use datafusion::physical_optimizer::coalesce_batches::CoalesceBatches;
+use datafusion::physical_optimizer::join_selection::JoinSelection;
+use datafusion::physical_optimizer::PhysicalOptimizerRule;
+use datafusion::physical_plan::ExecutionPlan;
+use datafusion::physical_planner::{
+    DefaultPhysicalPlanner as DFDefaultPhysicalPlanner, ExtensionPlanner, PhysicalPlanner as DFPhysicalPlanner,
+};
+
+use super::optimizer::PhysicalOptimizer;
+
+pub struct DefaultPhysicalPlanner {
+    ext_physical_transform_rules: Vec<Arc<dyn ExtensionPlanner + Send + Sync>>,
+    /// Responsible for optimizing a physical execution plan
+    ext_physical_optimizer_rules: Vec<Arc<dyn PhysicalOptimizerRule + Send + Sync>>,
+}
+
+impl DefaultPhysicalPlanner {
+    #[allow(dead_code)]
+    fn with_physical_transform_rules(mut self, rules: Vec<Arc<dyn ExtensionPlanner + Send + Sync>>) -> Self {
+        self.ext_physical_transform_rules = rules;
+        self
+    }
+}
+
+impl DefaultPhysicalPlanner {
+    #[allow(dead_code)]
+    fn with_optimizer_rules(mut self, rules: Vec<Arc<dyn PhysicalOptimizerRule + Send + Sync>>) -> Self {
+        self.ext_physical_optimizer_rules = rules;
+        self
+    }
+}
+
+impl Default for DefaultPhysicalPlanner {
+    fn default() -> Self {
+        let ext_physical_transform_rules: Vec<Arc<dyn ExtensionPlanner + Send + Sync>> = vec![
+            // can add rules at here
+        ];
+
+        // We need to take care of the rule ordering. They may influence each other.
+        let ext_physical_optimizer_rules: Vec<Arc<dyn PhysicalOptimizerRule + Sync + Send>> = vec![
+            Arc::new(AggregateStatistics::new()),
+            // Statistics-based join selection will change the Auto mode to a real join implementation,
+            // like collect left, or hash join, or future sort merge join, which will influence the
+            // EnforceDistribution and EnforceSorting rules as they decide whether to add additional
+            // repartitioning and local sorting steps to meet distribution and ordering requirements.
+            // Therefore, it should run before EnforceDistribution and EnforceSorting.
+            Arc::new(JoinSelection::new()),
+            // The CoalesceBatches rule will not influence the distribution and ordering of the
+            // whole plan tree. Therefore, to avoid influencing other rules, it should run last.
+            Arc::new(CoalesceBatches::new()),
+        ];
+
+        Self {
+            ext_physical_transform_rules,
+            ext_physical_optimizer_rules,
+        }
+    }
+}
+
+#[async_trait]
+impl PhysicalPlanner for DefaultPhysicalPlanner {
+    async fn create_physical_plan(
+        &self,
+        logical_plan: &LogicalPlan,
+        session: &SessionCtx,
+    ) -> QueryResult<Arc<dyn ExecutionPlan>> {
+        // 将扩展的物理计划优化规则注入df 的 session state
+        let new_state = SessionStateBuilder::new_from_existing(session.inner().clone())
+            .with_physical_optimizer_rules(self.ext_physical_optimizer_rules.clone())
+            .build();
+
+        // 通过扩展的物理计划转换规则构造df 的 Physical Planner
+        let planner = DFDefaultPhysicalPlanner::with_extension_planners(self.ext_physical_transform_rules.clone());
+
+        // 执行df的物理计划规划及优化
+        planner
+            .create_physical_plan(logical_plan, &new_state)
+            .await
+            .map_err(|e| e.into())
+    }
+
+    fn inject_physical_transform_rule(&mut self, rule: Arc<dyn ExtensionPlanner + Send + Sync>) {
+        self.ext_physical_transform_rules.push(rule)
+    }
+}
+
+impl PhysicalOptimizer for DefaultPhysicalPlanner {
+    fn optimize(&self, plan: Arc<dyn ExecutionPlan>, _session: &SessionCtx) -> QueryResult<Arc<dyn ExecutionPlan>> {
+        Ok(plan)
+    }
+
+    fn inject_optimizer_rule(&mut self, optimizer_rule: Arc<dyn PhysicalOptimizerRule + Send + Sync>) {
+        self.ext_physical_optimizer_rules.push(optimizer_rule);
+    }
+}
diff --git a/s3select/query/src/sql/planner.rs b/s3select/query/src/sql/planner.rs
index 0d468843..be6b314d 100644
--- a/s3select/query/src/sql/planner.rs
+++ b/s3select/query/src/sql/planner.rs
@@ -1,4 +1,14 @@
-use datafusion::sql::planner::SqlToRel;
+use api::{
+    query::{
+        ast::ExtStatement,
+        logical_planner::{LogicalPlanner, Plan, QueryPlan},
+        session::SessionCtx,
+    },
+    QueryError, QueryResult,
+};
+use async_recursion::async_recursion;
+use async_trait::async_trait;
+use datafusion::sql::{planner::SqlToRel, sqlparser::ast::Statement};
 
 use crate::metadata::ContextProviderExtension;
 
@@ -6,3 +16,45 @@ pub struct SqlPlanner<'a, S: ContextProviderExtension> {
     schema_provider: &'a S,
     df_planner: SqlToRel<'a, S>,
 }
+
+#[async_trait]
+impl<'a, S: ContextProviderExtension + Send + Sync> LogicalPlanner for SqlPlanner<'a, S> {
+    async fn create_logical_plan(&self, statement: ExtStatement, session: &SessionCtx) -> QueryResult<Plan> {
+        let plan = { self.statement_to_plan(statement, session).await.map_err(|err| err)? };
+
+        Ok(plan)
+    }
+}
+
+impl<'a, S: ContextProviderExtension + Send + Sync + 'a> SqlPlanner<'a, S> {
+    /// Create a new query planner
+    pub fn new(schema_provider: &'a S) -> Self {
+        SqlPlanner {
+            schema_provider,
+            df_planner: SqlToRel::new(schema_provider),
+        }
+    }
+
+    /// Generate a logical plan from an  Extent SQL statement
+    #[async_recursion]
+    pub(crate) async fn statement_to_plan(&self, statement: ExtStatement, session: &SessionCtx) -> QueryResult<Plan> {
+        match statement {
+            ExtStatement::SqlStatement(stmt) => self.df_sql_to_plan(*stmt, session).await,
+        }
+    }
+
+    async fn df_sql_to_plan(&self, stmt: Statement, _session: &SessionCtx) -> QueryResult<Plan> {
+        match stmt {
+            Statement::Query(_) => {
+                let df_plan = self.df_planner.sql_statement_to_plan(stmt)?;
+                let plan = Plan::Query(QueryPlan {
+                    df_plan,
+                    is_tag_scan: false,
+                });
+
+                Ok(plan)
+            }
+            _ => Err(QueryError::NotImplemented { err: stmt.to_string() }),
+        }
+    }
+}