[Rust] Add WTX - gRPC

Author: c410-f3r

frameworks/wtx-grpc/Cargo.lock

@@ -0,0 +1,18 @@
+[package]
+name = "httparena-wtx-grpc"
+version = "0.1.0"
+edition = "2024"
+
+[build-dependencies]
+pb-rs = { default-features = false, version = "0.10" }
+
+[dependencies]
+quick-protobuf = { default-features = false, version = "0.8" }
+tokio = { default-features = false, features = ["macros", "rt-multi-thread"], version = "1.0" }
+wtx = { default-features = false, features = ["grpc-server", "http-server-framework", "optimizations", "optioned-server", "quick-protobuf", "tokio"], version = "0.47" }
+
+[profile.release]
+codegen-units = 1
+lto = "thin"
+opt-level = 3
+panic = "abort"

frameworks/wtx-grpc/Cargo.toml

@@ -0,0 +1,13 @@
+FROM rust:1.95 AS build
+RUN rustup default nightly-2026-05-07
+WORKDIR /app
+COPY Cargo.toml build.rs ./
+COPY proto ./proto
+RUN mkdir src && echo "fn main() {}" > src/main.rs && cargo build --release && rm -rf src/ target/release/httparena-wtx-grpc* target/release/deps/httparena_wtx-grpc*
+COPY src ./src
+RUN RUSTFLAGS="-C target-cpu=native" cargo build --release
+
+FROM debian:bookworm-slim
+COPY --from=build /app/target/release/httparena-wtx-grpc /server
+EXPOSE 8080
+CMD ["/server"]

frameworks/wtx-grpc/Dockerfile

@@ -0,0 +1,26 @@
+use pb_rs::{ConfigBuilder, types::FileDescriptor};
+use std::{
+  fs::{DirBuilder, remove_dir_all},
+  path::Path,
+};
+
+fn main() {
+  let cmd = std::env::var("CARGO_MANIFEST_DIR").unwrap();
+  let in_dir = Path::new(&cmd).join("proto");
+  let out_dir = Path::new(&std::env::var("OUT_DIR").unwrap()).join("proto");
+  if out_dir.exists() {
+    remove_dir_all(&out_dir).unwrap();
+  }
+  DirBuilder::new().create(&out_dir).unwrap();
+  FileDescriptor::run(
+    &ConfigBuilder::new(
+      &[Path::new(&cmd).join("proto/benchmark.proto").as_path()],
+      None,
+      Some(&out_dir.as_path()),
+      &[in_dir.as_path()],
+    )
+    .unwrap()
+    .build(),
+  )
+  .unwrap();
+}

frameworks/wtx-grpc/build.rs

@@ -0,0 +1,12 @@
+{
+  "display_name": "wtx",
+  "language": "Rust",
+  "type": "production",
+  "engine": "wtx",
+  "description": "WTX - gRPC Server",
+  "repo": "https://github.com/c410-f3r/wtx",
+  "enabled": true,
+  "tests": [
+    "unary-grpc"
+  ]
+}

frameworks/wtx-grpc/meta.json

@@ -0,0 +1,15 @@
+syntax = "proto3";
+package benchmark;
+
+service BenchmarkService {
+  rpc GetSum (SumRequest) returns (SumReply);
+}
+
+message SumRequest {
+  int32 a = 1;
+  int32 b = 2;
+}
+
+message SumReply {
+  int32 result = 1;
+}

frameworks/wtx-grpc/proto/benchmark.proto

@@ -0,0 +1 @@
+include!(concat!(env!("OUT_DIR"), "/proto/mod.rs"));

frameworks/wtx-grpc/src/grpc_bindings.rs

@@ -0,0 +1,57 @@
+pub mod grpc_bindings;
+
+use wtx::{
+  codec::format::QuickProtobuf,
+  collection::Vector,
+  grpc::{GrpcManager, GrpcMiddleware},
+  http::{
+    HttpRecvParams, MsgBufferString,
+    server_framework::{Router, ServerFrameworkBuilder, State, post},
+  },
+};
+
+fn main() {
+  let threads = std::thread::available_parallelism().map(|el| el.get()).unwrap_or(1);
+  let mut handlers = Vector::new();
+  for _ in 0..threads {
+    let handle = std::thread::spawn(|| {
+      tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap().block_on(serve())
+    });
+    handlers.push(handle).unwrap();
+  }
+  for handle in handlers {
+    handle.join().unwrap();
+  }
+}
+
+async fn endpoint_grpc_unary(
+  state: State<'_, (), GrpcManager<QuickProtobuf>, MsgBufferString>,
+) -> wtx::Result<()> {
+  let sr: grpc_bindings::benchmark::SumRequest =
+    state.stream_aux.des_from_req_bytes(&mut state.req.msg_data.body.as_slice())?;
+  state.req.clear();
+  let result = sr.a.wrapping_add(sr.b);
+  state.stream_aux.ser_to_res_bytes(
+    &mut state.req.msg_data.body,
+    grpc_bindings::benchmark::SumReply { result },
+  )?;
+  Ok(())
+}
+
+async fn serve() {
+  let router = Router::new(
+    wtx::paths!(("/benchmark.BenchmarkService/GetSum", post(endpoint_grpc_unary))),
+    GrpcMiddleware,
+  )
+  .unwrap();
+  let _rslt = ServerFrameworkBuilder::new(HttpRecvParams::with_permissive_params(), router)
+    .with_stream_aux(|_| Ok(QuickProtobuf))
+    .tokio(
+      "0.0.0.0:8080",
+      |_error| println!("{_error}"),
+      |_| Ok(()),
+      |_stream| Ok(()),
+      |_error| println!("{_error}"),
+    )
+    .await;
+}