gRPC-Rust(v0.9)を動かしてみる

gRPC Server support is coming soon

grpc/                    新公式 grpc（v0.9.0 preview）
grpc-protobuf/           grpc 用 protobuf-over-grpc 実装
grpc-protobuf-build/     grpc 用 protobuf build 統合
grpc-google/             well-known proto 型
protoc-gen-rust-grpc/    新公式 grpc 用の protoc プラグイン
tonic/                   ← tonic 本体（mature, v0.14.x）
tonic-build/, tonic-prost/・・・・
xds-client/, interop/, examples/

grpc/src/
├── attributes/
├── client/
│   ├── load_balancing/
│   ├── name_resolution/
│   └── transport/
│       └── tonic/
├── core/
├── credentials/
│   └── rustls/
│       ├── client/
│       └── server/     ← TLS server もある
├── metadata/
├── server/             ← 実装あり
│   ├── mod.rs          
│   └── interceptor.rs  
├── status/
│   └── server_status.rs
└── lib.rs

pub mod attributes;
pub mod client;
pub mod core;
pub mod credentials;
pub mod metadata;

pub(crate) mod inmemory;
pub(crate) mod server;        // ← 公開してない

pub struct Server { handler: Option<Arc<dyn DynHandle>> }

#[trait_variant::make(Send)]
pub trait Listener {
    type SendStream: SendStream + 'static;
    type RecvStream: RecvStream + 'static;
    async fn accept(&self) -> Option<Call<Self::SendStream, Self::RecvStream>>;
}

impl Server {
    pub fn new() -> Self { /* ... */ }
    pub fn set_handler<H>(&mut self, h: H)
    where H: Handle + Send + Sync + 'static { /* ... */ }
    pub async fn serve(&self, l: &impl Listener) { /* ... */ }
}

allowed_external_types = [
    "bytes::*",
    "tonic::*",                              # ← 公的 API に tonic 型を露出することを許可
    "futures_core::stream::Stream",
    "tokio::sync::oneshot::*",
]

grpc-rust-hello/
├── Cargo.toml
├── proto/
│   └── helloworld.proto
├── server/
│   ├── Cargo.toml
│   ├── build.rs
│   └── src/main.rs
└── client/
    ├── Cargo.toml
    ├── build.rs
    └── src/main.rs

syntax = "proto3";
package helloworld;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest { string name = 1; }
message HelloReply   { string message = 1; }

use std::path::PathBuf;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let proto_dir = PathBuf::from("../proto");

    // .proto を自動列挙
    let protos: Vec<PathBuf> = std::fs::read_dir(&proto_dir)?
        .filter_map(Result::ok)
        .map(|e| e.path())
        .filter(|p| p.extension().map(|e| e == "proto").unwrap_or(false))
        .collect();

    // proto 編集で必ず再生成
    for p in &protos {
        println!("cargo:rerun-if-changed={}", p.display());
    }
    println!("cargo:rerun-if-changed={}", proto_dir.display());

    tonic_prost_build::configure()
        .build_server(true)
        .build_client(false)
        // 全メッセージに serde を一括付与（必要なときだけ）
        .type_attribute(".", "#[derive(serde::Serialize, serde::Deserialize)]")
        .compile_protos(&protos, &[proto_dir])?;

    Ok(())
}

use tonic::{transport::Server, Request, Response, Status};

pub mod helloworld {
    tonic::include_proto!("helloworld");
}

use helloworld::greeter_server::{Greeter, GreeterServer};
use helloworld::{HelloReply, HelloRequest};

#[derive(Default)]
pub struct MyGreeter;

#[tonic::async_trait]
impl Greeter for MyGreeter {
    async fn say_hello(
        &self,
        request: Request<HelloRequest>,
    ) -> Result<Response<HelloReply>, Status> {
        let name = request.into_inner().name;
        Ok(Response::new(HelloReply {
            message: format!("Hello, {name}! (from tonic server)"),
        }))
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let addr = "127.0.0.1:50051".parse()?;
    println!("[server] Greeter listening on {addr}");
    Server::builder()
        .add_service(GreeterServer::new(MyGreeter))
        .serve(addr)
        .await?;
    Ok(())
}

use std::path::PathBuf;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let proto_dir = PathBuf::from("../proto");
    let protos: Vec<PathBuf> = std::fs::read_dir(&proto_dir)?
        .filter_map(Result::ok).map(|e| e.path())
        .filter(|p| p.extension().map(|e| e == "proto").unwrap_or(false))
        .collect();
    for p in &protos {
        println!("cargo:rerun-if-changed={}", p.display());
    }
    println!("cargo:rerun-if-changed={}", proto_dir.display());

    tonic_prost_build::configure()
        .build_server(false)
        .build_client(true)
        .compile_protos(&protos, &[proto_dir])?;
    Ok(())
}

pub mod helloworld {
    tonic::include_proto!("helloworld");
}

use helloworld::greeter_client::GreeterClient;
use helloworld::HelloRequest;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = GreeterClient::connect("http://127.0.0.1:50051").await?;
    let resp = client
        .say_hello(tonic::Request::new(HelloRequest { name: "tonic-client".into() }))
        .await?;
    println!("[client] RESPONSE: {}", resp.into_inner().message);
    Ok(())
}

$ cargo build --release
   ...
    Finished `release` profile [optimized] target(s) in 51.09s

$ ./target/release/server &
[server] Greeter listening on 127.0.0.1:50051

$ ./target/release/client
[client] RESPONSE: Hello, tonic-client! (from tonic server)