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

@@ -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 @@
+