Tokio 0.3 Upgrade (#2319)

Co-authored-by: Urhengulas <johann.hemmann@code.berlin>
Co-authored-by: Eliza Weisman <eliza@buoyant.io>

benches/body.rs

@@ -10,8 +10,7 @@ use hyper::body::Body;
 
 macro_rules! bench_stream {
     ($bencher:ident, bytes: $bytes:expr, count: $count:expr, $total_ident:ident, $body_pat:pat, $block:expr) => {{
-        let mut rt = tokio::runtime::Builder::new()
-            .basic_scheduler()
+        let rt = tokio::runtime::Builder::new_current_thread()
             .build()
             .expect("rt build");
 

benches/connect.rs

@@ -12,12 +12,11 @@ use tokio::net::TcpListener;
 #[bench]
 fn http_connector(b: &mut test::Bencher) {
     let _ = pretty_env_logger::try_init();
-    let mut rt = tokio::runtime::Builder::new()
+    let rt = tokio::runtime::Builder::new_current_thread()
         .enable_all()
-        .basic_scheduler()
         .build()
         .expect("rt build");
-    let mut listener = rt
+    let listener = rt
         .block_on(TcpListener::bind(&SocketAddr::from(([127, 0, 0, 1], 0))))
         .expect("bind");
     let addr = listener.local_addr().expect("local_addr");

benches/end_to_end.rs

@@ -270,14 +270,16 @@ impl Opts {
     }
 
     fn bench(self, b: &mut test::Bencher) {
+        use std::sync::Arc;
         let _ = pretty_env_logger::try_init();
         // Create a runtime of current thread.
-        let mut rt = tokio::runtime::Builder::new()
-            .enable_all()
-            .basic_scheduler()
-            .build()
-            .expect("rt build");
-        let exec = rt.handle().clone();
+        let rt = Arc::new(
+            tokio::runtime::Builder::new_current_thread()
+                .enable_all()
+                .build()
+                .expect("rt build"),
+        );
+        let exec = rt.clone();
 
         let req_len = self.request_body.map(|b| b.len()).unwrap_or(0) as u64;
         let req_len = if self.request_chunks > 0 {
@@ -288,7 +290,7 @@ impl Opts {
         let bytes_per_iter = (req_len + self.response_body.len() as u64) * self.parallel_cnt as u64;
         b.bytes = bytes_per_iter;
 
-        let addr = spawn_server(&mut rt, &self);
+        let addr = spawn_server(&rt, &self);
 
         let connector = HttpConnector::new();
         let client = hyper::Client::builder()
@@ -351,7 +353,7 @@ impl Opts {
     }
 }
 
-fn spawn_server(rt: &mut tokio::runtime::Runtime, opts: &Opts) -> SocketAddr {
+fn spawn_server(rt: &tokio::runtime::Runtime, opts: &Opts) -> SocketAddr {
     use hyper::service::{make_service_fn, service_fn};
     let addr = "127.0.0.1:0".parse().unwrap();
 

benches/pipeline.rs

@@ -31,9 +31,8 @@ fn hello_world(b: &mut test::Bencher) {
                 }))
             });
 
-            let mut rt = tokio::runtime::Builder::new()
+            let rt = tokio::runtime::Builder::new_current_thread()
                 .enable_all()
-                .basic_scheduler()
                 .build()
                 .expect("rt build");
             let srv = rt.block_on(async move {

benches/server.rs

@@ -34,9 +34,8 @@ macro_rules! bench_server {
                     }))
                 });
 
-                let mut rt = tokio::runtime::Builder::new()
+                let rt = tokio::runtime::Builder::new_current_thread()
                     .enable_all()
-                    .basic_scheduler()
                     .build()
                     .expect("rt build");
 
@@ -185,6 +184,7 @@ fn raw_tcp_throughput_large_payload(b: &mut test::Bencher) {
         let mut buf = [0u8; 8192];
         while rx.try_recv().is_err() {
             let r = sock.read(&mut buf).unwrap();
+            extern crate test;
             if r == 0 {
                 break;
             }