remote make bucket

Signed-off-by: junxiang Mu <1948535941@qq.com>

common/protos/build.rs

@@ -40,8 +40,8 @@ fn main() -> Result<(), AnyError> {
     let project_root_dir = env::current_dir()?;
     let proto_dir = project_root_dir.join("src");
     let proto_files = &["node.proto"];
-    let proto_out_dir = project_root_dir.join("src").join("proto_gen");
-    let flatbuffer_out_dir = project_root_dir.join("src").join("flatbuffers_generated");
+    let proto_out_dir = project_root_dir.join("src").join("generated").join("proto_gen");
+    let flatbuffer_out_dir = project_root_dir.join("src").join("generated").join("flatbuffers_generated");
     let descriptor_set_path = PathBuf::from(env::var(ENV_OUT_DIR).unwrap()).join("proto-descriptor.bin");
 
     tonic_build::configure()
@@ -54,13 +54,17 @@ fn main() -> Result<(), AnyError> {
         .map_err(|e| format!("Failed to generate protobuf file: {e}."))?;
 
     // protos/gen/mod.rs
-    let generated_mod_rs_path = project_root_dir.join("src").join("proto_gen").join("mod.rs");
+    let generated_mod_rs_path = project_root_dir
+        .join("src")
+        .join("generated")
+        .join("proto_gen")
+        .join("mod.rs");
 
     let mut generated_mod_rs = fs::File::create(generated_mod_rs_path)?;
     writeln!(&mut generated_mod_rs, "pub mod node_service;")?;
     generated_mod_rs.flush()?;
 
-    let generated_mod_rs_path = project_root_dir.join("src").join("lib.rs");
+    let generated_mod_rs_path = project_root_dir.join("src").join("generated").join("mod.rs");
 
     let mut generated_mod_rs = fs::File::create(generated_mod_rs_path)?;
     writeln!(&mut generated_mod_rs, "#![allow(unused_imports)]")?;

common/protos/src/generated/mod.rs

@@ -0,0 +1,6 @@
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+pub mod proto_gen;
+
+mod flatbuffers_generated;
+pub use flatbuffers_generated::models::*;

common/protos/src/generated/proto_gen/node_service.rs

@@ -16,6 +16,28 @@ pub struct PingResponse {
     #[prost(bytes = "vec", tag = "2")]
     pub body: ::prost::alloc::vec::Vec<u8>,
 }
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct MakeBucketOptions {
+    #[prost(bool, tag = "1")]
+    pub force_create: bool,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MakeBucketRequest {
+    #[prost(string, tag = "1")]
+    pub name: ::prost::alloc::string::String,
+    #[prost(message, optional, tag = "2")]
+    pub options: ::core::option::Option<MakeBucketOptions>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MakeBucketResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, optional, tag = "2")]
+    pub error_info: ::core::option::Option<::prost::alloc::string::String>,
+}
 /// Generated client implementations.
 pub mod node_service_client {
     #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
@@ -109,6 +131,21 @@ pub mod node_service_client {
                 .insert(GrpcMethod::new("node_service.NodeService", "Ping"));
             self.inner.unary(req, path, codec).await
         }
+        pub async fn make_bucket(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MakeBucketRequest>,
+        ) -> std::result::Result<tonic::Response<super::MakeBucketResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::new(tonic::Code::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 mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("node_service.NodeService", "MakeBucket"));
+            self.inner.unary(req, path, codec).await
+        }
     }
 }
 /// Generated server implementations.
@@ -122,6 +159,10 @@ pub mod node_service_server {
             &self,
             request: tonic::Request<super::PingRequest>,
         ) -> std::result::Result<tonic::Response<super::PingResponse>, tonic::Status>;
+        async fn make_bucket(
+            &self,
+            request: tonic::Request<super::MakeBucketRequest>,
+        ) -> std::result::Result<tonic::Response<super::MakeBucketResponse>, tonic::Status>;
     }
     #[derive(Debug)]
     pub struct NodeServiceServer<T: NodeService> {
@@ -221,6 +262,34 @@ pub mod node_service_server {
                     };
                     Box::pin(fut)
                 }
+                "/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> {
+                        type Response = super::MakeBucketResponse;
+                        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 };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = 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);
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
                 _ => Box::pin(async move {
                     Ok(http::Response::builder()
                         .status(200)

common/protos/src/lib.rs

@@ -1,6 +1,28 @@
-#![allow(unused_imports)]
-#![allow(clippy::all)]
-pub mod proto_gen;
+mod generated;
+use std::time::Duration;
 
-mod flatbuffers_generated;
-pub use flatbuffers_generated::models::*;
+pub use generated::*;
+use proto_gen::node_service::node_service_client::NodeServiceClient;
+use tonic::{codec::CompressionEncoding, transport::Channel};
+use tower::timeout::Timeout;
+
+// Default 100 MB
+pub const DEFAULT_GRPC_SERVER_MESSAGE_LEN: usize = 100 * 1024 * 1024;
+
+pub fn node_service_time_out_client(
+    channel: Channel,
+    time_out: Duration,
+    max_message_size: usize,
+    grpc_enable_gzip: bool,
+) -> NodeServiceClient<Timeout<Channel>> {
+    let timeout_channel = Timeout::new(channel, time_out);
+    let client = NodeServiceClient::<Timeout<Channel>>::new(timeout_channel);
+    let client = NodeServiceClient::max_decoding_message_size(client, max_message_size);
+    if grpc_enable_gzip {
+        NodeServiceClient::max_encoding_message_size(client, max_message_size)
+            .accept_compressed(CompressionEncoding::Gzip)
+            .send_compressed(CompressionEncoding::Gzip)
+    } else {
+        NodeServiceClient::max_encoding_message_size(client, max_message_size)
+    }
+}

common/protos/src/node.proto

@@ -12,8 +12,23 @@ message PingResponse {
   bytes body = 2;
 }
 
+message MakeBucketOptions {
+  bool force_create = 1;
+}
+
+message MakeBucketRequest {
+  string name = 1;
+  MakeBucketOptions options = 2;
+}
+
+message MakeBucketResponse {
+  bool success = 1;
+  optional string error_info = 2;
+}
+
 /* -------------------------------------------------------------------- */
 
 service NodeService {
   rpc Ping(PingRequest) returns (PingResponse) {};
+  rpc MakeBucket(MakeBucketRequest) returns (MakeBucketResponse) {};
 }