add workaround for sync issues

Author: dignifiedquire

src/chunked.rs

@@ -4,7 +4,7 @@ use std::pin::Pin;
 use std::str::FromStr;
 use std::task::{Context, Poll};
 
-use async_std::io::{self, BufRead, Read};
+use async_std::io::{self, Read};
 use async_std::sync::{channel, Arc, Receiver, Sender};
 use byte_pool::{Block, BytePool};
 use http_types::headers::{HeaderName, HeaderValue};
@@ -19,7 +19,7 @@ lazy_static::lazy_static! {
 
 /// Decodes a chunked body according to
 /// https://tools.ietf.org/html/rfc7230#section-4.1
-pub struct ChunkedDecoder<R: BufRead> {
+pub struct ChunkedDecoder<R: Read> {
     /// The underlying stream
     inner: R,
     /// Buffer for the already read, but not yet parsed data.
@@ -37,7 +37,7 @@ pub struct ChunkedDecoder<R: BufRead> {
     trailer_receiver: Receiver<Vec<(HeaderName, HeaderValue)>>,
 }
 
-impl<R: BufRead> ChunkedDecoder<R> {
+impl<R: Read> ChunkedDecoder<R> {
     pub fn new(inner: R) -> Self {
         let (sender, receiver) = channel(1);
 
@@ -152,7 +152,7 @@ fn decode_trailer(buffer: Block<'static>, pos: &Position) -> io::Result<DecodeRe
     }
 }
 
-impl<R: BufRead + Unpin + Send + 'static> ChunkedDecoder<R> {
+impl<R: Read + Unpin> ChunkedDecoder<R> {
     fn poll_read_chunk(
         &mut self,
         cx: &mut Context<'_>,
@@ -277,7 +277,7 @@ impl<R: BufRead + Unpin + Send + 'static> ChunkedDecoder<R> {
     }
 }
 
-impl<R: BufRead + Unpin + Send + 'static> Read for ChunkedDecoder<R> {
+impl<R: Read + Unpin> Read for ChunkedDecoder<R> {
     #[allow(missing_doc_code_examples)]
     fn poll_read(
         mut self: Pin<&mut Self>,

src/client.rs

@@ -59,12 +59,14 @@ pub async fn encode(req: Request) -> Result<Encoder, std::io::Error> {
         url.push_str(query);
     }
 
-    write!(&mut buf, "{} {} HTTP/1.1\r\n", req.method(), url).await?;
+    let val = format!("{} {} HTTP/1.1\r\n", req.method(), url);
+    buf.write_all(val.as_bytes()).await?;
 
     // If the body isn't streaming, we can set the content-length ahead of time. Else we need to
     // send all items in chunks.
     if let Some(len) = req.len() {
-        write!(&mut buf, "Content-Length: {}\r\n", len).await?;
+        let val = format!("Content-Length: {}\r\n", len);
+        buf.write_all(val.as_bytes()).await?;
     } else {
         // write!(&mut buf, "Transfer-Encoding: chunked\r\n")?;
         panic!("chunked encoding is not implemented yet");
@@ -73,18 +75,20 @@ pub async fn encode(req: Request) -> Result<Encoder, std::io::Error> {
     }
     for (header, values) in req.iter() {
         for value in values.iter() {
-            write!(&mut buf, "{}: {}\r\n", header, value).await?;
+            let val = format!("{}: {}\r\n", header, value);
+            buf.write_all(val.as_bytes()).await?;
         }
     }
 
-    write!(&mut buf, "\r\n").await?;
+    buf.write_all(b"\r\n").await?;
+
     Ok(Encoder::new(buf, req))
 }
 
 /// Decode an HTTP respons on the client.
 pub async fn decode<R>(reader: R) -> Result<Response, Exception>
 where
-    R: Read + Unpin + Send + 'static,
+    R: Read + Unpin + Send + Sync + 'static,
 {
     let mut reader = BufReader::new(reader);
     let mut buf = Vec::new();

src/server.rs

@@ -50,7 +50,7 @@ impl Error for HttpError {
 /// Supports `KeepAlive` requests by default.
 pub async fn accept<RW, F, Fut>(addr: &str, mut io: RW, endpoint: F) -> Result<(), Exception>
 where
-    RW: Read + Write + Clone + Send + Unpin + 'static,
+    RW: Read + Write + Clone + Send + Sync + Unpin + 'static,
     F: Fn(Request) -> Fut,
     Fut: Future<Output = Result<Response, Exception>>,
 {
@@ -359,7 +359,7 @@ const HTTP_1_1_VERSION: u8 = 1;
 /// Decode an HTTP request on the server.
 async fn decode<R>(addr: &str, reader: R) -> Result<Option<Request>, Exception>
 where
-    R: Read + Unpin + Send + 'static,
+    R: Read + Unpin + Send + Sync + 'static,
 {
     let mut reader = BufReader::new(reader);
     let mut buf = Vec::new();