Update HttpStream

Author: saulvaldelvira

crates/client/src/main.rs

@@ -6,7 +6,7 @@ use std::{
     process,
 };
 
-use http::{HttpMethod, HttpRequest, HttpStream};
+use http::{HttpMethod, HttpRequest};
 mod config;
 use config::ClientConfig;
 
@@ -57,7 +57,6 @@ pub fn main() -> http::Result<()> {
             process::exit(1);
         }
     };
-    let tcp = HttpStream::from(tcp);
     let mut result = req.send_to(tcp).unwrap_or_else(|err| {
         eprint!("ERROR: {err}");
         process::exit(1);

crates/http/Cargo.toml

@@ -16,10 +16,19 @@ path = "src/lib.rs"
 base64 = { package = "rb64", version = ">=0.1.0", git = "https://github.com/saulvaldelvira/rb64" }
 url = { package = "url-utils", version = ">=0.1.0", path = "../url" }
 
+[dependencies.rustls]
+version = "0.23.28"
+optional = true
+default-features = false
+features = ["std"]
+
 [dependencies.builders]
 package = "builders"
 default-features = false
 features = ["builder"]
-version = ">=0.1.0"
+version = ">=0.5.0"
 git = "https://github.com/saulvaldelvira/builders"
 
+[features]
+default = []
+tls = ["dep:rustls"]

crates/http/src/lib.rs

@@ -12,7 +12,7 @@
 //!             .url("/")
 //!             .build().unwrap();
 //! let tcp = TcpStream::connect("127.0.0.1:80").unwrap();
-//! req.send_to(HttpStream::from(tcp)).unwrap();
+//! req.send_to(tcp).unwrap();
 //! ```
 
 pub mod encoding;

crates/http/src/request/mod.rs

@@ -1,23 +1,29 @@
 /* pub mod handler; */
 use builders::Builder;
 mod parse;
+use core::fmt;
 use std::{
     collections::HashMap,
     env,
     ffi::OsStr,
-    io::{BufReader, Read, Write},
+    io::{BufRead, BufReader, Read, Write},
     path::Path,
 };
 
 use parse::parse_request;
 
-use crate::{HttpMethod, HttpResponse, HttpStream, Result, StatusCode, encoding::Chunked};
+use crate::{
+    HttpMethod, HttpResponse, HttpStream, Result, StatusCode,
+    encoding::Chunked,
+    stream::{self, IntoHttpStream},
+};
 
 /// HTTP Request
 ///
 /// Represents an HTTP request
-#[derive(Builder, Debug)]
+#[derive(Builder)]
 pub struct HttpRequest {
+    #[builder(def = { HttpMethod::GET })]
     method: HttpMethod,
     url: Box<str>,
     #[builder(map = "header")]
@@ -28,35 +34,55 @@ pub struct HttpRequest {
     response_headers: HashMap<Box<str>, Box<str>>,
     #[builder(def = 1.0)]
     version: f32,
-    #[builder(disabled = true)]
-    #[builder(def = { BufReader::new(HttpStream::dummy()) })]
-    stream: BufReader<HttpStream>,
+    #[builder(def = { BufReader::new(stream::dummy())} )]
+    stream: BufReader<Box<dyn HttpStream>>,
     #[builder(def = 200u16)]
     status: u16,
     #[builder(optional = true)]
     body: Option<Box<[u8]>>,
 }
 
+impl fmt::Debug for HttpRequest {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("HttpRequest")
+            .field("method", &self.method)
+            .field("url", &self.url)
+            .field("headers", &self.headers)
+            .field("params", &self.params)
+            .field("response_headers", &self.response_headers)
+            .field("version", &self.version)
+            .field("status", &self.status)
+            .field("body", &self.body)
+            .finish()
+    }
+}
+
 impl HttpRequest {
     /// Read and parse an HTTP request from the given [`HttpStream`]
-    pub fn parse(stream: impl Into<HttpStream>) -> Result<Self> {
-        let stream = BufReader::new(stream.into());
-        parse_request(stream)
+    pub fn parse<S: IntoHttpStream>(stream: S) -> Result<Self> {
+        let stream: Box<dyn HttpStream> = Box::new(stream.into_http_stream());
+        parse_request(BufReader::new(stream))
     }
+
     #[inline]
     pub fn keep_alive(self) -> Result<Self> {
         let mut req = parse_request(self.stream)?;
         req.set_header("Connection", "keep-alive");
         Ok(req)
     }
+
+    #[inline]
+    pub fn stream(&self) -> &BufReader<Box<dyn HttpStream>> {
+        &self.stream
+    }
+
     #[inline]
-    #[must_use]
-    pub fn stream(&self) -> &HttpStream {
-        self.stream.get_ref()
+    pub fn stream_mut(&mut self) -> &mut BufReader<Box<dyn HttpStream>> {
+        &mut self.stream
     }
+
     /// Url of the request
     #[inline]
-    #[must_use]
     pub fn url(&self) -> &str {
         &self.url
     }
@@ -120,7 +146,8 @@ impl HttpRequest {
     ///
     /// # Errors
     /// If the transfer fails, returns the error
-    pub fn send_to(&self, mut stream: HttpStream) -> crate::Result<HttpResponse> {
+    pub fn send_to<Out: IntoHttpStream>(&self, stream: Out) -> crate::Result<HttpResponse> {
+        let mut stream = stream.into_http_stream();
         self.write_to(&mut stream)?;
         stream.flush()?;
         HttpResponse::parse(stream)
@@ -230,8 +257,8 @@ impl HttpRequest {
     /// [`stream`]'s availability
     ///
     /// [`stream`]: HttpStream
-    pub fn has_body(&self) -> Result<bool> {
-        Ok(self.body.is_some() || self.stream.get_ref().is_ready()?)
+    pub fn has_body(&mut self) -> Result<bool> {
+        Ok(self.body.is_some() || !self.stream.fill_buf()?.is_empty())
     }
 
     /// Reads the request body into [writer](Write)

crates/http/src/request/parse.rs

@@ -5,7 +5,7 @@ use std::{
 
 use crate::{HttpStream, Result, err, request::HttpRequest};
 
-pub(super) fn parse_request(mut stream: BufReader<HttpStream>) -> Result<HttpRequest> {
+pub(super) fn parse_request(mut stream: BufReader<Box<dyn HttpStream>>) -> Result<HttpRequest> {
     let mut line = String::new();
     /* Parse request line */
     stream.read_line(&mut line)?;

crates/http/src/response/mod.rs

@@ -1,23 +1,27 @@
+use core::fmt;
 use std::{
     collections::HashMap,
-    io::{self, BufReader, Read, Write},
+    io::{self, BufRead, BufReader, Read, Write},
 };
 
 use builders::Builder;
 use parse::parse_response;
 
-use crate::{HttpStream, Result};
+use crate::{
+    HttpStream, Result,
+    stream::{self, IntoHttpStream},
+};
 
 mod parse;
 
 /// An Http response
-#[derive(Builder, Debug)]
+#[derive(Builder)]
 pub struct HttpResponse {
     #[builder(map = "header")]
     headers: HashMap<String, String>,
     #[builder(disabled = true)]
-    #[builder(def = { BufReader::new(HttpStream::dummy()) })]
-    stream: BufReader<HttpStream>,
+    #[builder(def = { BufReader::new(stream::dummy())} )]
+    stream: BufReader<Box<dyn HttpStream>>,
     #[builder(def = 200u16)]
     status: u16,
     #[builder(optional = true)]
@@ -26,10 +30,21 @@ pub struct HttpResponse {
     version: f32,
 }
 
+impl fmt::Debug for HttpResponse {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("HttpResponse")
+            .field("headers", &self.headers)
+            .field("status", &self.status)
+            .field("body", &self.body)
+            .field("version", &self.version)
+            .finish()
+    }
+}
+
 impl HttpResponse {
-    pub fn parse(stream: impl Into<HttpStream>) -> crate::Result<Self> {
-        let stream = BufReader::new(stream.into());
-        parse_response(stream)
+    pub fn parse<S: IntoHttpStream>(stream: S) -> crate::Result<Self> {
+        let stream: Box<dyn HttpStream> = Box::new(stream.into_http_stream());
+        parse_response(BufReader::new(stream))
     }
     #[inline]
     #[must_use]
@@ -115,8 +130,8 @@ impl HttpResponse {
     /// [`stream`]'s availability
     ///
     /// [`stream`]: HttpStream
-    pub fn has_body(&self) -> Result<bool> {
-        Ok(self.stream.get_ref().is_ready()?)
+    pub fn has_body(&mut self) -> Result<bool> {
+        Ok(self.body.is_some() || !self.stream.fill_buf()?.is_empty())
     }
 
     /// Reads the response's body into [writer](Write)

crates/http/src/response/parse.rs

@@ -6,7 +6,9 @@ use std::{
 use super::HttpResponse;
 use crate::{HttpStream, err};
 
-pub(super) fn parse_response(mut stream: BufReader<HttpStream>) -> crate::Result<HttpResponse> {
+pub(super) fn parse_response(
+    mut stream: BufReader<Box<dyn HttpStream>>,
+) -> crate::Result<HttpResponse> {
     let mut line = String::new();
     /* Parse request line */
     stream.read_line(&mut line)?;