Port to runtime crate

example-service/src/client.rs

@@ -7,29 +7,11 @@
 #![feature(async_await)]
 
 use clap::{App, Arg};
-use futures::{compat::Executor01CompatExt, prelude::*};
-use std::{io, net::SocketAddr};
+use std::io;
 use tarpc::{client, context};
 
-async fn run(server_addr: SocketAddr, name: String) -> io::Result<()> {
-    let transport = json_transport::connect(&server_addr).await?;
-
-    // new_stub is generated by the service! macro. Like Server, it takes a config and any
-    // Transport as input, and returns a Client, also generated by the macro.
-    // by the service mcro.
-    let mut client = service::new_stub(client::Config::default(), transport).await?;
-
-    // The client has an RPC method for each RPC defined in service!. It takes the same args
-    // as defined, with the addition of a Context, which is always the first arg. The Context
-    // specifies a deadline and trace information which can be helpful in debugging requests.
-    let hello = client.hello(context::current(), name).await?;
-
-    println!("{}", hello);
-
-    Ok(())
-}
-
-fn main() {
+#[runtime::main(runtime_tokio::Tokio)]
+async fn main() -> io::Result<()> {
     let flags = App::new("Hello Client")
         .version("0.1")
         .author("Tim <tikue@google.com>")
@@ -53,21 +35,26 @@ fn main() {
         )
         .get_matches();
 
-    tarpc::init(tokio::executor::DefaultExecutor::current().compat());
-
     let server_addr = flags.value_of("server_addr").unwrap();
     let server_addr = server_addr
         .parse()
         .unwrap_or_else(|e| panic!(r#"--server_addr value "{}" invalid: {}"#, server_addr, e));
 
-    let name = flags.value_of("name").unwrap();
+    let name = flags.value_of("name").unwrap().into();
 
-    tarpc::init(tokio::executor::DefaultExecutor::current().compat());
+    let transport = json_transport::connect(&server_addr).await?;
 
-    tokio::run(
-        run(server_addr, name.into())
-            .map_err(|e| eprintln!("Oh no: {}", e))
-            .boxed()
-            .compat(),
-    );
+    // new_stub is generated by the service! macro. Like Server, it takes a config and any
+    // Transport as input, and returns a Client, also generated by the macro.
+    // by the service mcro.
+    let mut client = service::new_stub(client::Config::default(), transport).await?;
+
+    // The client has an RPC method for each RPC defined in service!. It takes the same args
+    // as defined, with the addition of a Context, which is always the first arg. The Context
+    // specifies a deadline and trace information which can be helpful in debugging requests.
+    let hello = client.hello(context::current(), name).await?;
+
+    println!("{}", hello);
+
+    Ok(())
 }

example-service/src/server.rs

@@ -8,7 +8,6 @@
 
 use clap::{App, Arg};
 use futures::{
-    compat::Executor01CompatExt,
     future::{self, Ready},
     prelude::*,
 };
@@ -37,30 +36,8 @@ impl service::Service for HelloServer {
     }
 }
 
-async fn run(server_addr: SocketAddr) -> io::Result<()> {
-    // bincode_transport is provided by the associated crate bincode-transport. It makes it easy
-    // to start up a serde-powered bincode serialization strategy over TCP.
-    json_transport::listen(&server_addr)?
-        // Ignore accept errors.
-        .filter_map(|r| future::ready(r.ok()))
-        .map(server::BaseChannel::with_defaults)
-        // Limit channels to 1 per IP.
-        .max_channels_per_key(1, |t| t.as_ref().peer_addr().unwrap().ip())
-        // serve is generated by the service! macro. It takes as input any type implementing
-        // the generated Service trait.
-        .map(|channel| {
-            let server = HelloServer(channel.as_ref().as_ref().peer_addr().unwrap());
-            channel.respond_with(service::serve(server))
-        })
-        // Max 10 channels.
-        .buffer_unordered(10)
-        .for_each(|_| futures::future::ready(()))
-        .await;
-
-    Ok(())
-}
-
-fn main() {
+#[runtime::main(runtime_tokio::Tokio)]
+async fn main() -> io::Result<()> {
     env_logger::init();
 
     let flags = App::new("Hello Server")
@@ -83,12 +60,26 @@ fn main() {
         .parse()
         .unwrap_or_else(|e| panic!(r#"--port value "{}" invalid: {}"#, port, e));
 
-    tarpc::init(tokio::executor::DefaultExecutor::current().compat());
+    let server_addr = ([0, 0, 0, 0], port).into();
 
-    tokio::run(
-        run(([0, 0, 0, 0], port).into())
-            .map_err(|e| eprintln!("Oh no: {}", e))
-            .boxed()
-            .compat(),
-    );
+    // bincode_transport is provided by the associated crate bincode-transport. It makes it easy
+    // to start up a serde-powered bincode serialization strategy over TCP.
+    json_transport::listen(&server_addr)?
+        // Ignore accept errors.
+        .filter_map(|r| future::ready(r.ok()))
+        .map(server::BaseChannel::with_defaults)
+        // Limit channels to 1 per IP.
+        .max_channels_per_key(1, |t| t.as_ref().peer_addr().unwrap().ip())
+        // serve is generated by the service! macro. It takes as input any type implementing
+        // the generated Service trait.
+        .map(|channel| {
+            let server = HelloServer(channel.as_ref().as_ref().peer_addr().unwrap());
+            channel.respond_with(service::serve(server))
+        })
+        // Max 10 channels.
+        .buffer_unordered(10)
+        .for_each(|_| futures::future::ready(()))
+        .await;
+
+    Ok(())
 }