chore(pool): Use Mutex types that do not poison themselves

Cargo.toml

@@ -75,6 +75,7 @@ tower-service = "0.3"
 futures-core = { version = "0.3.0", default-features = false }
 futures-util = { version = "0.3.0", default-features = false }
 sync_wrapper = { version = "1.0", features = ["futures"] }
+antidote = { version = "1" }
 
 # Optional deps...
 
@@ -112,7 +113,6 @@ typed-builder = { version = "0.20.0" }
 # boring-tls session cache
 linked_hash_set = { version = "0.1" }
 tower-layer = { version = "0.3" }
-antidote = { version = "1" }
 
 # cert compression
 brotli = { version = "7" }
@@ -129,7 +129,7 @@ cookie_store = { version = "0.21", optional = true }
 
 ## compression
 async-compression = { version = "0.4.0", default-features = false, features = ["tokio"], optional = true }
-tokio-util = { version = "0.7.9", default-features = false, features = ["codec", "io"], optional = true }
+tokio-util = { version = "0.7.0", default-features = false, features = ["codec", "io"], optional = true }
 
 ## socks
 tokio-socks = { version = "0.5.2", optional = true }

src/client/body.rs

@@ -66,7 +66,7 @@ impl Body {
     /// # Example
     ///
     /// ```
-    /// # use reqwest::Body;
+    /// # use rquest::Body;
     /// # use futures_util;
     /// # fn main() {
     /// let chunks: Vec<Result<_, ::std::io::Error>> = vec![
@@ -131,7 +131,7 @@ impl Body {
     /// # Example
     ///
     /// ```
-    /// # use reqwest::Body;
+    /// # use rquest::Body;
     /// # use futures_util;
     /// # fn main() {
     /// let content = "hello,world!".to_string();

src/client/decoder.rs

@@ -63,21 +63,6 @@ pub(super) struct Accepts {
     pub(super) deflate: bool,
 }
 
-impl Accepts {
-    pub fn none() -> Self {
-        Self {
-            #[cfg(feature = "gzip")]
-            gzip: false,
-            #[cfg(feature = "brotli")]
-            brotli: false,
-            #[cfg(feature = "zstd")]
-            zstd: false,
-            #[cfg(feature = "deflate")]
-            deflate: false,
-        }
-    }
-}
-
 /// A response decompressor over a non-blocking stream of chunks.
 ///
 /// The inner decoder may be constructed asynchronously.

src/client/http.rs

@@ -877,7 +877,7 @@ impl ClientBuilder {
     ///
     /// ```
     /// let interface = "lo";
-    /// let client = reqwest::Client::builder()
+    /// let client = rquest::Client::builder()
     ///     .interface(interface)
     ///     .build().unwrap();
     /// ```

src/client/response.rs

@@ -4,7 +4,6 @@ use std::pin::Pin;
 use std::time::Duration;
 
 use bytes::Bytes;
-use http_body_util::BodyExt;
 use hyper2::{HeaderMap, StatusCode, Version};
 #[cfg(feature = "json")]
 use serde::de::DeserializeOwned;
@@ -150,7 +149,7 @@ impl Response {
     ///
     /// ```
     /// # async fn run() -> Result<(), Box<dyn std::error::Error>> {
-    /// let content = reqwest::get("http://httpbin.org/range/26")
+    /// let content = rquest::get("http://httpbin.org/range/26")
     ///     .await?
     ///     .text()
     ///     .await?;
@@ -193,7 +192,7 @@ impl Response {
     ///
     /// ```
     /// # async fn run() -> Result<(), Box<dyn std::error::Error>> {
-    /// let content = reqwest::get("http://httpbin.org/range/26")
+    /// let content = rquest::get("http://httpbin.org/range/26")
     ///     .await?
     ///     .text_with_charset("utf-8")
     ///     .await?;
@@ -231,10 +230,10 @@ impl Response {
     /// # Examples
     ///
     /// ```
-    /// # extern crate reqwest;
+    /// # extern crate rquest;
     /// # extern crate serde;
     /// #
-    /// # use reqwest::Error;
+    /// # use rquest::Error;
     /// # use serde::Deserialize;
     /// #
     /// // This `derive` requires the `serde` dependency.
@@ -244,7 +243,7 @@ impl Response {
     /// }
     ///
     /// # async fn run() -> Result<(), Error> {
-    /// let ip = reqwest::get("http://httpbin.org/ip")
+    /// let ip = rquest::get("http://httpbin.org/ip")
     ///     .await?
     ///     .json::<Ip>()
     ///     .await?;
@@ -277,7 +276,7 @@ impl Response {
     ///
     /// ```
     /// # async fn run() -> Result<(), Box<dyn std::error::Error>> {
-    /// let bytes = reqwest::get("http://httpbin.org/ip")
+    /// let bytes = rquest::get("http://httpbin.org/ip")
     ///     .await?
     ///     .bytes()
     ///     .await?;
@@ -302,7 +301,7 @@ impl Response {
     ///
     /// ```
     /// # async fn run() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut res = reqwest::get("https://hyper.rs").await?;
+    /// let mut res = rquest::get("https://hyper.rs").await?;
     ///
     /// while let Some(chunk) = res.chunk().await? {
     ///     println!("Chunk: {chunk:?}");
@@ -335,7 +334,7 @@ impl Response {
     /// use futures_util::StreamExt;
     ///
     /// # async fn run() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut stream = reqwest::get("http://httpbin.org/ip")
+    /// let mut stream = rquest::get("http://httpbin.org/ip")
     ///     .await?
     ///     .bytes_stream();
     ///
@@ -362,7 +361,7 @@ impl Response {
     /// # Example
     ///
     /// ```
-    /// # use reqwest::Response;
+    /// # use rquest::Response;
     /// fn on_response(res: Response) {
     ///     match res.error_for_status() {
     ///         Ok(_res) => (),
@@ -371,7 +370,7 @@ impl Response {
     ///             // it could be any status between 400...599
     ///             assert_eq!(
     ///                 err.status(),
-    ///                 Some(reqwest::StatusCode::BAD_REQUEST)
+    ///                 Some(rquest::StatusCode::BAD_REQUEST)
     ///             );
     ///         }
     ///     }
@@ -392,7 +391,7 @@ impl Response {
     /// # Example
     ///
     /// ```
-    /// # use reqwest::Response;
+    /// # use rquest::Response;
     /// fn on_response(res: &Response) {
     ///     match res.error_for_status_ref() {
     ///         Ok(_res) => (),
@@ -401,7 +400,7 @@ impl Response {
     ///             // it could be any status between 400...599
     ///             assert_eq!(
     ///                 err.status(),
-    ///                 Some(reqwest::StatusCode::BAD_REQUEST)
+    ///                 Some(rquest::StatusCode::BAD_REQUEST)
     ///             );
     ///         }
     ///     }
@@ -434,61 +433,3 @@ impl From<Response> for Body {
         Body::wrap(r.res.into_body())
     }
 }
-
-// I'm not sure this conversion is that useful... People should be encouraged
-// to use `http::Response`, not `reqwest::Response`.
-impl<T: Into<Body>> From<http::Response<T>> for Response {
-    fn from(r: http::Response<T>) -> Response {
-        use crate::response::ResponseUrl;
-
-        let (mut parts, body) = r.into_parts();
-        let body: super::body::Body = body.into();
-        let decoder = Decoder::detect(
-            &mut parts.headers,
-            ResponseBody::new(body.map_err(Into::into)),
-            Accepts::none(),
-        );
-        let url = parts
-            .extensions
-            .remove::<ResponseUrl>()
-            .unwrap_or_else(|| ResponseUrl(Url::parse("http://no.url.provided.local").unwrap()));
-        let url = url.0;
-        let res = hyper2::Response::from_parts(parts, decoder);
-        Response {
-            res,
-            url: Box::new(url),
-        }
-    }
-}
-
-/// A `Response` can be converted into a `http::Response`.
-// It's supposed to be the inverse of the conversion above.
-impl From<Response> for http::Response<Body> {
-    fn from(r: Response) -> http::Response<Body> {
-        let (parts, body) = r.res.into_parts();
-        let body = Body::wrap(body);
-        http::Response::from_parts(parts, body)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Response;
-    use crate::ResponseBuilderExt;
-    use http::response::Builder;
-    use url::Url;
-
-    #[test]
-    fn test_from_http_response() {
-        let url = Url::parse("http://example.com").unwrap();
-        let response = Builder::new()
-            .status(200)
-            .url(url.clone())
-            .body("foo")
-            .unwrap();
-        let response = Response::from(response);
-
-        assert_eq!(response.status(), 200);
-        assert_eq!(*response.url(), url);
-    }
-}

src/connect.rs

@@ -17,6 +17,7 @@ use std::borrow::Cow;
 use std::future::Future;
 use std::io::{self, IoSlice};
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+use std::ops::Deref;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{Context, Poll};
@@ -271,7 +272,7 @@ impl Connector {
         }
 
         let mut http = tls.create_connector(http, dst.version());
-        let io = http.call(dst.uri().clone()).await?;
+        let io = http.call(dst.deref().clone()).await?;
 
         if let MaybeHttpsStream::Https(stream) = io {
             if !self.nodelay {
@@ -297,7 +298,7 @@ impl Connector {
         mut dst: ConnectRequest,
         proxy_scheme: ProxyScheme,
     ) -> Result<Conn, BoxError> {
-        log::debug!("proxy({:?}) intercepts '{:?}'", proxy_scheme, dst.uri());
+        log::debug!("proxy({:?}) intercepts '{:?}'", proxy_scheme, dst);
 
         let (proxy_dst, auth) = match proxy_scheme {
             ProxyScheme::Http { host, auth } => (into_uri(Scheme::HTTP, host)?, auth),
@@ -373,11 +374,10 @@ impl Service<ConnectRequest> for Connector {
     }
 
     fn call(&mut self, dst: ConnectRequest) -> Self::Future {
-        let uri = dst.uri();
-        log::debug!("starting new connection: {:?}", uri);
+        log::debug!("starting new connection: {:?}", dst);
         let timeout = self.timeout;
         for prox in self.proxies.iter() {
-            if let Some(proxy_scheme) = prox.intercept(uri) {
+            if let Some(proxy_scheme) = prox.intercept(dst.deref()) {
                 return Box::pin(with_timeout(
                     self.clone().connect_via_proxy(dst, proxy_scheme),
                     timeout,

src/dns/resolve.rs

@@ -17,7 +17,7 @@ pub type Addrs = Box<dyn Iterator<Item = SocketAddr> + Send>;
 /// Alias for the `Future` type returned by a DNS resolver.
 pub type Resolving = Pin<Box<dyn Future<Output = Result<Addrs, BoxError>> + Send>>;
 
-/// Trait for customizing DNS resolution in reqwest.
+/// Trait for customizing DNS resolution in rquest.
 pub trait Resolve: Send + Sync {
     /// Performs DNS resolution on a `Name`.
     /// The return type is a future containing an iterator of `SocketAddr`.

src/lib.rs

@@ -259,11 +259,9 @@ pub use url::Url;
 #[macro_use]
 mod error;
 mod into_url;
-mod response;
 
 pub use self::error::{Error, Result};
 pub use self::into_url::IntoUrl;
-pub use self::response::ResponseBuilderExt;
 
 /// Shortcut method to quickly make a `GET` request.
 ///