First pass at macro
This commit is contained in:
Lucio Franco
+168
-130
@@ -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,
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user