wreq-rb 0.6.0 → 0.6.1

data/vendor/wreq/src/client/layer/timeout/body.rs

@@ -57,33 +57,33 @@ pin_project! {
     /// The timeout resets after every successful read. If a single read
     /// takes longer than the specified duration, an error is returned.
     pub struct ReadTimeoutBody<B> {
-        timeout: Duration,
-        #[pin]
-        sleep: Option<Pin<Box<dyn Sleep>>>,
         #[pin]
         body: B,
+        #[pin]
+        sleep: Option<Pin<Box<dyn Sleep>>>,
+        timeout: Duration,
         timer: Timer,
     }
 }
 
-/// ==== impl TimeoutBody ====
+// ===== impl TimeoutBody =====
+
 impl<B> TimeoutBody<B> {
-    /// Creates a new [`TimeoutBody`] with no timeout.
+    /// Wraps a body with the active total timeout and an optional read timeout.
     pub fn new(
+        body: B,
         timer: Timer,
-        deadline: Option<Duration>,
         read_timeout: Option<Duration>,
-        body: B,
+        total_timeout: Option<Pin<Box<dyn Sleep>>>,
     ) -> Self {
-        let deadline = deadline.map(|deadline| timer.sleep(deadline));
-        match (deadline, read_timeout) {
+        match (total_timeout, read_timeout) {
             (Some(total_timeout), Some(read_timeout)) => TimeoutBody::CombinedTimeout {
                 body: TotalTimeoutBody {
                     timeout: total_timeout,
                     body: ReadTimeoutBody {
-                        timeout: read_timeout,
-                        sleep: None,
                         body,
+                        sleep: None,
+                        timeout: read_timeout,
                         timer,
                     },
                 },
@@ -160,7 +160,8 @@ where
     )
 }
 
-// ==== impl TotalTimeoutBody ====
+// ===== impl TotalTimeoutBody =====
+
 impl<B> Body for TotalTimeoutBody<B>
 where
     B: Body,
@@ -191,7 +192,8 @@ where
     }
 }
 
-/// ==== impl ReadTimeoutBody ====
+// ===== impl ReadTimeoutBody =====
+
 impl<B> Body for ReadTimeoutBody<B>
 where
     B: Body,
@@ -206,23 +208,27 @@ where
     ) -> Poll<Option<Result<http_body::Frame<Self::Data>, Self::Error>>> {
         let mut this = self.project();
 
-        // Error if the timeout has expired.
+        // Start the timeout on the first poll.
         if this.sleep.is_none() {
-            this.sleep.set(Some(this.timer.sleep(*this.timeout)));
+            let deadline = this.timer.now() + *this.timeout;
+            this.sleep.set(Some(this.timer.sleep_until(deadline)));
         }
 
         // Error if the timeout has expired.
-        if let Some(sleep) = this.sleep.as_mut().as_pin_mut() {
-            if sleep.poll(cx).is_ready() {
-                return Poll::Ready(Some(Err(Box::new(TimedOut))));
-            }
+        if let Some(sleep) = this.sleep.as_mut().as_pin_mut()
+            && sleep.poll(cx).is_ready()
+        {
+            return Poll::Ready(Some(Err(Error::body(TimedOut).into())));
         }
 
         // Poll the actual body
         match ready!(this.body.poll_frame(cx)) {
             Some(Ok(frame)) => {
-                // Reset timeout on successful read
-                this.sleep.set(None);
+                // Reuse the sleep to avoid allocating and registering a new timer for every frame.
+                if let Some(sleep) = this.sleep.as_mut().as_pin_mut() {
+                    let deadline = this.timer.now() + *this.timeout;
+                    this.timer.reset(sleep.get_mut(), deadline);
+                }
                 Poll::Ready(Some(Ok(frame)))
             }
             Some(Err(err)) => Poll::Ready(Some(Err(err.into()))),

data/vendor/wreq/src/client/layer/timeout/future.rs

@@ -16,80 +16,55 @@ use crate::{
 };
 
 pin_project! {
-    /// [`Timeout`] response future
+    /// Waits for response headers, then moves the total timeout into the response body.
     pub struct ResponseFuture<Fut> {
         #[pin]
-        pub(crate) fut: Fut,
-        pub(crate) total_timeout: Option<Pin<Box<dyn Sleep>>>,
-        pub(crate) read_timeout: Option<Pin<Box<dyn Sleep>>>,
+        pub(super) fut: Fut,
+        pub(super) timer: Timer,
+        pub(super) read_timeout: Option<Duration>,
+        pub(super) read_timeout_fut: Option<Pin<Box<dyn Sleep>>>,
+        pub(super) total_timeout_fut: Option<Pin<Box<dyn Sleep>>>,
     }
 }
 
-impl<F, T, E> Future for ResponseFuture<F>
+impl<Fut, ResBody, E> Future for ResponseFuture<Fut>
 where
-    F: Future<Output = Result<T, E>>,
+    Fut: Future<Output = Result<Response<ResBody>, E>>,
     E: Into<BoxError>,
 {
-    type Output = Result<T, BoxError>;
+    type Output = Result<Response<TimeoutBody<ResBody>>, BoxError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
 
-        // First, try polling the future
-        match this.fut.poll(cx) {
-            Poll::Ready(v) => return Poll::Ready(v.map_err(Into::into)),
-            Poll::Pending => {}
-        }
-
-        // Helper closure for polling a timeout and returning a TimedOut error
-        let mut check_timeout = |sleep: Option<&mut Pin<Box<dyn Sleep>>>| {
-            if let Some(sleep) = sleep {
-                if sleep.as_mut().poll(cx).is_ready() {
-                    return Some(Poll::Ready(Err(Error::request(TimedOut).into())));
-                }
-            }
-            None
-        };
-
-        // Check total timeout first
-        if let Some(poll) = check_timeout(this.total_timeout.as_mut()) {
-            return poll;
+        // The total timer covers response headers and body. Poll it first so an
+        // expired timeout wins, then move it into `TimeoutBody` below.
+        if let Some(timeout) = this.total_timeout_fut.as_mut()
+            && timeout.as_mut().poll(cx).is_ready()
+        {
+            return Poll::Ready(Err(Error::request(TimedOut).into()));
         }
 
-        // Check read timeout
-        if let Some(poll) = check_timeout(this.read_timeout.as_mut()) {
-            return poll;
+        // Before headers arrive, the read timer limits that wait. The body starts
+        // and resets its own read timer after each successful frame.
+        if let Some(timeout) = this.read_timeout_fut.as_mut()
+            && timeout.as_mut().poll(cx).is_ready()
+        {
+            return Poll::Ready(Err(Error::request(TimedOut).into()));
         }
 
-        Poll::Pending
-    }
-}
+        // Poll the request after both timers so every pending future registers the
+        // current waker before `ready!` returns.
+        let response = ready!(this.fut.poll(cx)).map_err(Into::into)?;
 
-pin_project! {
-    /// Response future for wrapping the response body in [`TimeoutBody`].
-    pub struct ResponseBodyTimeoutFuture<Fut> {
-        #[pin]
-        pub(super) fut: Fut,
-        pub(super) timer: Timer,
-        pub(super) total_timeout: Option<Duration>,
-        pub(super) read_timeout: Option<Duration>,
-
-    }
-}
-
-impl<Fut, ResBody, E> Future for ResponseBodyTimeoutFuture<Fut>
-where
-    Fut: Future<Output = Result<Response<ResBody>, E>>,
-{
-    type Output = Result<Response<TimeoutBody<ResBody>>, E>;
-
-    #[inline(always)]
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let timer = self.timer.clone();
-        let total_timeout = self.total_timeout;
-        let read_timeout = self.read_timeout;
-        let res = ready!(self.project().fut.poll(cx))?
-            .map(|body| TimeoutBody::new(timer, total_timeout, read_timeout, body));
-        Poll::Ready(Ok(res))
+        // Moving the running total timer preserves the original deadline.
+        Poll::Ready(Ok(response.map(|body| {
+            TimeoutBody::new(
+                body,
+                this.timer.clone(),
+                *this.read_timeout,
+                this.total_timeout_fut.take(),
+            )
+        })))
     }
 }

data/vendor/wreq/src/client/layer/timeout.rs

@@ -12,17 +12,14 @@ use http::{Request, Response};
 use tower::{BoxError, Layer, Service};
 use wreq_proto::rt::Timer as _;
 
-use self::{
-    body::TimeoutBody,
-    future::{ResponseBodyTimeoutFuture, ResponseFuture},
-};
+use self::{body::TimeoutBody, future::ResponseFuture};
 use crate::{config::RequestConfig, rt::Timer};
 
 /// Options for configuring timeouts.
 #[derive(Clone, Copy, Default)]
 pub struct TimeoutOptions {
-    total_timeout: Option<Duration>,
     read_timeout: Option<Duration>,
+    total_timeout: Option<Duration>,
 }
 
 impl TimeoutOptions {
@@ -88,7 +85,7 @@ where
 {
     type Response = Response<TimeoutBody<ResBody>>;
     type Error = BoxError;
-    type Future = ResponseFuture<ResponseBodyTimeoutFuture<S::Future>>;
+    type Future = ResponseFuture<S::Future>;
 
     #[inline(always)]
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
@@ -99,14 +96,11 @@ where
     fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
         let (total_timeout, read_timeout) = fetch_timeout_options(&self.timeout, req.extensions());
         ResponseFuture {
-            fut: ResponseBodyTimeoutFuture {
-                fut: self.inner.call(req),
-                timer: self.timer.clone(),
-                total_timeout,
-                read_timeout,
-            },
-            total_timeout: total_timeout.map(|timeout| self.timer.sleep(timeout)),
-            read_timeout: read_timeout.map(|timeout| self.timer.sleep(timeout)),
+            fut: self.inner.call(req),
+            timer: self.timer.clone(),
+            read_timeout,
+            read_timeout_fut: read_timeout.map(|timeout| self.timer.sleep(timeout)),
+            total_timeout_fut: total_timeout.map(|timeout| self.timer.sleep(timeout)),
         }
     }
 }

data/vendor/wreq/src/client/request.rs

@@ -473,6 +473,10 @@ impl RequestBuilder {
 
     /// Send a JSON body.
     ///
+    /// Serializes the value as JSON and sets the resulting bytes as the request body.
+    ///
+    /// Sets `Content-Type` to `application/json` unless it is already set.
+    ///
     /// # Optional
     ///
     /// This requires the optional `json` feature enabled.

data/vendor/wreq/src/client.rs

@@ -60,8 +60,10 @@ use crate::dns::hickory::HickoryDnsResolver;
 use crate::{
     IntoUri, Method, Proxy,
     conn::{
-        BoxedConnectorLayer, BoxedConnectorService, Conn, Unnameable, connector::Connector,
-        http::HttpConnect, net::SocketBindOptions,
+        BoxedConnectorLayer, BoxedTransportConnector, Conn, Unnameable,
+        connector::{Connector, ConnectorBuilder},
+        http::HttpConnect,
+        net::SocketBindOptions,
     },
     dns::{DnsResolverWithOverrides, DynResolver, GaiResolver, IntoResolve, Resolve},
     error::{self, Error},
@@ -114,9 +116,7 @@ type MaybeDecompressionBody<T> = tower_http::decompression::DecompressionBody<T>
 
 type ClientService = Timeout<
     ConfigService<
-        MaybeDecompression<
-            Retry<RetryPolicy, FollowRedirect<HttpClient<Connector, Body>, FollowRedirectPolicy>>,
-        >,
+        MaybeDecompression<Retry<RetryPolicy, FollowRedirect<HttpClient<Connector, Body>>>>,
     >,
 >;
 
@@ -185,6 +185,7 @@ struct Config {
     pool_max_size: Option<NonZeroUsize>,
     tcp_nodelay: bool,
     tcp_reuse_address: bool,
+    tcp_linger: Option<Duration>,
     tcp_keepalive: Option<Duration>,
     tcp_keepalive_interval: Option<Duration>,
     tcp_keepalive_retries: Option<u32>,
@@ -276,6 +277,7 @@ impl Client {
                 tcp_user_timeout: Some(Duration::from_secs(30)),
                 tcp_nodelay: true,
                 tcp_reuse_address: false,
+                tcp_linger: None,
                 tcp_send_buffer_size: None,
                 tcp_recv_buffer_size: None,
                 tcp_happy_eyeballs_timeout: Some(Duration::from_millis(300)),
@@ -502,7 +504,8 @@ impl ClientBuilder {
                 DynResolver::new(resolver)
             };
 
-            let connector = Connector::builder(config.proxies, resolver)
+            let connector = ConnectorBuilder::new(config.proxies, resolver)
+                .timer(config.timer.clone())
                 .timeout(config.connect_timeout)
                 .tls_info(config.tls_info)
                 .tcp_nodelay(config.tcp_nodelay)
@@ -529,6 +532,7 @@ impl ClientBuilder {
                     http.set_keepalive_interval(config.tcp_keepalive_interval);
                     http.set_keepalive_retries(config.tcp_keepalive_retries);
                     http.set_reuse_address(config.tcp_reuse_address);
+                    http.set_linger(config.tcp_linger);
                     http.set_connect_timeout(config.connect_timeout);
                     http.set_nodelay(config.tcp_nodelay);
                     http.set_send_buffer_size(config.tcp_send_buffer_size);
@@ -788,9 +792,8 @@ impl ClientBuilder {
     ///
     /// If auto gzip decompression is turned on:
     ///
-    /// - When sending a request and if the request's headers do not already contain an
-    ///   `Accept-Encoding` **and** `Range` values, the `Accept-Encoding` header is set to `gzip`.
-    ///   The request body is **not** automatically compressed.
+    /// - Requests without `Accept-Encoding` advertise `gzip`. Range requests use `Accept-Encoding:
+    ///   identity` instead. The request body is **not** automatically compressed.
     /// - When receiving a response, if its headers contain a `Content-Encoding` value of `gzip`,
     ///   both `Content-Encoding` and `Content-Length` are removed from the headers' set. The
     ///   response body is automatically decompressed.
@@ -812,9 +815,8 @@ impl ClientBuilder {
     ///
     /// If auto brotli decompression is turned on:
     ///
-    /// - When sending a request and if the request's headers do not already contain an
-    ///   `Accept-Encoding` **and** `Range` values, the `Accept-Encoding` header is set to `br`. The
-    ///   request body is **not** automatically compressed.
+    /// - Requests without `Accept-Encoding` advertise `br`. Range requests use `Accept-Encoding:
+    ///   identity` instead. The request body is **not** automatically compressed.
     /// - When receiving a response, if its headers contain a `Content-Encoding` value of `br`, both
     ///   `Content-Encoding` and `Content-Length` are removed from the headers' set. The response
     ///   body is automatically decompressed.
@@ -836,9 +838,8 @@ impl ClientBuilder {
     ///
     /// If auto zstd decompression is turned on:
     ///
-    /// - When sending a request and if the request's headers do not already contain an
-    ///   `Accept-Encoding` **and** `Range` values, the `Accept-Encoding` header is set to `zstd`.
-    ///   The request body is **not** automatically compressed.
+    /// - Requests without `Accept-Encoding` advertise `zstd`. Range requests use `Accept-Encoding:
+    ///   identity` instead. The request body is **not** automatically compressed.
     /// - When receiving a response, if its headers contain a `Content-Encoding` value of `zstd`,
     ///   both `Content-Encoding` and `Content-Length` are removed from the headers' set. The
     ///   response body is automatically decompressed.
@@ -860,9 +861,8 @@ impl ClientBuilder {
     ///
     /// If auto deflate decompression is turned on:
     ///
-    /// - When sending a request and if the request's headers do not already contain an
-    ///   `Accept-Encoding` **and** `Range` values, the `Accept-Encoding` header is set to
-    ///   `deflate`. The request body is **not** automatically compressed.
+    /// - Requests without `Accept-Encoding` advertise `deflate`. Range requests use
+    ///   `Accept-Encoding: identity` instead. The request body is **not** automatically compressed.
     /// - When receiving a response, if it's headers contain a `Content-Encoding` value that equals
     ///   to `deflate`, both values `Content-Encoding` and `Content-Length` are removed from the
     ///   headers' set. The response body is automatically decompressed.
@@ -963,7 +963,11 @@ impl ClientBuilder {
         self
     }
 
-    /// Enable or disable automatic setting of the `Referer` header.
+    /// Enable or disable automatic `Referer` management during redirects.
+    ///
+    /// When enabled, redirect responses can control how an existing `Referer`
+    /// is forwarded through `Referrer-Policy`. No header is added when the
+    /// request has none.
     ///
     /// Default is `true`.
     #[inline]
@@ -1041,12 +1045,10 @@ impl ClientBuilder {
 
     /// Set a timeout for only the connect phase of a `Client`.
     ///
-    /// Default is `None`.
-    ///
-    /// # Note
+    /// The timeout covers DNS resolution, the complete TCP address race,
+    /// proxy tunneling, and the TLS handshake.
     ///
-    /// This **requires** the futures be executed in a tokio runtime with
-    /// a tokio timer enabled.
+    /// Default is `None`.
     #[inline]
     pub fn connect_timeout(mut self, timeout: Duration) -> ClientBuilder {
         self.config.connect_timeout = Some(timeout);
@@ -1220,6 +1222,27 @@ impl ClientBuilder {
         self
     }
 
+    /// Set that all sockets have `SO_LINGER` set with the supplied duration.
+    ///
+    /// This option controls how long the socket lingers on close while data
+    /// remains unsent. A duration of zero aborts the connection on close: unsent
+    /// data is discarded, the connection is reset (`RST`) rather than going
+    /// through the normal `FIN` termination sequence, and the socket does not
+    /// enter `TIME_WAIT`.
+    ///
+    /// If `None`, the option will not be set and the operating system default
+    /// applies.
+    ///
+    /// Default is `None`.
+    #[inline]
+    pub fn tcp_linger<D>(mut self, val: D) -> ClientBuilder
+    where
+        D: Into<Option<Duration>>,
+    {
+        self.config.tcp_linger = val.into();
+        self
+    }
+
     /// Sets the size of the TCP send buffer on this client socket.
     ///
     /// On most operating systems, this sets the `SO_SNDBUF` socket option.
@@ -1244,18 +1267,17 @@ impl ClientBuilder {
         self
     }
 
-    /// Set timeout for [RFC 6555 (Happy Eyeballs)][RFC 6555] algorithm.
+    /// Set the delay between connection attempts for
+    /// [RFC 8305 (Happy Eyeballs v2)][RFC 8305].
     ///
-    /// If hostname resolves to both IPv4 and IPv6 addresses and connection
-    /// cannot be established using preferred address family before timeout
-    /// elapses, then connector will in parallel attempt connection using other
-    /// address family.
+    /// The first address is attempted immediately. Later addresses are started
+    /// after this delay without waiting for the previous attempt to finish.
     ///
     /// If `None`, parallel connection attempts are disabled.
     ///
     /// Default is 300 milliseconds.
     ///
-    /// [RFC 6555]: https://tools.ietf.org/html/rfc6555
+    /// [RFC 8305]: https://www.rfc-editor.org/rfc/rfc8305.html#section-5
     #[inline]
     pub fn tcp_happy_eyeballs_timeout<D>(mut self, val: D) -> ClientBuilder
     where
@@ -1631,7 +1653,7 @@ impl ClientBuilder {
     #[inline]
     pub fn connector_layer<L>(mut self, layer: L) -> ClientBuilder
     where
-        L: Layer<BoxedConnectorService> + Clone + Send + Sync + 'static,
+        L: Layer<BoxedTransportConnector> + Clone + Send + Sync + 'static,
         L::Service:
             Service<Unnameable, Response = Conn, Error = BoxError> + Clone + Send + Sync + 'static,
         <L::Service as Service<Unnameable>>::Future: Send + 'static,