WIP: add an example of a bidirectional gRPC call via tonic

Cargo.toml

@@ -46,6 +46,7 @@ members = [
  "template_tinytemplate",
  "template_yarte",
  "todo",
+ "tonic-bidirectional",
  "udp-echo",
  "unix-socket",
  "web-cors/backend",

tonic-bidirectional/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "tonic-bidirectional"
+version = "0.1.0"
+authors = ["Lunar"]
+edition = "2018"
+
+[dependencies]
+tonic = "0.4"
+actix = "0.10"
+actix-rt = "1.1"
+env_logger = "0.8"
+log = "0.4"
+futures = "0.3"
+prost = "0.7"
+
+[build-dependencies]
+tonic-build = { version = "0.4" }

tonic-bidirectional/build.rs

@@ -0,0 +1,8 @@
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+ tonic_build::configure()
+ .compile(
+ &["proto/echo.proto"],
+ &["proto"],
+ )?;
+ Ok(())
+ }

tonic-bidirectional/proto/echo.proto

@@ -0,0 +1,15 @@
+syntax = "proto3";
+
+package echo;
+
+service Echo {
+ rpc Echo(stream EchoRequest) returns (stream EchoReply) {}
+}
+
+message EchoRequest {
+ string payload = 1;
+}
+
+message EchoReply {
+ string payload = 1;
+}

tonic-bidirectional/src/echo_rpc.rs

@@ -0,0 +1,42 @@
+use actix::prelude::*;
+use futures::channel::mpsc::Sender;
+use log::info;
+
+use crate::EchoReceived;
+use crate::grpc_api::{
+ EchoRequest,
+ EchoReply,
+};
+
+pub struct EchoRpc {
+ addr: actix::prelude::Recipient<EchoReceived>,
+ tx: Sender<EchoRequest>,
+}
+
+impl Actor for EchoRpc {
+ type Context = Context<Self>;
+}
+
+impl Handler<EchoRequest> for EchoRpc {
+ type Result = ();
+
+ fn handle(&mut self, msg: EchoRequest, ctx: &mut Context<Self>) {
+ if let Err(_) = self.tx.try_send(msg) {
+ info!("Sending echo request failed. Stopping.");
+ ctx.stop();
+ }
+ }
+}
+
+impl StreamHandler<Result<EchoReply, tonic::Status>> for EchoRpc {
+ fn handle(&mut self, msg: Result<EchoReply, tonic::Status>, _: &mut Context<Self>) {
+ match msg {
+ Ok(msg) => {
+ self.addr.send(EchoReceived { payload: msg.payload });
+ }
+ Err(status) => {
+ info!("Stream error: {}", status.message());
+ }
+ }
+ }
+}

tonic-bidirectional/src/echo_service.rs

@@ -0,0 +1,96 @@
+use actix::prelude::*;
+use log::{info, error};
+
+use crate::EchoReceived;
+use crate::echo_rpc::EchoRpc;
+use crate::grpc_api::echo_client::EchoClient;
+
+#[derive(Message)]
+#[rtype(result = "Result<Addr<EchoRpc>, RunningEchoFailed>")]
+pub struct RunEcho {
+ pub addr: actix::prelude::Recipient<EchoReceived>,
+}
+
+#[derive(Debug)]
+pub struct NotConnectedError;
+
+#[derive(Debug)]
+pub struct RunningEchoFailed;
+
+pub struct EchoService {
+ endpoint: String,
+ client: Option<EchoClient<tonic::transport::Channel>>,
+}
+
+impl EchoService {
+ pub fn new(endpoint: String) -> EchoService {
+ EchoService {
+ endpoint,
+ client: None,
+ }
+ }
+}
+
+// EchoService should be responsible for connecting on startup and it'll have a RunEcho message
+
+impl Actor for EchoService {
+ type Context = Context<Self>;
+
+ fn started(&mut self, ctx: &mut Context<Self>) {
+ EchoClient::connect(self.endpoint.clone())
+ .into_actor(self)
+ .then(|res, act, ctx| {
+ match res {
+ Ok(echo_client) => {
+ act.client = Some(echo_client);
+ }
+ Err(err) => {
+ error!("Unable to connect to echo server {:?}", err);
+ ctx.stop();
+ }
+ }
+ fut::ready(())
+ })
+ .wait(ctx)
+ }
+}
+
+impl Handler<RunEcho> for EchoService {
+ type Result = ResponseActFuture<Self, Result<Addr<EchoRpc>, RunningEchoFailed>>;
+
+ fn handle(&mut self, msg: RunEcho, _ctx: &mut Context<Self>) -> Self::Result {
+ if let Some(mut client) = &mut self.client {
+ const OUTBOUND_CHANNEL_BUFFER: usize = 10;
+ let (tx, rx) = futures::channel::mpsc::channel(OUTBOUND_CHANNEL_BUFFER);
+
+ info!("Sending echo RPC!");
+ Box::pin(
+ client.echo(tonic::Request::new(rx))
+ .into_actor(self)
+ .map(|res, _act, _ctx| {
+ match res {
+ Ok(inbound) => {
+ Ok(EchoRpc::create(|ctx| {
+ ctx.add_stream(inbound.into_inner());
+ EchoRpc {
+ addr: msg.addr,
+ tx
+ }
+ }))
+ }
+ Err(_) => {
+ // XXX: This is not really useful
+ Err(RunningEchoFailed)
+ }
+ }
+ })
+ )
+ } else {
+ // XXX: do something smart about retrying. maybe ctx.stop()?
+ error!("Not connected to the echo server");
+ Box::pin(fut::err(RunningEchoFailed))
+ }
+ }
+}
+
+impl Supervised for EchoService {}

