tokio: rewrite examples with async. (#1228)

tokio/examples/echo-udp.rs

@@ -0,0 +1,69 @@
+//! An UDP echo server that just sends back everything that it receives.
+//!
+//! If you're on Unix you can test this out by in one terminal executing:
+//!
+//!     cargo run --example echo-udp
+//!
+//! and in another terminal you can run:
+//!
+//!     cargo run --example connect -- --udp 127.0.0.1:8080
+//!
+//! Each line you type in to the `nc` terminal should be echo'd back to you!
+
+#![feature(async_await)]
+#![deny(warnings, rust_2018_idioms)]
+
+use std::net::SocketAddr;
+use std::{env, io};
+use tokio;
+use tokio::net::UdpSocket;
+
+struct Server {
+    socket: UdpSocket,
+    buf: Vec<u8>,
+    to_send: Option<(usize, SocketAddr)>,
+}
+
+impl Server {
+    async fn run(self) -> Result<(), io::Error> {
+        let Server {
+            mut socket,
+            mut buf,
+            mut to_send,
+        } = self;
+
+        loop {
+            // First we check to see if there's a message we need to echo back.
+            // If so then we try to send it back to the original source, waiting
+            // until it's writable and we're able to do so.
+            if let Some((size, peer)) = to_send {
+                let amt = socket.send_to(&buf[..size], &peer).await?;
+
+                println!("Echoed {}/{} bytes to {}", amt, size, peer);
+            }
+
+            // If we're here then `to_send` is `None`, so we take a look for the
+            // next message we're going to echo back.
+            to_send = Some(socket.recv_from(&mut buf).await?);
+        }
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
+    let addr = addr.parse::<SocketAddr>()?;
+
+    let socket = UdpSocket::bind(&addr)?;
+    println!("Listening on: {}", socket.local_addr()?);
+
+    let server = Server {
+        socket: socket,
+        buf: vec![0; 1024],
+        to_send: None,
+    };
+
+    // This starts the server task.
+    server.run().await?;
+    Ok(())
+}

tokio/examples/hello_world.rs

@@ -0,0 +1,34 @@
+//! Hello world server.
+//!
+//! A simple client that opens a TCP stream, writes "hello world\n", and closes
+//! the connection.
+//!
+//! You can test this out by running:
+//!
+//!     ncat -l 6142
+//!
+//! And then in another terminal run:
+//!
+//!     cargo run --example hello_world
+
+#![deny(warnings, rust_2018_idioms)]
+#![feature(async_await)]
+
+use tokio;
+use tokio::io::AsyncWriteExt;
+use tokio::net::TcpStream;
+
+#[tokio::main]
+pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let addr = "127.0.0.1:6142".parse()?;
+
+    // Open a TCP stream to the socket address.
+    //
+    // Note that this is the Tokio TcpStream, which is fully async.
+    let mut stream = TcpStream::connect(&addr).await?;
+    println!("created stream");
+    let result = stream.write(b"hello world\n").await;
+    println!("wrote to stream; success={:?}", result.is_ok());
+
+    Ok(())
+}

tokio/examples/udp-client.rs

@@ -0,0 +1,69 @@
+//! A UDP client that just sends everything it gets via `stdio` in a single datagram, and then
+//! waits for a reply.
+//!
+//! For the reasons of simplicity data from `stdio` is read until `EOF` in a blocking manner.
+//!
+//! You can test this out by running an echo server:
+//!
+//! ```
+//!     $ cargo run --example echo-udp -- 127.0.0.1:8080
+//! ```
+//!
+//! and running the client in another terminal:
+//!
+//! ```
+//!     $ cargo run --example udp-client
+//! ```
+//!
+//! You can optionally provide any custom endpoint address for the client:
+//!
+//! ```
+//!     $ cargo run --example udp-client -- 127.0.0.1:8080
+//! ```
+//!
+//! Don't forget to pass `EOF` to the standard input of the client!
+//!
+//! Please mind that since the UDP protocol doesn't have any capabilities to detect a broken
+//! connection the server needs to be run first, otherwise the client will block forever.
+
+#![feature(async_await)]
+#![deny(warnings, rust_2018_idioms)]
+
+use std::env;
+use std::io::{stdin, Read};
+use std::net::SocketAddr;
+use tokio::net::UdpSocket;
+
+fn get_stdin_data() -> Result<Vec<u8>, Box<dyn std::error::Error>> {
+    let mut buf = Vec::new();
+    stdin().read_to_end(&mut buf)?;
+    Ok(buf)
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let remote_addr: SocketAddr = env::args()
+        .nth(1)
+        .unwrap_or("127.0.0.1:8080".into())
+        .parse()?;
+    // We use port 0 to let the operating system allocate an available port for us.
+    let local_addr: SocketAddr = if remote_addr.is_ipv4() {
+        "0.0.0.0:0"
+    } else {
+        "[::]:0"
+    }
+    .parse()?;
+    let mut socket = UdpSocket::bind(&local_addr)?;
+    const MAX_DATAGRAM_SIZE: usize = 65_507;
+    socket.connect(&remote_addr)?;
+    let data = get_stdin_data()?;
+    socket.send(&data).await?;
+    let mut data = vec![0u8; MAX_DATAGRAM_SIZE];
+    let len = socket.recv(&mut data).await?;
+    println!(
+        "Received {} bytes:\n{}",
+        len,
+        String::from_utf8_lossy(&data[..len])
+    );
+    Ok(())
+}