change: update client example

examples/client/src/main.rs

@@ -15,18 +15,10 @@ use std::io::{ BufReader, stdout, stdin };
 use std::fs;
 use tokio::io;
 use tokio::prelude::*;
-use tokio_core::net::TcpStream;
-use tokio_core::reactor::Core;
 use clap::{ App, Arg };
 use rustls::ClientConfig;
 use tokio_rustls::ClientConfigExt;
 
-#[cfg(unix)]
-use tokio::io::AsyncRead;
-
-#[cfg(unix)]
-use tokio_file_unix::{ StdFile, File };
-
 #[cfg(not(unix))]
 use std::io::{Read, Write};
 
@@ -44,17 +36,13 @@ fn main() {
     let matches = app().get_matches();
 
     let host = matches.value_of("host").unwrap();
-    let port = if let Some(port) = matches.value_of("port") {
-        port.parse().unwrap()
-    } else {
-        443
-    };
+    let port = matches.value_of("port")
+        .map(|port| port.parse().unwrap())
+        .unwrap_or(443);
     let domain = matches.value_of("domain").unwrap_or(host);
     let cafile = matches.value_of("cafile");
     let text = format!("GET / HTTP/1.0\r\nHost: {}\r\n\r\n", domain);
 
-    let mut core = Core::new().unwrap();
-    let handle = core.handle();
     let addr = (host, port)
         .to_socket_addrs().unwrap()
         .next().unwrap();
@@ -67,28 +55,28 @@ fn main() {
         config.root_store.add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS);
     }
     let arc_config = Arc::new(config);
-
     let domain = webpki::DNSNameRef::try_from_ascii_str(domain).unwrap();
 
+    // Use async non-blocking I/O for stdin/stdout on Unixy platforms.
+    #[cfg(unix)]
+    {
+        use tokio::io::AsyncRead;
+        use tokio_core::reactor::Core;
+        use tokio_core::net::TcpStream;
+        use tokio_file_unix::{ StdFile, File };
+
+        let mut core = Core::new().unwrap();
+        let handle = core.handle();
         let socket = TcpStream::connect(&addr, &handle);
 
-    // Use async non-blocking I/O for stdin/stdout on Unixy platforms.
-
-    #[cfg(unix)]
         let stdin = stdin();
-
-    #[cfg(unix)]
         let stdin = File::new_nb(StdFile(stdin.lock())).unwrap()
             .into_io(&handle).unwrap();
 
-    #[cfg(unix)]
         let stdout = stdout();
-
-    #[cfg(unix)]
         let stdout = File::new_nb(StdFile(stdout.lock())).unwrap()
             .into_io(&handle).unwrap();
 
-    #[cfg(unix)]
         let resp = socket
             .and_then(|stream| arc_config.connect_async(domain, stream))
             .and_then(|stream| io::write_all(stream, text.as_bytes()))
@@ -100,16 +88,20 @@ fn main() {
                     .map_err(|(e, _)| e)
             });
 
+        core.run(resp).unwrap();
+    }
+
     // XXX: For now, just use blocking I/O for stdin/stdout on other platforms.
     // The network I/O will still be asynchronous and non-blocking.
-
     #[cfg(not(unix))]
+    {
+        use tokio::net::TcpStream;
+
+        let socket = TcpStream::connect(&addr);
+
         let mut input = Vec::new();
-
-    #[cfg(not(unix))]
         stdin().read_to_end(&mut input).unwrap();
 
-    #[cfg(not(unix))]
         let resp = socket
             .and_then(|stream| arc_config.connect_async(domain, stream))
             .and_then(|stream| io::write_all(stream, text.as_bytes()))
@@ -117,5 +109,6 @@ fn main() {
             .and_then(|(stream, _)| io::read_to_end(stream, Vec::new()))
             .and_then(|(_, output)| stdout().write_all(&output));
 
-    core.run(resp).unwrap();
+        resp.wait().unwrap();
+    }
 }