wreq-rb 0.5.0 → 0.5.1

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

@@ -1,21 +1,36 @@
-mod options;
-
 use std::{
     sync::Arc,
     task::{Context, Poll},
 };
 
 use futures_util::future::{self, Either, Ready};
-use http::{HeaderMap, Request, Response};
+use http::{HeaderMap, Request, Response, Version};
 use tower::{Layer, Service};
+use wreq_proto::{http1::Http1Options, http2::Http2Options};
 
-pub use self::options::{RequestOptions, TransportOptions};
-use crate::{Error, config::RequestConfig, ext::UriExt, header::OrigHeaderMap};
+use crate::{
+    Error, config::RequestConfig, conn::net::SocketBindOptions, ext::UriExt, group::Group,
+    header::OrigHeaderMap, proxy::Matcher, tls::TlsOptions,
+};
 
 /// A marker type for the default headers configuration value.
 #[derive(Clone, Copy)]
 pub(crate) struct DefaultHeaders;
 
+/// Per-request configuration for proxy, protocol, and transport options.
+/// Overrides client defaults for a single request.
+#[derive(Debug, Default, Clone)]
+#[non_exhaustive]
+pub(crate) struct RequestOptions {
+    pub group: Group,
+    pub proxy: Option<Matcher>,
+    pub version: Option<Version>,
+    pub tls_options: Option<TlsOptions>,
+    pub http1_options: Option<Http1Options>,
+    pub http2_options: Option<Http2Options>,
+    pub socket_bind_options: Option<SocketBindOptions>,
+}
+
 /// Configuration for the [`ConfigService`].
 struct Config {
     https_only: bool,
@@ -40,6 +55,10 @@ pub struct ConfigService<S> {
 
 impl_request_config_value!(DefaultHeaders, bool);
 
+// ===== impl RequestOptions =====
+
+impl_request_config_value!(RequestOptions);
+
 // ===== impl ConfigServiceLayer =====
 
 impl ConfigServiceLayer {
@@ -109,7 +128,9 @@ where
         }
 
         // store the original headers in request extensions
-        self.config.orig_headers.store(req.extensions_mut());
+        if let Some(orig_headers) = self.config.orig_headers.take(req.extensions_mut()) {
+            wreq_proto::ext::on_preserve_header(&mut req, orig_headers);
+        }
 
         Either::Left(self.inner.call(req))
     }

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

@@ -60,7 +60,7 @@ impl_request_config_value!(AcceptEncoding);
 impl DecompressionLayer {
     /// Creates a new [`DecompressionLayer`] with the specified [`AcceptEncoding`].
     #[inline(always)]
-    pub const fn new(accept: AcceptEncoding) -> Self {
+    pub fn new(accept: AcceptEncoding) -> Self {
         Self { accept }
     }
 }
@@ -70,8 +70,13 @@ impl<S> Layer<S> for DecompressionLayer {
 
     #[inline(always)]
     fn layer(&self, service: S) -> Self::Service {
+        let decoder = decompression::Decompression::new(service)
+            .no_br()
+            .no_deflate()
+            .no_gzip()
+            .no_zstd();
         Decompression(Some(Decompression::<S>::accept_in_place(
-            decompression::Decompression::new(service),
+            decoder,
             &self.accept,
         )))
     }
@@ -126,10 +131,10 @@ where
     }
 
     fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
-        if let Some(accept) = RequestConfig::<AcceptEncoding>::get(req.extensions()) {
+        if let Some(accept_encoding) = RequestConfig::<AcceptEncoding>::get(req.extensions()) {
             if let Some(decoder) = self.0.take() {
                 self.0
-                    .replace(Decompression::accept_in_place(decoder, accept));
+                    .replace(Decompression::accept_in_place(decoder, accept_encoding));
             }
             debug_assert!(self.0.is_some());
         }

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

@@ -13,11 +13,14 @@ use http::{
 };
 use http_body::Body;
 use pin_project_lite::pin_project;
-use tower::{Service, util::Oneshot};
+use tower::{BoxError, Service, util::Oneshot};
 use url::Url;
 
-use super::{Action, Attempt, BodyRepr, Policy};
-use crate::{Error, error::BoxError, ext::RequestUri, into_uri::IntoUriSealed};
+use super::{
+    BodyRepr,
+    policy::{Action, Attempt, Policy},
+};
+use crate::{Error, ext::RequestUri, into_uri::IntoUriSealed};
 
 /// Pending future state for handling redirects.
 pub struct Pending<ReqBody, Response> {

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

@@ -11,11 +11,10 @@ use std::{
 use futures_util::future::Either;
 use http::{Request, Response};
 use http_body::Body;
-use tower::{Layer, Service};
+use tower::{BoxError, Layer, Service};
 
 use self::future::ResponseFuture;
 pub use self::policy::{Action, Attempt, Policy};
-use crate::error::BoxError;
 
 enum BodyRepr<B> {
     Some(B),
@@ -64,7 +63,7 @@ pub struct FollowRedirectLayer<P> {
 impl<P> FollowRedirectLayer<P> {
     /// Create a new [`FollowRedirectLayer`] with the given redirection [`Policy`].
     #[inline(always)]
-    pub const fn with_policy(policy: P) -> Self {
+    pub fn with_policy(policy: P) -> Self {
         FollowRedirectLayer { policy }
     }
 }
@@ -95,7 +94,7 @@ where
 {
     /// Create a new [`FollowRedirect`] with the given redirection [`Policy`].
     #[inline(always)]
-    pub const fn with_policy(inner: S, policy: P) -> Self {
+    pub fn with_policy(inner: S, policy: P) -> Self {
         FollowRedirect { inner, policy }
     }
 }
@@ -111,7 +110,7 @@ where
     type Error = S::Error;
     type Future = ResponseFuture<S, ReqBody, P>;
 
-    #[inline]
+    #[inline(always)]
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.inner.poll_ready(cx)
     }

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

@@ -6,17 +6,20 @@ mod scope;
 use std::{error::Error as StdError, future::Ready, sync::Arc, time::Duration};
 
 use http::{Request, Response};
-use tower::retry::{
-    Policy,
-    budget::{Budget, TpsBudget},
+use tower::{
+    BoxError,
+    retry::{
+        Policy,
+        budget::{Budget, TpsBudget},
+    },
 };
+use wreq_proto::body::Incoming;
 
 pub(crate) use self::{
     classify::{Action, Classifier, ClassifyFn, ReqRep},
     scope::{ScopeFn, Scoped},
 };
-use super::super::core::body::Incoming;
-use crate::{Body, error::BoxError, retry};
+use crate::{Body, retry};
 
 /// A retry policy for HTTP requests.
 #[derive(Clone)]

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

@@ -7,11 +7,12 @@ use std::{
 
 use http_body::Body;
 use pin_project_lite::pin_project;
-use tokio::time::{Sleep, sleep};
+use wreq_proto::rt::{Sleep, Timer as _};
 
 use crate::{
     Error,
     error::{BoxError, TimedOut},
+    rt::Timer,
 };
 
 pin_project! {
@@ -46,7 +47,7 @@ pin_project! {
     pub struct TotalTimeoutBody<B> {
         #[pin]
         body: B,
-        timeout: Pin<Box<Sleep>>,
+        timeout: Pin<Box<dyn Sleep>>,
     }
 }
 
@@ -58,17 +59,23 @@ pin_project! {
     pub struct ReadTimeoutBody<B> {
         timeout: Duration,
         #[pin]
-        sleep: Option<Sleep>,
+        sleep: Option<Pin<Box<dyn Sleep>>>,
         #[pin]
         body: B,
+        timer: Timer,
     }
 }
 
 /// ==== impl TimeoutBody ====
 impl<B> TimeoutBody<B> {
     /// Creates a new [`TimeoutBody`] with no timeout.
-    pub fn new(deadline: Option<Duration>, read_timeout: Option<Duration>, body: B) -> Self {
-        let deadline = deadline.map(sleep).map(Box::pin);
+    pub fn new(
+        timer: Timer,
+        deadline: Option<Duration>,
+        read_timeout: Option<Duration>,
+        body: B,
+    ) -> Self {
+        let deadline = deadline.map(|deadline| timer.sleep(deadline));
         match (deadline, read_timeout) {
             (Some(total_timeout), Some(read_timeout)) => TimeoutBody::CombinedTimeout {
                 body: TotalTimeoutBody {
@@ -77,6 +84,7 @@ impl<B> TimeoutBody<B> {
                         timeout: read_timeout,
                         sleep: None,
                         body,
+                        timer,
                     },
                 },
             },
@@ -88,6 +96,7 @@ impl<B> TimeoutBody<B> {
                     timeout,
                     sleep: None,
                     body,
+                    timer,
                 },
             },
             (None, None) => TimeoutBody::Plain { body },
@@ -199,7 +208,7 @@ where
 
         // Error if the timeout has expired.
         if this.sleep.is_none() {
-            this.sleep.set(Some(sleep(*this.timeout)));
+            this.sleep.set(Some(this.timer.sleep(*this.timeout)));
         }
 
         // Error if the timeout has expired.

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

@@ -7,20 +7,21 @@ use std::{
 
 use http::Response;
 use pin_project_lite::pin_project;
-use tokio::time::Sleep;
+use wreq_proto::rt::Sleep;
 
 use super::body::TimeoutBody;
-use crate::error::{BoxError, Error, TimedOut};
+use crate::{
+    error::{BoxError, Error, TimedOut},
+    rt::Timer,
+};
 
 pin_project! {
     /// [`Timeout`] response future
-    pub struct ResponseFuture<F> {
-        #[pin]
-        pub(crate) response: F,
+    pub struct ResponseFuture<Fut> {
         #[pin]
-        pub(crate) total_timeout: Option<Sleep>,
-        #[pin]
-        pub(crate) read_timeout: Option<Sleep>,
+        pub(crate) fut: Fut,
+        pub(crate) total_timeout: Option<Pin<Box<dyn Sleep>>>,
+        pub(crate) read_timeout: Option<Pin<Box<dyn Sleep>>>,
     }
 }
 
@@ -32,18 +33,18 @@ where
     type Output = Result<T, BoxError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.project();
+        let this = self.project();
 
         // First, try polling the future
-        match this.response.poll(cx) {
+        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<Pin<&mut Sleep>>| {
+        let mut check_timeout = |sleep: Option<&mut Pin<Box<dyn Sleep>>>| {
             if let Some(sleep) = sleep {
-                if sleep.poll(cx).is_ready() {
+                if sleep.as_mut().poll(cx).is_ready() {
                     return Some(Poll::Ready(Err(Error::request(TimedOut).into())));
                 }
             }
@@ -51,12 +52,12 @@ where
         };
 
         // Check total timeout first
-        if let Some(poll) = check_timeout(this.total_timeout.as_mut().as_pin_mut()) {
+        if let Some(poll) = check_timeout(this.total_timeout.as_mut()) {
             return poll;
         }
 
         // Check read timeout
-        if let Some(poll) = check_timeout(this.read_timeout.as_mut().as_pin_mut()) {
+        if let Some(poll) = check_timeout(this.read_timeout.as_mut()) {
             return poll;
         }
 
@@ -65,12 +66,14 @@ where
 }
 
 pin_project! {
-    /// Response future for [`ResponseBodyTimeout`].
+    /// Response future for wrapping the response body in [`TimeoutBody`].
     pub struct ResponseBodyTimeoutFuture<Fut> {
         #[pin]
-        pub(super) inner: Fut,
+        pub(super) fut: Fut,
+        pub(super) timer: Timer,
         pub(super) total_timeout: Option<Duration>,
         pub(super) read_timeout: Option<Duration>,
+
     }
 }
 
@@ -80,11 +83,13 @@ where
 {
     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().inner.poll(cx))?
-            .map(|body| TimeoutBody::new(total_timeout, read_timeout, body));
+        let res = ready!(self.project().fut.poll(cx))?
+            .map(|body| TimeoutBody::new(timer, total_timeout, read_timeout, body));
         Poll::Ready(Ok(res))
     }
 }

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

@@ -1,6 +1,6 @@
 //! Middleware for setting a timeout on the response.
 
-mod body;
+pub mod body;
 mod future;
 
 use std::{
@@ -9,11 +9,14 @@ use std::{
 };
 
 use http::{Request, Response};
-use tower::{Layer, Service};
+use tower::{BoxError, Layer, Service};
+use wreq_proto::rt::Timer as _;
 
-pub use self::body::TimeoutBody;
-use self::future::{ResponseBodyTimeoutFuture, ResponseFuture};
-use crate::{config::RequestConfig, error::BoxError};
+use self::{
+    body::TimeoutBody,
+    future::{ResponseBodyTimeoutFuture, ResponseFuture},
+};
+use crate::{config::RequestConfig, rt::Timer};
 
 /// Options for configuring timeouts.
 #[derive(Clone, Copy, Default)]
@@ -44,14 +47,15 @@ impl_request_config_value!(TimeoutOptions);
 // This layer allows you to set a total timeout and a read timeout for requests.
 #[derive(Clone)]
 pub struct TimeoutLayer {
+    timer: Timer,
     timeout: RequestConfig<TimeoutOptions>,
 }
 
 impl TimeoutLayer {
     /// Create a new [`TimeoutLayer`].
-    #[inline(always)]
-    pub const fn new(options: TimeoutOptions) -> Self {
+    pub fn new(timer: Timer, options: TimeoutOptions) -> Self {
         TimeoutLayer {
+            timer,
             timeout: RequestConfig::new(Some(options)),
         }
     }
@@ -64,15 +68,17 @@ impl<S> Layer<S> for TimeoutLayer {
     fn layer(&self, service: S) -> Self::Service {
         Timeout {
             inner: service,
+            timer: self.timer.clone(),
             timeout: self.timeout,
         }
     }
 }
 
-/// Middleware that applies total and per-read timeouts to a [`Service`] response body.
+/// Middleware that applies request and response-body timeouts to a [`Service`].
 #[derive(Clone)]
 pub struct Timeout<T> {
     inner: T,
+    timer: Timer,
     timeout: RequestConfig<TimeoutOptions>,
 }
 
@@ -80,9 +86,9 @@ impl<ReqBody, ResBody, S> Service<Request<ReqBody>> for Timeout<S>
 where
     S: Service<Request<ReqBody>, Response = Response<ResBody>, Error = BoxError>,
 {
-    type Response = S::Response;
+    type Response = Response<TimeoutBody<ResBody>>;
     type Error = BoxError;
-    type Future = ResponseFuture<S::Future>;
+    type Future = ResponseFuture<ResponseBodyTimeoutFuture<S::Future>>;
 
     #[inline(always)]
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
@@ -93,70 +99,14 @@ where
     fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
         let (total_timeout, read_timeout) = fetch_timeout_options(&self.timeout, req.extensions());
         ResponseFuture {
-            response: self.inner.call(req),
-            total_timeout: total_timeout.map(tokio::time::sleep),
-            read_timeout: read_timeout.map(tokio::time::sleep),
-        }
-    }
-}
-
-/// [`Layer`] that applies a [`ResponseBodyTimeout`] middleware to a service.
-// This layer allows you to set a total timeout and a read timeout for the response body.
-#[derive(Clone)]
-pub struct ResponseBodyTimeoutLayer {
-    timeout: RequestConfig<TimeoutOptions>,
-}
-
-impl ResponseBodyTimeoutLayer {
-    /// Creates a new [`ResponseBodyTimeoutLayer`].
-    #[inline(always)]
-    pub const fn new(options: TimeoutOptions) -> Self {
-        Self {
-            timeout: RequestConfig::new(Some(options)),
-        }
-    }
-}
-
-impl<S> Layer<S> for ResponseBodyTimeoutLayer {
-    type Service = ResponseBodyTimeout<S>;
-
-    #[inline(always)]
-    fn layer(&self, inner: S) -> Self::Service {
-        ResponseBodyTimeout {
-            inner,
-            timeout: self.timeout,
-        }
-    }
-}
-
-/// Middleware that timeouts the response body of a request with a [`Service`] to a total timeout
-/// and a read timeout.
-#[derive(Clone)]
-pub struct ResponseBodyTimeout<S> {
-    inner: S,
-    timeout: RequestConfig<TimeoutOptions>,
-}
-
-impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for ResponseBodyTimeout<S>
-where
-    S: Service<Request<ReqBody>, Response = Response<ResBody>>,
-{
-    type Response = Response<TimeoutBody<ResBody>>;
-    type Error = S::Error;
-    type Future = ResponseBodyTimeoutFuture<S::Future>;
-
-    #[inline(always)]
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.inner.poll_ready(cx)
-    }
-
-    #[inline(always)]
-    fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
-        let (total_timeout, read_timeout) = fetch_timeout_options(&self.timeout, req.extensions());
-        ResponseBodyTimeoutFuture {
-            inner: self.inner.call(req),
-            total_timeout,
-            read_timeout,
+            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)),
         }
     }
 }

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

@@ -1,8 +1,7 @@
 //! Middleware for the client.
 
+pub mod client;
 pub mod config;
-#[cfg(feature = "cookies")]
-pub mod cookie;
 #[cfg(any(
     feature = "gzip",
     feature = "zstd",