Replace the generated file to the generated folder

Signed-off-by: Aisuko <[email protected]>

backend/rust/Cargo.toml

@@ -3,4 +3,5 @@ resolver = "2"
 members = [
     "bunker",
     "burn",
+    "codegen",
 ]

backend/rust/Makefile

@@ -0,0 +1,30 @@
+# default are fmt and then check
+.DEFAULT_GOAL := all
+
+.PHONY: all
+all: fmt check
+
+.PHONY: fmt
+fmt:
+	@echo "Formatting code..."
+	@cargo fmt --all -- --check
+
+.PHONY: build
+build:
+	@echo "Building..."
+	@cargo build --release
+
+.PHONY: test
+test:
+	@echo "Testing..."
+	@cargo test --all
+
+.PHONY: check
+check:
+	@echo "Checking..."
+	@cargo check --all
+
+.PHONY: clean
+clean:
+	@echo "Cleaning..."
+	@cargo clean

backend/rust/README.md

@@ -30,10 +30,8 @@ macOS
 brew install protobuf
 ```
 
-### Generating the server side code
-
-> Rust backend uses the same proto file with the other backends, so we should keep the same interface of the backend. So, the output file of backend.rs is in the /target folder and do not need to be managed by git.
+### Cargo fmt all the code
 
 ```
