79 lines
1.8 KiB
Rust
79 lines
1.8 KiB
Rust
#![feature(async_await)]
|
|
|
|
use std::time::Duration;
|
|
use tokio::timer::Delay;
|
|
use tonic::{Request, Response, Status};
|
|
use tonic_macros::grpc;
|
|
|
|
// #[derive(Debug)]
|
|
// struct HelloRequest;
|
|
// #[derive(Debug)]
|
|
// struct HelloResponse;
|
|
|
|
#[derive(Default, Clone)]
|
|
struct MyGreeter {
|
|
data: String,
|
|
}
|
|
|
|
#[grpc(service = "proto/helloworld.proto")]
|
|
impl MyGreeter {
|
|
pub async fn say_hello(&mut self, request: Request<()>) -> Result<Response<()>, Status> {
|
|
println!("Got a request: {:?}", request);
|
|
|
|
let string = &self.data;
|
|
|
|
let when = tokio::clock::now() + Duration::from_millis(100);
|
|
Delay::new(when).await;
|
|
|
|
println!("My data: {:?}", string);
|
|
|
|
Delay::new(when).await;
|
|
|
|
Ok(Response::new(()))
|
|
}
|
|
}
|
|
|
|
use std::future::Future;
|
|
use std::task::{Poll, Context};
|
|
pub trait Service<'a, Request> {
|
|
type Response;
|
|
type Error;
|
|
type Future: Future<Output = Result<Self::Response, Self::Error>> + 'a;
|
|
|
|
fn poll_ready(&'a mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>;
|
|
fn call(&'a mut self, req: Request) -> Self::Future;
|
|
}
|
|
|
|
struct Svc {
|
|
inner: MyGreeter,
|
|
}
|
|
|
|
impl<'a> Service<'a, tonic::Request<()>> for Svc {
|
|
type Response = tonic::Response<()>;
|
|
type Error = tonic::Status;
|
|
type Future = tonic::ResponseFuture<'a, Self::Response>;
|
|
|
|
fn poll_ready(
|
|
&'a mut self,
|
|
_cx: &mut std::task::Context<'_>,
|
|
) -> std::task::Poll<Result<(), Self::Error>> {
|
|
std::task::Poll::Ready(Ok(()))
|
|
}
|
|
|
|
fn call(&'a mut self, request: tonic::Request<()>) -> Self::Future {
|
|
use tonic::GrpcInnerService;
|
|
self.inner.call(request)
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn grpc() {
|
|
let greeter = MyGreeter {
|
|
data: "some data".into(),
|
|
};
|
|
|
|
let mut svc = Svc { inner: greeter };
|
|
|
|
svc.call(Request::new(())).await.unwrap();
|
|
}
|