Fix interoptests and rewrite decode

tonic-interop/src/bin/client.rs

@@ -1,5 +1,5 @@
-use tonic_interop::client;
 use structopt::{clap::arg_enum, StructOpt};
+use tonic_interop::client;
 
 #[derive(StructOpt)]
 struct Opts {
@@ -9,7 +9,7 @@ struct Opts {
         min_values = 1,
         raw(possible_values = r#"&Testcase::variants()"#)
     )]
-    test_case: Vec<Testcase>
+    test_case: Vec<Testcase>,
 }
 
 #[tokio::main]
@@ -52,7 +52,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             Testcase::unimplemented_service => {
                 client::unimplemented_service(&mut unimplemented_client, &mut test_results).await
             }
-            Testcase::custom_metadata => client::custom_metadata(&mut client, &mut test_results).await,
+            Testcase::custom_metadata => {
+                client::custom_metadata(&mut client, &mut test_results).await
+            }
             _ => unimplemented!(),
         }
 

tonic-interop/src/bin/server.rs

@@ -1,6 +1,5 @@
-use tokio::net::TcpListener;
+use hyper::Server;
 use tonic::{Code, Request, Response, Status};
-use tower_h2::{Server, Builder};
 
 pub mod pb {
     #![allow(dead_code)]
@@ -18,8 +17,8 @@ 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!("empty_call; REQUEST={:?}", request);
+    pub async fn empty_call(&self, _request: Request<Empty>) -> Result<Response<Empty>, Status> {
+        println!("empty_call");
         Ok(Response::new(Empty {}))
     }
 
@@ -27,7 +26,7 @@ impl TestService {
         &self,
         request: Request<SimpleRequest>,
     ) -> Result<Response<SimpleResponse>, Status> {
-        println!("unary_call; REQUEST={:?}", request);
+        println!("unary_call");
 
         let req = request.into_inner();
 
@@ -59,23 +58,13 @@ impl TestService {
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     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 settings = Builder::default();
-    settings.initial_connection_window_size(1_000_000_000);
-    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());
-        }
-
-        if let Err(e) = server.serve(sock).await {
-            println!("H2 ERROR: {}", e);
-        }
-    }
+    Server::bind(&addr)
+        .http2_only(true)
+        .serve(TestServiceServer::new(greeter))
+        .await?;
 
     Ok(())
 }

tonic-interop/src/client.rs

@@ -1,12 +1,15 @@
 use crate::{pb::*, test_assert, TestAssertion};
 use futures_util::{future, stream, SinkExt, StreamExt};
+use hyper::client::conn::{Builder, SendRequest};
+use hyper::client::connect::HttpConnector;
+use hyper::client::service::{Connect, MakeService};
 use std::net::SocketAddr;
-use tokio::{net::TcpStream, sync::mpsc};
+use tokio::sync::mpsc;
+use tonic::service::add_origin::AddOrigin;
 use tonic::{metadata::MetadataValue, Code, Request, Response, Status};
-use tower_h2::{add_origin::AddOrigin, Connection};
 
-pub type Client = TestServiceClient<AddOrigin<Connection<tonic::BoxBody>>>;
-pub type UnimplementedClient = UnimplementedServiceClient<AddOrigin<Connection<tonic::BoxBody>>>;
+pub type Client = TestServiceClient<AddOrigin<SendRequest<tonic::BoxBody>>>;
+pub type UnimplementedClient = UnimplementedServiceClient<AddOrigin<SendRequest<tonic::BoxBody>>>;
 
 tonic::client!(service = "grpc.testing.TestService", proto = "crate::pb");
 tonic::client!(
@@ -23,11 +26,12 @@ const SPECIAL_TEST_STATUS_MESSAGE: &'static str =
     "\t\ntest with whitespace\r\nand Unicode BMP ☺ and non-BMP 😈\t\n";
 
 pub async fn create(addr: SocketAddr) -> Result<Client, Box<dyn std::error::Error>> {
-    let io = TcpStream::connect(&addr).await?;
-
     let origin = http::Uri::from_shared(format!("http://{}", addr).into()).unwrap();
 
-    let svc = Connection::handshake(io).await?;
+    let settings = Builder::new().http2_only(true).clone();
+    let mut maker = Connect::new(HttpConnector::new(1), settings);
+
+    let svc = maker.make_service(origin.clone()).await?;
     let svc = AddOrigin::new(svc, origin);
 
     Ok(TestServiceClient::new(svc))
@@ -36,11 +40,12 @@ pub async fn create(addr: SocketAddr) -> Result<Client, Box<dyn std::error::Erro
 pub async fn create_unimplemented(
     addr: SocketAddr,
 ) -> Result<UnimplementedClient, Box<dyn std::error::Error>> {
-    let io = TcpStream::connect(&addr).await?;
-
     let origin = http::Uri::from_shared(format!("http://{}", addr).into()).unwrap();
 
-    let svc = Connection::handshake(io).await?;
+    let settings = Builder::new().http2_only(true).clone();
+    let mut maker = Connect::new(HttpConnector::new(1), settings);
+
+    let svc = maker.make_service(origin.clone()).await?;
     let svc = AddOrigin::new(svc, origin);
 
     Ok(UnimplementedServiceClient::new(svc))