Fix encoding, more interop and update nightly version

tonic-interop/src/bin/client.rs

@@ -1,10 +1,10 @@
-#![feature(async_await)]
-
-use clap::{arg_enum, App, Arg, values_t};
+use clap::{arg_enum, values_t, App, Arg};
 use tonic_interop::client;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    pretty_env_logger::init();
+
     let matches = App::new("My Super Program")
         .version("1.0")
         .about("Does awesome things")
@@ -35,7 +35,18 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         let mut test_results = Vec::new();
 
         match test_case {
-            Testcase::empty_unary => client::unary_call(&mut client, &mut test_results).await,
+            Testcase::empty_unary => client::empty_unary(&mut client, &mut test_results).await,
+            Testcase::large_unary => client::large_unary(&mut client, &mut test_results).await,
+            Testcase::client_streaming => {
+                client::client_streaming(&mut client, &mut test_results).await
+            }
+
+            Testcase::server_streaming => {
+                client::server_streaming(&mut client, &mut test_results).await
+            }
+
+            Testcase::ping_pong => client::ping_pong(&mut client, &mut test_results).await,
+            Testcase::empty_stream => client::empty_stream(&mut client, &mut test_results).await,
             _ => unimplemented!(),
         }
 

tonic-interop/src/bin/server.rs

@@ -1,8 +1,5 @@
-#![feature(async_await)]
-
-use std::time::Duration;
-use tokio::{net::TcpListener, timer::Delay};
-use tonic::{Request, Response, Status};
+use tokio::net::TcpListener;
+use tonic::{Code, Request, Response, Status};
 use tower_h2::Server;
 
 pub mod pb {
@@ -22,20 +19,53 @@ pub struct TestService {
 #[tonic::server(service = "grpc.testing.TestService", proto = "pb")]
 impl TestService {
     pub async fn empty_call(&self, request: Request<Empty>) -> Result<Response<Empty>, Status> {
-        println!("REQUEST={:?}", request);
+        println!("empty_call; REQUEST={:?}", request);
         Ok(Response::new(Empty {}))
     }
+
+    pub async fn unary_call(
+        &self,
+        request: Request<SimpleRequest>,
+    ) -> Result<Response<SimpleResponse>, Status> {
+        println!("unary_call; REQUEST={:?}", request);
+
+        let req = request.into_inner();
+
+        if let Some(echo_status) = req.response_status {
+            let status = Status::new(Code::from_i32(echo_status.code), echo_status.message);
+            return Err(status);
+        }
+
+        let res_size = if req.response_size >= 0 {
+            req.response_size as usize
+        } else {
+            let status = Status::new(Code::InvalidArgument, "response_size cannot be negative");
+            return Err(status);
+        };
+
+        let res = pb::SimpleResponse {
+            payload: Some(pb::Payload {
+                body: vec![0; res_size],
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+
+        Ok(Response::new(res))
+    }
 }
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let addr = "[::1]:10000".parse().unwrap();
+    pretty_env_logger::init();
+    let addr = "127.0.0.1:10000".parse().unwrap();
     let mut bind = TcpListener::bind(&addr)?;
 
     let greeter = TestService::default();
     let mut server = Server::new(TestServiceServer::new(greeter), Default::default());
 
     while let Ok((sock, _addr)) = bind.accept().await {
+        println!("new connection");
         if let Err(e) = sock.set_nodelay(true) {
             return Err(e.into());
         }