talksik/tonic
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

First pass at macro

Browse Source
This commit is contained in:
Lucio Franco
2019-08-15 17:50:25 -04:00
parent 0a8aaa8071
commit 5e208d9da2
10 changed files with 470 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Cargo.toml
+1
View File
@@ -2,6 +2,7 @@
members = [
"tonic",
"tonic-macros",
"tonic-build",
"tonic-examples",
"tower-h2"
]
tonic-build/Cargo.toml
+13
View File
@@ -0,0 +1,13 @@
[package]
name = "tonic-build"
version = "0.1.0"
authors = ["Lucio Franco <luciofranco14@gmail.com>"]
edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
prost-build = "0.5"
codegen = "0.1"
serde_json = "1.0"
serde = { version = "1.0", features = ["derive"] }
tonic-build/src/lib.rs
+95
View File
@@ -0,0 +1,95 @@
use prost_build::Config;
use serde::Serialize;
use std::{io, path};
pub fn compile_protos<P>(protos: &[P], includes: &[P]) -> io::Result<()>
where
P: AsRef<path::Path>,
{
let mut config = Config::new();
config.service_generator(Box::new(ServiceGenerator {}));
config.compile_protos(protos, includes)
}
pub struct ServiceGenerator {}
impl prost_build::ServiceGenerator for ServiceGenerator {
fn generate(&mut self, service: prost_build::Service, _buf: &mut String) {
let file = format!(
"{}/{}.{}.json",
std::env::var("OUT_DIR").unwrap(),
service.package,
service.name
);
let svc = Service {
name: service.name,
proto_name: service.proto_name,
package: service.package,
methods: service
.methods
.into_iter()
.map(|m| Method {
name: m.name,
proto_name: m.proto_name,
input_type: m.input_type,
output_type: m.output_type,
input_proto_type: m.input_proto_type,
output_proto_type: m.output_proto_type,
client_streaming: m.client_streaming,
server_streaming: m.server_streaming,
})
.collect(),
};
let json = serde_json::to_string(&svc).unwrap();
std::fs::write(file, json).unwrap();
}
// fn finalize(&mut self, buf: &mut String) {
// let mut fmt = codegen::Formatter::new(buf);
// self.scope
// .fmt(&mut fmt)
// .expect("formatting root scope failed!");
// self.scope = codegen::Scope::new();
// }
}
/// A service descriptor.
#[derive(Debug, Serialize)]
pub struct Service {
/// The service name in Rust style.
pub name: String,
/// The service name as it appears in the .proto file.
pub proto_name: String,
/// The package name as it appears in the .proto file.
pub package: String,
/// The service methods.
pub methods: Vec<Method>,
}
/// A service method descriptor.
#[derive(Debug, Serialize)]
pub struct Method {
/// The name of the method in Rust style.
pub name: String,
/// The name of the method as it appears in the .proto file.
pub proto_name: String,
/// The input Rust type.
pub input_type: String,
/// The output Rust type.
pub output_type: String,
/// The input Protobuf type.
pub input_proto_type: String,
/// The output Protobuf type.
pub output_proto_type: String,
// /// The method options.
// pub options: prost_types::MethodOptions,
/// Identifies if client streams multiple client messages.
pub client_streaming: bool,
/// Identifies if server streams multiple server messages.
pub server_streaming: bool,
}
tonic-examples/Cargo.toml
+3
View File
@@ -22,3 +22,6 @@ tokio = "=0.2.0-alpha.1"
prost = "0.5"
prost-derive = "0.5"
bytes = "0.4"
[build-dependencies]
tonic-build = { path = "../tonic-build" }
tonic-examples/build.rs
+7 -1
View File
@@ -1 +1,7 @@
fn main() {}
fn main() {
tonic_build::compile_protos(
&["proto/helloworld/helloworld.proto"],
&["proto/helloworld"],
)
.unwrap();
}
tonic-examples/src/helloworld/server.rs
+6 -16
View File
@@ -5,18 +5,8 @@ use tokio::{timer::Delay, net::TcpListener};
use tonic::{Request, Response, Status};
use tower_h2::Server;
mod proto {
#[derive(Clone, PartialEq, prost::Message)]
pub struct HelloRequest {
#[prost(string, tag = "1")]
pub name: std::string::String,
}
/// The response message containing the greetings
#[derive(Clone, PartialEq, prost::Message)]
pub struct HelloReply {
#[prost(string, tag = "1")]
pub message: std::string::String,
}
pub mod hello_world {
include!(concat!(env!("OUT_DIR"), "/helloworld.rs"));
}
#[derive(Default, Clone)]
@@ -24,9 +14,9 @@ pub struct MyGreeter {
data: String,
}
#[tonic::server(service = "helloworld.Greeter", proto = "proto")]
#[tonic::server(service = "helloworld.Greeter", proto = "hello_world")]
impl MyGreeter {
pub async fn say_hello(&self, request: Request<proto::HelloRequest>) -> Result<Response<proto::HelloReply>, Status> {
pub async fn say_hello(&self, request: Request<hello_world::HelloRequest>) -> Result<Response<hello_world::HelloReply>, Status> {
println!("Got a request: {:?}", request);
let string = &self.data;
@@ -38,7 +28,7 @@ impl MyGreeter {
Delay::new(when).await;
let reply = HelloReply {
let reply = hello_world::HelloReply {
message: "Zomg, it works!".into(),
};
Ok(Response::new(reply))
@@ -51,7 +41,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut bind = TcpListener::bind(&addr)?;
let greeter = MyGreeter::default();
let mut server = Server::new(GrpcServer::new(greeter), Default::default());
let mut server = Server::new(GreeterServer::new(greeter), Default::default());
while let Ok((sock, _addr)) = bind.accept().await {
if let Err(e) = sock.set_nodelay(true) {
tonic-macros/Cargo.toml
+5 -5
View File
@@ -8,11 +8,11 @@ edition = "2018"
proc-macro = true
[dependencies]
syn = { version = "0.15", features = ["full"] }
quote = "0.6"
proc-macro2 = "0.4"
prost-build = "0.5"
tower-service = { git = "https://github.com/tower-rs/tower", branch = "std-future" }
syn = { version = "1.0", features = ["full"] }
quote = "1.0"
proc-macro2 = "1.0"
serde_json = "1.0"
serde = { version = "1.0", features = ["derive"] }
[dev-dependencies]
tokio = "=0.2.0-alpha.1"
tonic-macros/src/lib.rs
+168 -130
View File
@@ -2,155 +2,193 @@
#![recursion_limit = "256"]
extern crate proc_macro;
mod service;
use proc_macro::TokenStream;
use prost_build::{Comments, Method, Service};
use quote::quote;
use syn::{ImplItem, ImplItemMethod, ItemImpl, Type};
use serde::Deserialize;
use syn::{AttributeArgs, ItemImpl};
#[proc_macro_attribute]
pub fn server(attr: TokenStream, item: TokenStream) -> TokenStream {
let service = load_service(attr);
let mut original = item.clone();
let ItemImpl { self_ty, items, .. } = syn::parse_macro_input!(item as ItemImpl);
let item = syn::parse_macro_input!(item as ItemImpl);
let args = syn::parse_macro_input!(attr as AttributeArgs);
let s = if let Type::Path(t) = *self_ty {
t.path.segments.iter().next().unwrap().clone()
} else {
panic!("wrong type!")
};
let service = load_service(args);
let service_def = service::parse_service_impl(item, service);
let output = service::generate(service_def);
let mut m_ident = None;
for item in items {
if let ImplItem::Method(method) = item {
// println!("{:?}", method);
original.extend(TokenStream::from(output));
original
let ImplItemMethod { sig, .. } = method;
// let mut original = item.clone();
// let ItemImpl { self_ty, items, .. } = syn::parse_macro_input!(item as ItemImpl);
if sig.asyncness.is_some() {
let name = format!("{}", sig.ident);
// let mut m_ident = None;
// for item in items {
// if let ImplItem::Method(method) = item {
// // println!("{:?}", method);
if let Some(_method) = service.methods.iter().find(|method| method.name == name) {
// println!("found method!");
m_ident = Some(sig.ident.clone());
}
}
}
}
// let ImplItemMethod { sig, .. } = method;
// if sig.asyncness.is_some() {
// let name = format!("{}", sig.ident);
// if let Some(_method) = service.methods.iter().find(|method| method.name == name) {
// // println!("found method!");
// m_ident = Some(sig.ident.clone());
// }
// }
// }
// }
// let service_name = service.proto_name.clone();
let ts = quote! {
use tonic::_codegen;
use proto::*;
// let ts = quote! {
// use tonic::_codegen;
// use proto::*;
#[derive(Clone)]
pub struct GrpcServer {
inner: std::sync::Arc<#s>,
}
// #[derive(Clone)]
// pub struct GrpcServer {
// inner: std::sync::Arc<#s>,
// }
impl GrpcServer {
fn new(t: #s) -> Self {
Self { inner: std::sync::Arc::new(t) }
// impl GrpcServer {
// fn new(t: #s) -> Self {
// Self { inner: std::sync::Arc::new(t) }
// }
// }
// impl _codegen::Service<()> for GrpcServer {
// type Response = Self;
// type Error = tonic::error::Never;
// type Future = _codegen::Ready<Result<Self::Response, Self::Error>>;
// fn poll_ready(&mut self, _cx: &mut _codegen::Context<'_>) -> _codegen::Poll<Result<(), Self::Error>> {
// std::task::Poll::Ready(Ok(()))
// }
// fn call(&mut self, _: ()) -> Self::Future {
// _codegen::ok(self.clone())
// }
// }
// impl _codegen::Service<_codegen::http::Request<tower_h2::RecvBody>> for GrpcServer {
// type Response = _codegen::http::Response<tonic::body::BoxAsyncBody>;
// type Error = tonic::error::Never;
// type Future = _codegen::ResponseFuture2<Self::Response, Self::Error>;
// fn poll_ready(&mut self, _cx: &mut _codegen::Context<'_>) -> _codegen::Poll<Result<(), Self::Error>> {
// Ok(()).into()
// }
// fn call(&mut self, request: _codegen::http::Request<tower_h2::RecvBody>) -> Self::Future {
// let inner = self.inner.clone();
// match request.uri().path() {
// "/helloworld.Greeter/SayHello" => {
// use tonic::_codegen::*;
// use tonic::*;
// pub struct SayHello(pub std::sync::Arc<#s>);
// impl tonic::server::UnaryService<HelloRequest> for SayHello {
// type Response = HelloReply;
// type Future = Pin<Box<dyn Future<Output = Result<Response<Self::Response>, Status>> + Send + 'static>>;
// fn call(&mut self, request: Request<HelloRequest>) -> Self::Future {
// let inner = self.0.clone();
// let fut = async move {
// inner.#m_ident(request).await
// };
// Box::pin(fut)
// }
// }
// let inner = self.inner.clone();
// let fut = async move {
// let method = SayHello(inner);
// let codec = tonic::codec::ProstCodec::new();
// let mut grpc = tonic::server::Grpc::new(codec);
// let res = grpc.unary(method, request).await;
// Ok(res)
// };
// Box::pin(fut)
// },
// _ => unimplemented!("use grpc unimplemented")
// }
// }
// }
// };
}
fn load_service(attr: AttributeArgs) -> Service {
use syn::{Lit, Meta, MetaNameValue, NestedMeta};
let service = attr
.iter()
.filter_map(|i| match i {
NestedMeta::Meta(Meta::NameValue(MetaNameValue { path, lit, .. }))
if path.segments.first().unwrap().ident == "service" =>
{
Some(lit.clone())
}
}
impl _codegen::Service<()> for GrpcServer {
type Response = Self;
type Error = tonic::error::Never;
type Future = _codegen::Ready<Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, _cx: &mut _codegen::Context<'_>) -> _codegen::Poll<Result<(), Self::Error>> {
std::task::Poll::Ready(Ok(()))
}
fn call(&mut self, _: ()) -> Self::Future {
_codegen::ok(self.clone())
}
}
impl _codegen::Service<_codegen::http::Request<tower_h2::RecvBody>> for GrpcServer {
type Response = _codegen::http::Response<tonic::body::BoxAsyncBody>;
type Error = tonic::error::Never;
type Future = _codegen::ResponseFuture2<Self::Response, Self::Error>;
fn poll_ready(&mut self, _cx: &mut _codegen::Context<'_>) -> _codegen::Poll<Result<(), Self::Error>> {
Ok(()).into()
}
fn call(&mut self, request: _codegen::http::Request<tower_h2::RecvBody>) -> Self::Future {
let inner = self.inner.clone();
match request.uri().path() {
"/helloworld.Greeter/SayHello" => {
use tonic::_codegen::*;
use tonic::*;
pub struct SayHello(pub std::sync::Arc<#s>);
impl tonic::server::UnaryService<HelloRequest> for SayHello {
type Response = HelloReply;
type Future = Pin<Box<dyn Future<Output = Result<Response<Self::Response>, Status>> + Send + 'static>>;
fn call(&mut self, request: Request<HelloRequest>) -> Self::Future {
let inner = self.0.clone();
let fut = async move {
inner.#m_ident(request).await
};
Box::pin(fut)
}
}
let inner = self.inner.clone();
let fut = async move {
let method = SayHello(inner);
let codec = tonic::codec::ProstCodec::new();
let mut grpc = tonic::server::Grpc::new(codec);
let res = grpc.unary(method, request).await;
Ok(res)
};
Box::pin(fut)
},
_ => unimplemented!("use grpc unimplemented")
}
}
}
_ => None,
})
.next();
let service_name = match service {
Some(Lit::Str(s)) => s.value(),
Some(_) => panic!("expected a literal string"),
None => panic!("expected a `service = \"package.Service\" attribute"),
};
original.extend(TokenStream::from(ts));
original
let file = format!(
"{}/{}.json",
std::env::var("OUT_DIR").unwrap(),
service_name
);
let json = std::fs::read_to_string(file).unwrap();
serde_json::from_str(&json).unwrap()
}
fn load_service(_attr: TokenStream) -> Service {
Service {
name: "Greeter".into(),
proto_name: "greeter".into(),
package: "helloworld".into(),
comments: Comments {
leading_detached: Vec::new(),
leading: Vec::new(),
trailing: Vec::new(),
},
methods: vec![Method {
name: "say_hello".into(),
proto_name: "SayHello".into(),
comments: Comments {
leading_detached: Vec::new(),
leading: Vec::new(),
trailing: Vec::new(),
},
input_type: "HelloRequest".into(),
output_type: "HelloResponse".into(),
input_proto_type: "HelloRequest".into(),
output_proto_type: "HelloResponse".into(),
options: Default::default(),
client_streaming: false,
server_streaming: false,
}],
options: Default::default(),
}
/// A service descriptor.
#[derive(Debug, Deserialize)]
pub(crate) struct Service {
/// The service name in Rust style.
pub name: String,
/// The service name as it appears in the .proto file.
pub proto_name: String,
/// The package name as it appears in the .proto file.
pub package: String,
/// The service methods.
pub methods: Vec<Method>,
}
/// A service method descriptor.
#[derive(Debug, Deserialize)]
pub(crate) struct Method {
/// The name of the method in Rust style.
pub name: String,
/// The name of the method as it appears in the .proto file.
pub proto_name: String,
/// The input Rust type.
pub input_type: String,
/// The output Rust type.
pub output_type: String,
/// The input Protobuf type.
pub input_proto_type: String,
/// The output Protobuf type.
pub output_proto_type: String,
// /// The method options.
// pub options: prost_types::MethodOptions,
/// Identifies if client streams multiple client messages.
pub client_streaming: bool,
/// Identifies if server streams multiple server messages.
pub server_streaming: bool,
}
tonic-macros/src/service.rs
+169
View File
@@ -0,0 +1,169 @@
use crate::{Method, Service};
use proc_macro2::{Span, TokenStream};
use quote::quote;
use syn::{Ident, ImplItem, ImplItemMethod, ItemImpl, Lit, LitStr, Path, Type};
#[derive(Debug)]
pub struct ServiceDef {
name: Path,
name_str: String,
package: String,
proto_name: String,
methods: Vec<(Method, Ident)>,
}
pub(crate) fn parse_service_impl(item: ItemImpl, mut service: Service) -> ServiceDef {
let ItemImpl { self_ty, items, .. } = item;
let name = if let Type::Path(t) = *self_ty {
t.path.clone()
} else {
panic!("wrong type!")
};
let mut methods = Vec::new();
for item in items {
if let ImplItem::Method(method) = item {
let ImplItemMethod { sig, .. } = method;
if sig.asyncness.is_some() {
let name = format!("{}", sig.ident);
if let Some((i, _)) = service
.methods
.iter()
.enumerate()
.find(|(_, method)| method.name == name)
{
let method = service.methods.remove(i);
methods.push((method, sig.ident));
}
}
}
}
ServiceDef {
name,
name_str: service.name,
package: service.package,
proto_name: service.proto_name,
methods,
}
}
pub(crate) fn generate(service: ServiceDef) -> TokenStream {
let service_server = Ident::new(&format!("{}Server", service.name_str), Span::call_site());
let service_impl = service.name.clone();
let methods = generate_methods(&service);
quote! {
use tonic::_codegen::*;
// TODO: impl debug
#[derive(Clone)]
pub struct #service_server {
inner: std::sync::Arc<#service_impl>,
}
impl #service_server {
pub fn new(t: #service_impl) -> Self {
let inner = std::sync::Arc::new(t);
Self { inner }
}
}
impl Service<()> for #service_server {
type Response = Self;
type Error = tonic::error::Never;
type Future = Ready<Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
fn call(&mut self, _: ()) -> Self::Future {
ok(self.clone())
}
}
impl Service<http::Request<tower_h2::RecvBody>> for #service_server {
type Response = http::Response<tonic::BoxAsyncBody>;
type Error = tonic::error::Never;
type Future = BoxFuture<Self::Response, Self::Error>;
fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
fn call(&mut self, req: http::Request<tower_h2::RecvBody>) -> Self::Future {
let inner = self.inner.clone();
match req.uri().path() {
#methods
_ => unimplemented!("use grpc unimplemented"),
}
}
}
}
}
fn generate_methods(service: &ServiceDef) -> TokenStream {
let mut stream = TokenStream::new();
for (method, ident) in &service.methods {
let path = format!(
"/{}.{}/{}",
service.package, service.proto_name, method.proto_name
);
let method_path = Lit::Str(LitStr::new(&path, Span::call_site()));
let method_stream = generate_unary(method, ident.clone(), service.name.clone());
let method = quote! {
#method_path => {
#method_stream
}
};
stream.extend(method);
}
stream
}
fn generate_unary(method: &Method, method_ident: Ident, service_impl: Path) -> TokenStream {
let service_ident = Ident::new(&method.proto_name, Span::call_site());
let request: Path = syn::parse_str(&format!("hello_world::{}", method.input_type)).unwrap();
let response: Path = syn::parse_str(&format!("hello_world::{}", method.output_type)).unwrap();
quote! {
struct #service_ident(pub std::sync::Arc<#service_impl>);
impl tonic::server::UnaryService<#request> for #service_ident {
type Response =#response;
type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
fn call(&mut self, request: tonic::Request<#request>) -> Self::Future {
let inner = self.0.clone();
let fut = async move {
inner.#method_ident(request).await
};
Box::pin(fut)
}
}
let inner = self.inner.clone();
let fut = async move {
let method = #service_ident(inner);
let codec = tonic::codec::ProstCodec::new();
let mut grpc = tonic::server::Grpc::new(codec);
let res = grpc.unary(method, req).await;
Ok(res)
};
Box::pin(fut)
}
}
tonic/src/lib.rs
+3 -3
View File
@@ -14,6 +14,7 @@ mod request;
mod response;
mod status;
pub use body::{BoxAsyncBody, BoxBody};
pub use request::Request;
pub use response::Response;
pub use status::{Code, Status};
@@ -39,9 +40,8 @@ pub mod _codegen {
pub use std::pin::Pin;
pub use std::task::{Context, Poll};
pub use tower_service::Service;
pub type ResponseFuture<T> =
self::Pin<Box<dyn self::Future<Output = Result<T, crate::Status>> + Send + 'static>>;
pub type ResponseFuture2<T, E> =
pub type BoxFuture<T, E> =
self::Pin<Box<dyn self::Future<Output = Result<T, E>> + Send + 'static>>;
pub mod http {