Merge pull request #23 from yoshuawuyts/fix-server

Fix URL parsing in server code

Author: yoshuawuyts

Cargo.toml

@@ -15,7 +15,7 @@ edition = "2018"
 url = "2.1.0"
 httparse = "1.3.3"
 futures-io = "0.3.0"
-async-std = { version = "0.99.12", features = ["unstable"] }
+async-std = { version = "1", features = ["unstable"] }
 futures-core-preview = "0.3.0-alpha.18"
 http-types = { path = '../http-types' }
 

examples/server.rs

@@ -8,24 +8,37 @@ use async_std::prelude::*;
 use async_std::task::{self, Context, Poll};
 use http_types::{Response, StatusCode};
 
+async fn accept(addr: String, stream: TcpStream) -> Result<(), async_h1::Exception> {
+    // 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::connect(&addr, stream.clone(), stream, |_| {
+        async {
+            let resp = Response::new(StatusCode::Ok)
+                .set_header("Content-Type", "text/plain")?
+                .set_body_string("Hello, World!".to_string())?;
+            Ok(resp)
+        }
+    })
+    .await
+}
+
 fn main() -> Result<(), async_h1::Exception> {
     task::block_on(async {
         let listener = net::TcpListener::bind(("127.0.0.1", 8080)).await?;
-        println!("listening on {}", listener.local_addr()?);
+        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 {
-                let stream = stream?;
-                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::connect(stream.clone(), stream, |_| {
-                    async { Ok(Response::new(StatusCode::Ok)) }
-                })
-                .await
+                if let Err(err) = accept(addr, stream).await {
+                    eprintln!("{}", err);
+                }
             });
         }
         Ok(())

src/date.rs

@@ -13,7 +13,7 @@ const SECONDS_IN_HOUR: u64 = 3600;
 
 /// Format using the `Display` trait.
 /// Convert timestamp into/from `SytemTime` to use.
-/// Supports comparsion and sorting.
+/// Supports comparison and sorting.
 #[derive(Copy, Clone, Debug, Eq, Ord)]
 pub struct HttpDate {
     /// 0...59

src/server.rs

@@ -15,7 +15,8 @@ use std::pin::Pin;
 
 use crate::{Exception, MAX_HEADERS};
 
-pub async fn connect<'a, R, W, F, Fut>(
+pub async fn connect<R, W, F, Fut>(
+    addr: &str,
     reader: R,
     mut writer: W,
     callback: F,
@@ -33,7 +34,7 @@ where
 
     // Decode a request. This may be the first of many since
     // the connection is Keep-Alive by default
-    let decoded = decode(reader).await?;
+    let decoded = decode(addr, reader).await?;
     // Decode returns one of three things;
     // * A request with its body reader set to the underlying TCP stream
     // * A request with an empty body AND the underlying stream
@@ -60,7 +61,7 @@ where
 
             // Decode a new request, timing out if this takes longer than the
             // timeout duration.
-            decoded = match timeout(timeout_duration, decode(to_decode)).await {
+            decoded = match timeout(timeout_duration, decode(addr, to_decode)).await {
                 Ok(Ok(Some(r))) => r,
                 Ok(Ok(None)) | Err(TimeoutError { .. }) => break, /* EOF or timeout */
                 Ok(Err(e)) => return Err(e),
@@ -170,7 +171,7 @@ pub async fn encode(res: Response) -> io::Result<Encoder> {
 const HTTP_1_1_VERSION: u8 = 1;
 
 /// Decode an HTTP request on the server.
-pub async fn decode<R>(reader: R) -> Result<Option<DecodedRequest>, Exception>
+pub async fn decode<R>(addr: &str, reader: R) -> Result<Option<DecodedRequest>, Exception>
 where
     R: Read + Unpin + Send + 'static,
 {
@@ -204,7 +205,7 @@ where
     // Convert httparse headers + body into a `http::Request` type.
     let method = httparse_req.method.ok_or_else(|| "No method found")?;
     let uri = httparse_req.path.ok_or_else(|| "No uri found")?;
-    let uri = url::Url::parse(uri)?;
+    let uri = url::Url::parse(&format!("{}{}", addr, uri))?;
     let version = httparse_req.version.ok_or_else(|| "No version found")?;
     if version != HTTP_1_1_VERSION {
         return Err("Unsupported HTTP version".into());