-make build
+cargo fmt --all --check
 ```

backend/rust/bunker/Cargo.toml

@@ -6,7 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-tonic = "0.10"
+tonic = { version = "0.10", features = [] }
 prost = "0.12"
 tokio = { version = "1.0", features = ["rt-multi-thread", "macros", "sync", "time"] }
 tokio-stream = "0.1"
@@ -16,6 +16,5 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 rand = "0.7"
 async-trait = "0.1.74"
-
-[build-dependencies]
-tonic-build = "0.10"
+tracing-subscriber = "0.3.17"
+tracing = "0.1.39"

backend/rust/bunker/src/lib.rs

@@ -1,5 +1,6 @@
-pub mod service;
+/// Import the code() backend.rs was generated from backend.proto
+pub mod pb {
+    include!("../generated/backend.rs");
+}
 
-pub mod pb{
-    include!("backend.rs");
-}
+pub mod service;

backend/rust/bunker/src/service.rs

@@ -1,21 +1,43 @@
-use crate::pb::{HealthMessage, PredictOptions,Reply,ModelOptions, EmbeddingResult, GenerateImageRequest,TranscriptRequest,TranscriptResult,TtsRequest,TokenizationResponse,StatusResponse};
+//! Contains the service trait for the bunker service.
+
 use crate::pb::Result as PbResult;
-use tonic::{Request, Response, Status};
-use tokio_stream::wrappers::ReceiverStream;
+use crate::pb::{
+    EmbeddingResult, GenerateImageRequest, HealthMessage, ModelOptions, PredictOptions, Reply,
+    StatusResponse, TokenizationResponse, TranscriptRequest, TranscriptResult, TtsRequest,
+};
 use async_trait::async_trait;
-
+use tokio_stream::wrappers::ReceiverStream;
+use tonic::{Request, Response, Status};
 
 #[async_trait]
-pub trait BackendService<T = ReceiverStream<Result<Reply, Status>>>{
-    async fn health(&self, request: Request<HealthMessage>) -> Result<Response<Reply>,Status>;
-    async fn predict(&self, request: Request<PredictOptions>) -> Result<Response<Reply>,Status>;
-    async fn load_model(&self, request: Request<ModelOptions>) -> Result<Response<PbResult>,Status>;
-    async fn predict_stream(&self, request: Request<PredictOptions>) -> Result<Response<T>,Status>; // https://github.com/rust-lang/rust/issues/29661
-    async fn embedding(&self, request: Request<PredictOptions>) -> Result<Response<EmbeddingResult>,Status>;
-    async fn generate_image(&self, request: Request<GenerateImageRequest>) -> Result<Response<PbResult>,Status>;
-    async fn audio_transcription(&self, request: Request<TranscriptRequest>) -> Result<Response<TranscriptResult>,Status>;
-    async fn tts(&self, request: Request<TtsRequest>) -> Result<Response<PbResult>,Status>;
-    async fn tokenize_string(&self, request: Request<PredictOptions>) -> Result<Response<TokenizationResponse>,Status>;
-    async fn status(&self, request: Request<HealthMessage>) -> Result<Response<StatusResponse>,Status>;
-
-}
+pub trait BackendService<T = ReceiverStream<Result<Reply, Status>>> {
+    async fn health(&self, request: Request<HealthMessage>) -> Result<Response<Reply>, Status>;
+    async fn predict(&self, request: Request<PredictOptions>) -> Result<Response<Reply>, Status>;
+    async fn load_model(
+        &self,
+        request: Request<ModelOptions>,
+    ) -> Result<Response<PbResult>, Status>;
+    async fn predict_stream(&self, request: Request<PredictOptions>)
+        -> Result<Response<T>, Status>; // https://github.com/rust-lang/rust/issues/29661
+    async fn embedding(
+        &self,
+        request: Request<PredictOptions>,
+    ) -> Result<Response<EmbeddingResult>, Status>;
+    async fn generate_image(
+        &self,
+        request: Request<GenerateImageRequest>,
+    ) -> Result<Response<PbResult>, Status>;
+    async fn audio_transcription(
+        &self,
+        request: Request<TranscriptRequest>,
+    ) -> Result<Response<TranscriptResult>, Status>;
+    async fn tts(&self, request: Request<TtsRequest>) -> Result<Response<PbResult>, Status>;
+    async fn tokenize_string(
+        &self,
+        request: Request<PredictOptions>,
+    ) -> Result<Response<TokenizationResponse>, Status>;
+    async fn status(
+        &self,
+        request: Request<HealthMessage>,
+    ) -> Result<Response<StatusResponse>, Status>;
+}

backend/rust/burn/Cargo.toml

@@ -9,15 +9,7 @@ edition = "2021"
 
 # import bunker here
 bunker = { path = "../bunker" }
-
-tonic = "0.10"
-prost = "0.12"
-tokio = { version = "1.0", features = ["rt-multi-thread", "macros", "sync", "time"] }
-tokio-stream = "0.1"
-
-async-stream = "0.2"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-rand = "0.7"
-tracing = "0.1"
-tracing-subscriber = "0.3"
+tokio = "1.33.0"
+async-trait = "0.1.74"
+tonic = "0.10.2"
+tokio-stream = "0.1.14"

backend/rust/burn/src/main.rs

@@ -1,89 +1,88 @@
-use tokio_stream::wrappers::ReceiverStream;
-use tonic::transport::Server;
-use tonic::{async_trait, Request, Response, Status};
-use tracing;
-use tracing_subscriber;
-use bunker::pb::{EmbeddingResult, GenerateImageRequest, HealthMessage, ModelOptions, PredictOptions, Reply, StatusResponse, TokenizationResponse, TranscriptRequest, TranscriptResult, TtsRequest};
 use bunker::pb::Result as PbResult;
+use bunker::pb::{
+    EmbeddingResult, GenerateImageRequest, HealthMessage, ModelOptions, PredictOptions, Reply,
+    StatusResponse, TokenizationResponse, TranscriptRequest, TranscriptResult, TtsRequest,
+};
 use bunker::service::BackendService;
+use tokio_stream::wrappers::ReceiverStream;
+use tonic::{Request, Response, Status};
 
+use async_trait::async_trait;
 
 // implement BackendService trait in bunker
 
 struct BurnBackend;
 
 #[async_trait]
-impl BackendService<ReceiverStream<Result<Reply, Status>>> for BurnBackend{
-
-    async fn health(&self, request: Request<HealthMessage>) -> Result<Response<Reply>,Status> {
+impl BackendService<ReceiverStream<Result<Reply, Status>>> for BurnBackend {
+    async fn health(&self, request: Request<HealthMessage>) -> Result<Response<Reply>, Status> {
         // return a Result<Response<Reply>,Status>
         let reply = Reply {
             message: "OK".into(),
         };
-        let res=Response::new(reply);
+        let res = Response::new(reply);
         Ok(res)
     }
 
-    async fn predict(&self, request: Request<PredictOptions>) -> Result<Response<Reply>,Status> {
+    async fn predict(&self, request: Request<PredictOptions>) -> Result<Response<Reply>, Status> {
         todo!()
     }
 
-    async fn load_model(&self, request: Request<ModelOptions>) -> Result<Response<PbResult>, Status> {
+    async fn load_model(
+        &self,
+        request: Request<ModelOptions>,
+    ) -> Result<Response<PbResult>, Status> {
         todo!()
     }
 
-    async fn predict_stream(&self, request: Request<PredictOptions>) -> Result<Response<ReceiverStream<Result<Reply,Status>>>, Status> {
+    async fn predict_stream(
+        &self,
+        request: Request<PredictOptions>,
+    ) -> Result<Response<ReceiverStream<Result<Reply, Status>>>, Status> {
         todo!()
     }
 
-    async fn embedding(&self, request: Request<PredictOptions>) -> Result<Response<EmbeddingResult>, Status> {
+    async fn embedding(
+        &self,
+        request: Request<PredictOptions>,
+    ) -> Result<Response<EmbeddingResult>, Status> {
         todo!()
     }
 
-    async fn generate_image(&self, request: Request<GenerateImageRequest>) -> Result<Response<PbResult>, Status> {
+    async fn generate_image(
+        &self,
+        request: Request<GenerateImageRequest>,
+    ) -> Result<Response<PbResult>, Status> {
         todo!()
     }
 
-    async fn audio_transcription(&self, request: Request<TranscriptRequest>) -> Result<Response<TranscriptResult>, Status> {
+    async fn audio_transcription(
+        &self,
+        request: Request<TranscriptRequest>,
+    ) -> Result<Response<TranscriptResult>, Status> {
         todo!()
     }
 
     async fn tts(&self, request: Request<TtsRequest>) -> Result<Response<PbResult>, Status> {
         todo!()
     }
 
-    async fn tokenize_string(&self, request: Request<PredictOptions>) -> Result<Response<TokenizationResponse>, Status> {
+    async fn tokenize_string(
+        &self,
+        request: Request<PredictOptions>,
+    ) -> Result<Response<TokenizationResponse>, Status> {
         todo!()
     }
 
-    async fn status(&self, request: Request<HealthMessage>) -> Result<Response<StatusResponse>, Status> {
+    async fn status(
+        &self,
+        request: Request<HealthMessage>,
+    ) -> Result<Response<StatusResponse>, Status> {
         todo!()
     }
-
 }
 
-
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-
-    let subscriber = tracing_subscriber::fmt()
-        .compact()
-        .with_file(true)
-        .with_line_number(true)
-        .with_target(true)
-        .with_level(true)
-        .finish();
-
-    tracing::subscriber::set_global_default(subscriber)
-        .expect("setting default subscriber failed");
-
-    let addr = "[::1]:50052".parse().unwrap();
-
-    let backend = BackendService {};
-
-    let svc = BurnBackend::new(backend);
-
-    Server::builder().add_service(svc).serve(addr).await?;
-
-    Ok(())
+    todo!()
 }

backend/rust/codegen/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "codegen"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[build-dependencies]
+tonic-build = "0.10"

backend/rust/codegen/build.rs

@@ -0,0 +1,11 @@
+fn main() {
+    tonic_build::configure()
+        .out_dir("../bunker/generated")
+        .build_server(true)
+        .build_client(false)
+        .compile(
+            &["../../../pkg/grpc/proto/backend.proto"],
+            &["../../../pkg/grpc/proto"],
+        )
+        .unwrap();
+}

backend/rust/codegen/src/lib.rs

@@ -0,0 +1 @@
+