Update async-std and simplify examples

Author: yoshuawuyts

Cargo.toml

@@ -14,7 +14,7 @@ edition = "2018"
 [dependencies]
 url = "2.1.0"
 httparse = "1.3.3"
-async-std = { version = "1.4.0", default-features = false }
+async-std = { version = "1.5.0", features = ["unstable"] }
 http-types = { path = '../http-types' }
 pin-project-lite = "0.1.1"
 byte-pool = "0.2.1"

examples/server.rs

@@ -1,83 +1,38 @@
-use std::pin::Pin;
-use std::str::FromStr;
-use std::sync::Arc;
-
-use async_h1::server;
-use async_std::io::{self, Read, Write};
-use async_std::net::{self, TcpStream};
+use async_std::net::{TcpStream, TcpListener};
 use async_std::prelude::*;
-use async_std::task::{self, Context, Poll};
-use http_types::headers::{HeaderName, HeaderValue};
-use http_types::{Error, Response, StatusCode};
-
-async fn accept(addr: String, stream: TcpStream) -> Result<(), Error> {
-    // println!("starting new connection from {}", stream.peer_addr()?);
-
-    // TODO: Delete this line when we implement `Clone` for `TcpStream`.
-    let stream = Stream(Arc::new(stream));
-
-    server::accept(&addr, stream.clone(), |req| {
-        async move {
-            dbg!(req.method());
-            let mut resp = Response::new(StatusCode::Ok);
-            resp.insert_header(
-                HeaderName::from_str("Content-Type")?,
-                HeaderValue::from_str("text/plain")?,
-            )?;
-            resp.set_body("Hello");
-            // To try chunked encoding, replace `set_body_string` with the following method call
-            // .set_body(io::Cursor::new(vec![
-            //     0x48u8, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x77, 0x6F, 0x72, 0x6C, 0x64, 0x21,
-            // ]));
-            Ok(resp)
-        }
-    })
-    .await
-}
-
-fn main() -> Result<(), Error> {
-    task::block_on(async {
-        let listener = net::TcpListener::bind(("127.0.0.1", 8080)).await?;
-        let addr = format!("http://{}", listener.local_addr()?);
-        println!("listening on {}", addr);
-        let mut incoming = listener.incoming();
-
-        while let Some(stream) = incoming.next().await {
-            let stream = stream?;
-            let addr = addr.clone();
-            task::spawn(async {
-                if let Err(err) = accept(addr, stream).await {
-                    eprintln!("{}", err);
-                }
-            });
-        }
-        Ok(())
-    })
-}
-
-#[derive(Clone)]
-struct Stream(Arc<TcpStream>);
-
-impl Read for Stream {
-    fn poll_read(
-        self: Pin<&mut Self>,
-        cx: &mut Context,
-        buf: &mut [u8],
-    ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut &*self.0).poll_read(cx, buf)
+use async_std::task;
+use http_types::{Response, StatusCode};
+
+#[async_std::main]
+async fn main() -> http_types::Result<()> {
+    // Open up a TCP connection and create a URL.
+    let listener = TcpListener::bind(("127.0.0.1", 8080)).await?;
+    let addr = format!("http://{}", listener.local_addr()?);
+    println!("listening on {}", addr);
+
+    // For each incoming TCP connection, spawn a task and call `accept`.
+    let mut incoming = listener.incoming();
+    while let Some(stream) = incoming.next().await {
+        let stream = stream?;
+        let addr = addr.clone();
+        task::spawn(async {
+            if let Err(err) = accept(addr, stream).await {
+                eprintln!("{}", err);
+            }
+        });
     }
+    Ok(())
 }
 
-impl Write for Stream {
-    fn poll_write(self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) -> Poll<io::Result<usize>> {
-        Pin::new(&mut &*self.0).poll_write(cx, buf)
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
-        Pin::new(&mut &*self.0).poll_flush(cx)
-    }
-
-    fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
-        Pin::new(&mut &*self.0).poll_close(cx)
-    }
+// Take a TCP stream, and convert it into sequential HTTP request / response pairs.
+async fn accept(addr: String, stream: TcpStream) -> http_types::Result<()> {
+    println!("starting new connection from {}", stream.peer_addr()?);
+    async_h1::server::accept(&addr, stream.clone(), |_req| async move {
+        let mut res = Response::new(StatusCode::Ok);
+        res.insert_header("Content-Type", "text/plain")?;
+        res.set_body("Hello");
+        Ok(res)
+    })
+    .await?;
+    Ok(())
 }