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

More macro clean up

Browse Source
This commit is contained in:
Lucio Franco
2019-08-15 17:56:28 -04:00
parent 5e208d9da2
commit 28a0b9e286
2 changed files with 46 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tonic-macros/src/lib.rs
+24 -107
View File
@@ -15,118 +15,16 @@ pub fn server(attr: TokenStream, item: TokenStream) -> TokenStream {
let item = syn::parse_macro_input!(item as ItemImpl);
let args = syn::parse_macro_input!(attr as AttributeArgs);
let service = load_service(args);
let service_def = service::parse_service_impl(item, service);
let (service, proto_path) = load_service(args);
let service_def = service::parse_service_impl(item, service, proto_path);
let output = service::generate(service_def);
original.extend(TokenStream::from(output));
original
// let mut original = item.clone();
// let ItemImpl { self_ty, items, .. } = syn::parse_macro_input!(item as ItemImpl);
// let mut m_ident = None;
// for item in items {
// if let ImplItem::Method(method) = item {
// // println!("{:?}", method);
// 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::*;
// #[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 _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 {
fn load_service(attr: AttributeArgs) -> (Service, String) {
use syn::{Lit, Meta, MetaNameValue, NestedMeta};
let service = attr
@@ -147,14 +45,33 @@ fn load_service(attr: AttributeArgs) -> Service {
None => panic!("expected a `service = \"package.Service\" attribute"),
};
let service = attr
.iter()
.filter_map(|i| match i {
NestedMeta::Meta(Meta::NameValue(MetaNameValue { path, lit, .. }))
if path.segments.first().unwrap().ident == "proto" =>
{
Some(lit.clone())
}
_ => None,
})
.next();
let proto_path = match service {
Some(Lit::Str(s)) => s.value(),
Some(_) => panic!("expected a literal string"),
None => panic!("expected a `proto = \"my::proto::path\" attribute"),
};
let file = format!(
"{}/{}.json",
std::env::var("OUT_DIR").unwrap(),
service_name
);
let json = std::fs::read_to_string(file).unwrap();
let svc = serde_json::from_str(&json).unwrap();
serde_json::from_str(&json).unwrap()
(svc, proto_path)
}
/// A service descriptor.
tonic-macros/src/service.rs
+22 -5
View File
@@ -9,10 +9,15 @@ pub struct ServiceDef {
name_str: String,
package: String,
proto_name: String,
proto_path: String,
methods: Vec<(Method, Ident)>,
}
pub(crate) fn parse_service_impl(item: ItemImpl, mut service: Service) -> ServiceDef {
pub(crate) fn parse_service_impl(
item: ItemImpl,
mut service: Service,
proto_path: String,
) -> ServiceDef {
let ItemImpl { self_ty, items, .. } = item;
let name = if let Type::Path(t) = *self_ty {
@@ -48,6 +53,7 @@ pub(crate) fn parse_service_impl(item: ItemImpl, mut service: Service) -> Servic
name_str: service.name,
package: service.package,
proto_name: service.proto_name,
proto_path,
methods,
}
}
@@ -120,7 +126,12 @@ fn generate_methods(service: &ServiceDef) -> TokenStream {
);
let method_path = Lit::Str(LitStr::new(&path, Span::call_site()));
let method_stream = generate_unary(method, ident.clone(), service.name.clone());
let method_stream = generate_unary(
method,
ident.clone(),
service.name.clone(),
&service.proto_path,
);
let method = quote! {
#method_path => {
@@ -133,11 +144,17 @@ fn generate_methods(service: &ServiceDef) -> TokenStream {
stream
}
fn generate_unary(method: &Method, method_ident: Ident, service_impl: Path) -> TokenStream {
fn generate_unary(
method: &Method,
method_ident: Ident,
service_impl: Path,
proto_path: &str,
) -> 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();
let request: Path = syn::parse_str(&format!("{}::{}", proto_path, method.input_type)).unwrap();
let response: Path =
syn::parse_str(&format!("{}::{}", proto_path, method.output_type)).unwrap();
quote! {
struct #service_ident(pub std::sync::Arc<#service_impl>);