tonic-bidirectional/src/grpc_api.rs

@@ -0,0 +1,13 @@
+use actix::prelude::{
+ Message as ActixMessage,
+};
+
+tonic::include_proto!("echo");
+
+impl ActixMessage for EchoRequest {
+ type Result = ();
+}
+
+impl ActixMessage for EchoReply {
+ type Result = ();
+}

tonic-bidirectional/src/main.rs

@@ -0,0 +1,97 @@
+mod echo_service;
+mod echo_rpc;
+mod grpc_api;
+
+use actix::prelude::*;
+use log::{error, info};
+
+use crate::echo_service::{EchoService, RunEcho};
+use crate::echo_rpc::EchoRpc;
+
+#[derive(Message)]
+#[rtype(result = "()")]
+pub struct SendEcho {
+ pub payload: String,
+}
+
+#[derive(Message)]
+#[rtype(result = "()")]
+pub struct EchoReceived {
+ pub payload: String,
+}
+
+struct EchoSender {
+ service: Addr<EchoService>,
+ echo_rpc: Option<Addr<EchoRpc>>,
+}
+
+impl EchoSender {
+ fn new(service: Addr<EchoService>) -> EchoSender {
+ EchoSender {
+ service,
+ echo_rpc: None,
+ }
+ }
+}
+
+impl Actor for EchoSender {
+ type Context = Context<Self>;
+
+ fn started(&mut self, ctx: &mut Context<Self>) {
+ self.service.send(RunEcho { addr: ctx.address().recipient() })
+ .into_actor(self)
+ .map(|res, act, ctx| {
+ match res {
+ Ok(Ok(echo_rpc)) => {
+ act.echo_rpc = Some(echo_rpc);
+ }
+ _ => {
+ error!("Unable to start echo RPC");
+ ctx.stop();
+ }
+ }
+ })
+ .wait(ctx)
+ }
+}
+
+impl Handler<SendEcho> for EchoSender {
+ type Result = ();
+
+ fn handle(&mut self, msg: SendEcho, ctx: &mut Context<Self>) {
+ info!("Sending echo: {}", msg.payload);
+ match &self.echo_rpc {
+ Some(echo_rpc) => {
+ echo_rpc.do_send(grpc_api::EchoRequest { payload: msg.payload });
+ }
+ None => {
+ // Maybe we could do something smart like trying to (re)connect here.
+ error!("Not connected!");
+ ctx.stop();
+ }
+ }
+ }
+}
+
+impl Handler<EchoReceived> for EchoSender {
+ type Result = ();
+
+ fn handle(&mut self, msg: EchoReceived, _: &mut Context<Self>) {
+ info!("EchoSender has just received: {}", msg.payload)
+ }
+}
+
+const ENDPOINT: &str = "http://127.0.0.1:50051";
+
+#[actix_rt::main]
+async fn main() {
+ env_logger::init();
+
+ let service = EchoService::new(ENDPOINT.to_string()).start();
+ let sender = EchoSender::new(service).start();
+ sender.do_send(SendEcho { payload: "Alpha".to_string() });
+ sender.do_send(SendEcho { payload: "Beta".to_string() });
+ sender.do_send(SendEcho { payload: "Gamma".to_string() });
+
+ actix_rt::Arbiter::local_join().await;
+}