Merge pull request #17 from yoshuawuyts/http-types

Switch over to http-types

Author: yoshuawuyts

Cargo.toml

@@ -12,11 +12,12 @@ readme = "README.md"
 edition = "2018"
 
 [dependencies]
+url = "2.1.0"
 httparse = "1.3.3"
-http = "0.1.17"
 futures-io = "0.3.0"
 async-std = { version = "0.99.12", features = ["unstable"] }
 futures-core-preview = "0.3.0-alpha.18"
+http-types = { path = '../http-types' }
 
 [dev-dependencies]
 futures-util = "0.3.0"

examples/client.rs

@@ -1,24 +1,81 @@
-use async_h1::{client, Body};
+use async_h1::client;
 use async_std::{io, net, task};
+use http_types::{Method, Request, Url};
 
 fn main() -> Result<(), async_h1::Exception> {
     task::block_on(async {
         let tcp_stream = net::TcpStream::connect("127.0.0.1:8080").await?;
         println!("connecting to {}", tcp_stream.peer_addr()?);
 
+        let stream = Stream::new(tcp_stream);
         for i in 0usize..2 {
-            let (tcp_reader, tcp_writer) = &mut (&tcp_stream, &tcp_stream);
-
             println!("making request {}/2", i + 1);
 
-            let body = Body::from_string("hello chashu".to_owned());
-            let mut req = client::encode(http::Request::new(body)).await?;
-            io::copy(&mut req, tcp_writer).await?;
+            let mut req =
+                client::encode(Request::new(Method::Get, Url::parse("/foo").unwrap())).await?;
+            io::copy(&mut req, &mut stream.clone()).await?;
 
             // read the response
-            let res = client::decode(tcp_reader).await?;
+            let res = client::decode(stream.clone()).await?;
             println!("{:?}", res);
         }
         Ok(())
     })
 }
+
+use async_std::{
+    io::{Read, Write},
+    net::TcpStream,
+    task::{Context, Poll},
+};
+use std::{
+    pin::Pin,
+    sync::{Arc, Mutex},
+};
+
+struct Stream {
+    internal: Arc<Mutex<TcpStream>>,
+}
+
+impl Stream {
+    fn new(internal: TcpStream) -> Self {
+        Stream {
+            internal: Arc::new(Mutex::new(internal)),
+        }
+    }
+}
+
+impl Clone for Stream {
+    fn clone(&self) -> Self {
+        Stream {
+            internal: self.internal.clone(),
+        }
+    }
+}
+
+impl Read for Stream {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context,
+        buf: &mut [u8],
+    ) -> Poll<io::Result<usize>> {
+        <TcpStream as Read>::poll_read(Pin::new(&mut self.internal.lock().unwrap()), cx, buf)
+    }
+}
+impl Write for Stream {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        <TcpStream as Write>::poll_write(Pin::new(&mut self.internal.lock().unwrap()), cx, buf)
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
+        <TcpStream as Write>::poll_flush(Pin::new(&mut self.internal.lock().unwrap()), cx)
+    }
+
+    fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
+        <TcpStream as Write>::poll_close(Pin::new(&mut self.internal.lock().unwrap()), cx)
+    }
+}

examples/server.rs

@@ -1,7 +1,8 @@
-use async_h1::{server, Body};
+use async_h1::server;
 use async_std::net;
 use async_std::prelude::*;
 use async_std::task;
+use http_types::{Response, StatusCode};
 
 fn main() -> Result<(), async_h1::Exception> {
     task::block_on(async {
@@ -14,16 +15,70 @@ fn main() -> Result<(), async_h1::Exception> {
                 let stream = stream?;
                 println!("starting new connection from {}", stream.peer_addr()?);
 
-                let (reader, writer) = &mut (&stream, &stream);
-                server::connect(reader, writer, |_| {
-                    async {
-                        let body = Body::from_string("hello chashu".to_owned());
-                        Ok(http::Response::new(body))
-                    }
+                let stream = Stream::new(stream);
+                server::connect(stream.clone(), stream, |_| {
+                    async { Ok(Response::new(StatusCode::Ok)) }
                 })
                 .await
             });
         }
         Ok(())
     })
 }
+
+use async_std::{
+    io::{self, Read, Write},
+    net::TcpStream,
+    task::{Context, Poll},
+};
+use std::{
+    pin::Pin,
+    sync::{Arc, Mutex},
+};
+
+struct Stream {
+    internal: Arc<Mutex<TcpStream>>,
+}
+
+impl Stream {
+    fn new(internal: TcpStream) -> Self {
+        Stream {
+            internal: Arc::new(Mutex::new(internal)),
+        }
+    }
+}
+
+impl Clone for Stream {
+    fn clone(&self) -> Self {
+        Stream {
+            internal: self.internal.clone(),
+        }
+    }
+}
+
+impl Read for Stream {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context,
+        buf: &mut [u8],
+    ) -> Poll<io::Result<usize>> {
+        <TcpStream as Read>::poll_read(Pin::new(&mut self.internal.lock().unwrap()), cx, buf)
+    }
+}
+impl Write for Stream {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        <TcpStream as Write>::poll_write(Pin::new(&mut self.internal.lock().unwrap()), cx, buf)
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
+        <TcpStream as Write>::poll_flush(Pin::new(&mut self.internal.lock().unwrap()), cx)
+    }
+
+    fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
+        <TcpStream as Write>::poll_close(Pin::new(&mut self.internal.lock().unwrap()), cx)
+    }
+}