RubyGems - wreq-rb - Versions diffs - 0.3.0 - Mend

wreq-rb 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (167) hide show

checksums.yaml +7 -0
data/Cargo.lock +2688 -0
data/Cargo.toml +6 -0
data/README.md +179 -0
data/ext/wreq_rb/Cargo.toml +39 -0
data/ext/wreq_rb/extconf.rb +22 -0
data/ext/wreq_rb/src/client.rs +565 -0
data/ext/wreq_rb/src/error.rs +25 -0
data/ext/wreq_rb/src/lib.rs +20 -0
data/ext/wreq_rb/src/response.rs +132 -0
data/lib/wreq-rb/version.rb +5 -0
data/lib/wreq-rb.rb +17 -0
data/patches/0001-add-transfer-size-tracking.patch +292 -0
data/vendor/wreq/Cargo.toml +306 -0
data/vendor/wreq/LICENSE +202 -0
data/vendor/wreq/README.md +122 -0
data/vendor/wreq/examples/cert_store.rs +77 -0
data/vendor/wreq/examples/connect_via_lower_priority_tokio_runtime.rs +258 -0
data/vendor/wreq/examples/emulation.rs +118 -0
data/vendor/wreq/examples/form.rs +14 -0
data/vendor/wreq/examples/http1_websocket.rs +37 -0
data/vendor/wreq/examples/http2_websocket.rs +45 -0
data/vendor/wreq/examples/json_dynamic.rs +41 -0
data/vendor/wreq/examples/json_typed.rs +47 -0
data/vendor/wreq/examples/keylog.rs +16 -0
data/vendor/wreq/examples/request_with_emulation.rs +115 -0
data/vendor/wreq/examples/request_with_interface.rs +37 -0
data/vendor/wreq/examples/request_with_local_address.rs +16 -0
data/vendor/wreq/examples/request_with_proxy.rs +13 -0
data/vendor/wreq/examples/request_with_redirect.rs +22 -0
data/vendor/wreq/examples/request_with_version.rs +15 -0
data/vendor/wreq/examples/tor_socks.rs +24 -0
data/vendor/wreq/examples/unix_socket.rs +33 -0
data/vendor/wreq/src/client/body.rs +304 -0
data/vendor/wreq/src/client/conn/conn.rs +231 -0
data/vendor/wreq/src/client/conn/connector.rs +549 -0
data/vendor/wreq/src/client/conn/http.rs +1023 -0
data/vendor/wreq/src/client/conn/proxy/socks.rs +233 -0
data/vendor/wreq/src/client/conn/proxy/tunnel.rs +260 -0
data/vendor/wreq/src/client/conn/proxy.rs +39 -0
data/vendor/wreq/src/client/conn/tls_info.rs +98 -0
data/vendor/wreq/src/client/conn/uds.rs +44 -0
data/vendor/wreq/src/client/conn/verbose.rs +149 -0
data/vendor/wreq/src/client/conn.rs +323 -0
data/vendor/wreq/src/client/core/body/incoming.rs +485 -0
data/vendor/wreq/src/client/core/body/length.rs +118 -0
data/vendor/wreq/src/client/core/body.rs +34 -0
data/vendor/wreq/src/client/core/common/buf.rs +149 -0
data/vendor/wreq/src/client/core/common/rewind.rs +141 -0
data/vendor/wreq/src/client/core/common/watch.rs +76 -0
data/vendor/wreq/src/client/core/common.rs +3 -0
data/vendor/wreq/src/client/core/conn/http1.rs +342 -0
data/vendor/wreq/src/client/core/conn/http2.rs +307 -0
data/vendor/wreq/src/client/core/conn.rs +11 -0
data/vendor/wreq/src/client/core/dispatch.rs +299 -0
data/vendor/wreq/src/client/core/error.rs +435 -0
data/vendor/wreq/src/client/core/ext.rs +201 -0
data/vendor/wreq/src/client/core/http1.rs +178 -0
data/vendor/wreq/src/client/core/http2.rs +483 -0
data/vendor/wreq/src/client/core/proto/h1/conn.rs +988 -0
data/vendor/wreq/src/client/core/proto/h1/decode.rs +1170 -0
data/vendor/wreq/src/client/core/proto/h1/dispatch.rs +684 -0
data/vendor/wreq/src/client/core/proto/h1/encode.rs +580 -0
data/vendor/wreq/src/client/core/proto/h1/io.rs +879 -0
data/vendor/wreq/src/client/core/proto/h1/role.rs +694 -0
data/vendor/wreq/src/client/core/proto/h1.rs +104 -0
data/vendor/wreq/src/client/core/proto/h2/client.rs +650 -0
data/vendor/wreq/src/client/core/proto/h2/ping.rs +539 -0
data/vendor/wreq/src/client/core/proto/h2.rs +379 -0
data/vendor/wreq/src/client/core/proto/headers.rs +138 -0
data/vendor/wreq/src/client/core/proto.rs +58 -0
data/vendor/wreq/src/client/core/rt/bounds.rs +57 -0
data/vendor/wreq/src/client/core/rt/timer.rs +150 -0
data/vendor/wreq/src/client/core/rt/tokio.rs +99 -0
data/vendor/wreq/src/client/core/rt.rs +25 -0
data/vendor/wreq/src/client/core/upgrade.rs +267 -0
data/vendor/wreq/src/client/core.rs +16 -0
data/vendor/wreq/src/client/emulation.rs +161 -0
data/vendor/wreq/src/client/http/client/error.rs +142 -0
data/vendor/wreq/src/client/http/client/exec.rs +29 -0
data/vendor/wreq/src/client/http/client/extra.rs +77 -0
data/vendor/wreq/src/client/http/client/lazy.rs +79 -0
data/vendor/wreq/src/client/http/client/pool.rs +1105 -0
data/vendor/wreq/src/client/http/client/util.rs +104 -0
data/vendor/wreq/src/client/http/client.rs +1003 -0
data/vendor/wreq/src/client/http/future.rs +99 -0
data/vendor/wreq/src/client/http.rs +1629 -0
data/vendor/wreq/src/client/layer/config/options.rs +156 -0
data/vendor/wreq/src/client/layer/config.rs +116 -0
data/vendor/wreq/src/client/layer/cookie.rs +161 -0
data/vendor/wreq/src/client/layer/decoder.rs +139 -0
data/vendor/wreq/src/client/layer/redirect/future.rs +270 -0
data/vendor/wreq/src/client/layer/redirect/policy.rs +63 -0
data/vendor/wreq/src/client/layer/redirect.rs +145 -0
data/vendor/wreq/src/client/layer/retry/classify.rs +105 -0
data/vendor/wreq/src/client/layer/retry/scope.rs +51 -0
data/vendor/wreq/src/client/layer/retry.rs +151 -0
data/vendor/wreq/src/client/layer/timeout/body.rs +233 -0
data/vendor/wreq/src/client/layer/timeout/future.rs +90 -0
data/vendor/wreq/src/client/layer/timeout.rs +177 -0
data/vendor/wreq/src/client/layer.rs +15 -0
data/vendor/wreq/src/client/multipart.rs +717 -0
data/vendor/wreq/src/client/request.rs +818 -0
data/vendor/wreq/src/client/response.rs +534 -0
data/vendor/wreq/src/client/ws/json.rs +99 -0
data/vendor/wreq/src/client/ws/message.rs +453 -0
data/vendor/wreq/src/client/ws.rs +714 -0
data/vendor/wreq/src/client.rs +27 -0
data/vendor/wreq/src/config.rs +140 -0
data/vendor/wreq/src/cookie.rs +579 -0
data/vendor/wreq/src/dns/gai.rs +249 -0
data/vendor/wreq/src/dns/hickory.rs +78 -0
data/vendor/wreq/src/dns/resolve.rs +180 -0
data/vendor/wreq/src/dns.rs +69 -0
data/vendor/wreq/src/error.rs +502 -0
data/vendor/wreq/src/ext.rs +398 -0
data/vendor/wreq/src/hash.rs +143 -0
data/vendor/wreq/src/header.rs +506 -0
data/vendor/wreq/src/into_uri.rs +187 -0
data/vendor/wreq/src/lib.rs +586 -0
data/vendor/wreq/src/proxy/mac.rs +82 -0
data/vendor/wreq/src/proxy/matcher.rs +806 -0
data/vendor/wreq/src/proxy/uds.rs +66 -0
data/vendor/wreq/src/proxy/win.rs +31 -0
data/vendor/wreq/src/proxy.rs +569 -0
data/vendor/wreq/src/redirect.rs +575 -0
data/vendor/wreq/src/retry.rs +198 -0
data/vendor/wreq/src/sync.rs +129 -0
data/vendor/wreq/src/tls/conn/cache.rs +123 -0
data/vendor/wreq/src/tls/conn/cert_compression.rs +125 -0
data/vendor/wreq/src/tls/conn/ext.rs +82 -0
data/vendor/wreq/src/tls/conn/macros.rs +34 -0
data/vendor/wreq/src/tls/conn/service.rs +138 -0
data/vendor/wreq/src/tls/conn.rs +681 -0
data/vendor/wreq/src/tls/keylog/handle.rs +64 -0
data/vendor/wreq/src/tls/keylog.rs +99 -0
data/vendor/wreq/src/tls/options.rs +464 -0
data/vendor/wreq/src/tls/x509/identity.rs +122 -0
data/vendor/wreq/src/tls/x509/parser.rs +71 -0
data/vendor/wreq/src/tls/x509/store.rs +228 -0
data/vendor/wreq/src/tls/x509.rs +68 -0
data/vendor/wreq/src/tls.rs +154 -0
data/vendor/wreq/src/trace.rs +55 -0
data/vendor/wreq/src/util.rs +122 -0
data/vendor/wreq/tests/badssl.rs +228 -0
data/vendor/wreq/tests/brotli.rs +350 -0
data/vendor/wreq/tests/client.rs +1098 -0
data/vendor/wreq/tests/connector_layers.rs +227 -0
data/vendor/wreq/tests/cookie.rs +306 -0
data/vendor/wreq/tests/deflate.rs +347 -0
data/vendor/wreq/tests/emulation.rs +260 -0
data/vendor/wreq/tests/gzip.rs +347 -0
data/vendor/wreq/tests/layers.rs +261 -0
data/vendor/wreq/tests/multipart.rs +165 -0
data/vendor/wreq/tests/proxy.rs +438 -0
data/vendor/wreq/tests/redirect.rs +629 -0
data/vendor/wreq/tests/retry.rs +135 -0
data/vendor/wreq/tests/support/delay_server.rs +117 -0
data/vendor/wreq/tests/support/error.rs +16 -0
data/vendor/wreq/tests/support/layer.rs +183 -0
data/vendor/wreq/tests/support/mod.rs +9 -0
data/vendor/wreq/tests/support/server.rs +232 -0
data/vendor/wreq/tests/timeouts.rs +281 -0
data/vendor/wreq/tests/unix_socket.rs +135 -0
data/vendor/wreq/tests/upgrade.rs +98 -0
data/vendor/wreq/tests/zstd.rs +559 -0
metadata +225 -0

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

@@ -0,0 +1,151 @@
+//! Middleware for retrying requests.
+mod classify;
+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},
+};
+pub(crate) use self::{
+    classify::{Action, Classifier, ClassifyFn, ReqRep},
+    scope::{ScopeFn, Scoped},
+};
+use super::super::core::body::Incoming;
+use crate::{Body, error::BoxError, retry};
+/// A retry policy for HTTP requests.
+#[derive(Clone)]
+pub struct RetryPolicy {
+    budget: Option<Arc<TpsBudget>>,
+    classifier: Classifier,
+    max_retries_per_request: u32,
+    retry_cnt: u32,
+    scope: Scoped,
+}
+impl RetryPolicy {
+    /// Create a new `RetryPolicy`.
+    #[inline]
+    pub fn new(policy: retry::Policy) -> Self {
+        Self {
+            budget: policy
+                .budget
+                .map(|budget| Arc::new(TpsBudget::new(Duration::from_secs(10), 10, budget))),
+            classifier: policy.classifier,
+            max_retries_per_request: policy.max_retries_per_request,
+            retry_cnt: 0,
+            scope: policy.scope,
+        }
+    }
+}
+type Req = Request<Body>;
+type Res = Response<Incoming>;
+impl Policy<Req, Res, BoxError> for RetryPolicy {
+    type Future = Ready<()>;
+    fn retry(&mut self, req: &mut Req, result: &mut Result<Res, BoxError>) -> Option<Self::Future> {
+        match self.classifier.classify(req, result) {
+            Action::Success => {
+                trace!(
+                    "Request successful, no retry needed: {} {}",
+                    req.method(),
+                    req.uri()
+                );
+                if let Some(ref budget) = self.budget {
+                    budget.deposit();
+                    trace!("Token deposited back to retry budget");
+                }
+                None
+            }
+            Action::Retryable => {
+                if self.budget.as_ref().map(|b| b.withdraw()).unwrap_or(true) {
+                    self.retry_cnt += 1;
+                    trace!(
+                        "Retrying request ({}/{} attempts): {} {} - {}",
+                        self.retry_cnt,
+                        self.max_retries_per_request,
+                        req.method(),
+                        req.uri(),
+                        match result {
+                            Ok(res) => format!("HTTP {}", res.status()),
+                            Err(e) => format!("Error: {}", e),
+                        }
+                    );
+                    Some(std::future::ready(()))
+                } else {
+                    debug!(
+                        "Request is retryable but retry budget exhausted: {} {}",
+                        req.method(),
+                        req.uri()
+                    );
+                    None
+                }
+            }
+        }
+    }
+    fn clone_request(&mut self, req: &Req) -> Option<Req> {
+        if self.retry_cnt > 0 && !self.scope.applies_to(req) {
+            trace!("not in scope, not retrying");
+            return None;
+        }
+        if self.retry_cnt >= self.max_retries_per_request {
+            trace!("max_retries_per_request hit");
+            return None;
+        }
+        let body = req.body().try_clone()?;
+        let mut new = http::Request::new(body);
+        *new.method_mut() = req.method().clone();
+        *new.uri_mut() = req.uri().clone();
+        *new.version_mut() = req.version();
+        *new.headers_mut() = req.headers().clone();
+        *new.extensions_mut() = req.extensions().clone();
+        Some(new)
+    }
+}
+/// Determines whether the given error is considered retryable for HTTP/2 requests.
+///
+/// Returns `true` if the error type or content indicates that the request can be retried,
+/// otherwise returns `false`.
+fn is_retryable_error(err: &(dyn StdError + 'static)) -> bool {
+    let err = if let Some(err) = err.source() {
+        err
+    } else {
+        return false;
+    };
+    if let Some(cause) = err.source() {
+        if let Some(err) = cause.downcast_ref::<http2::Error>() {
+            // They sent us a graceful shutdown, try with a new connection!
+            if err.is_go_away() && err.is_remote() && err.reason() == Some(http2::Reason::NO_ERROR)
+            {
+                return true;
+            }
+            // REFUSED_STREAM was sent from the server, which is safe to retry.
+            // https://www.rfc-editor.org/rfc/rfc9113.html#section-8.7-3.2
+            if err.is_reset()
+                && err.is_remote()
+                && err.reason() == Some(http2::Reason::REFUSED_STREAM)
+            {
+                return true;
+            }
+        }
+    }
+    false
+}

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

@@ -0,0 +1,233 @@
+use std::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll, ready},
+    time::Duration,
+};
+use http_body::Body;
+use pin_project_lite::pin_project;
+use tokio::time::{Sleep, sleep};
+use crate::{
+    Error,
+    error::{BoxError, TimedOut},
+};
+pin_project! {
+    /// A wrapper body that applies timeout strategies to an inner HTTP body.
+    #[project = TimeoutBodyProj]
+    pub enum TimeoutBody<B> {
+        Plain {
+            #[pin]
+            body: B,
+        },
+        TotalTimeout {
+            #[pin]
+            body: TotalTimeoutBody<B>,
+        },
+        ReadTimeout {
+            #[pin]
+            body: ReadTimeoutBody<B>
+        },
+        CombinedTimeout {
+            #[pin]
+            body: TotalTimeoutBody<ReadTimeoutBody<B>>,
+        }
+    }
+}
+pin_project! {
+    /// A body wrapper that enforces a total timeout for the entire stream.
+    ///
+    /// The timeout applies to the whole body: if the deadline is reached before
+    /// the body is fully read, an error is returned. The timer does **not** reset
+    /// between chunks.
+    pub struct TotalTimeoutBody<B> {
+        #[pin]
+        body: B,
+        timeout: Pin<Box<Sleep>>,
+    }
+}
+pin_project! {
+    /// A body wrapper that enforces a timeout for each read operation.
+    ///
+    /// 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<Sleep>,
+        #[pin]
+        body: B,
+    }
+}
+/// ==== 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);
+        match (deadline, read_timeout) {
+            (Some(total_timeout), Some(read_timeout)) => TimeoutBody::CombinedTimeout {
+                body: TotalTimeoutBody {
+                    timeout: total_timeout,
+                    body: ReadTimeoutBody {
+                        timeout: read_timeout,
+                        sleep: None,
+                        body,
+                    },
+                },
+            },
+            (Some(timeout), None) => TimeoutBody::TotalTimeout {
+                body: TotalTimeoutBody { body, timeout },
+            },
+            (None, Some(timeout)) => TimeoutBody::ReadTimeout {
+                body: ReadTimeoutBody {
+                    timeout,
+                    sleep: None,
+                    body,
+                },
+            },
+            (None, None) => TimeoutBody::Plain { body },
+        }
+    }
+}
+impl<B> Body for TimeoutBody<B>
+where
+    B: Body,
+    B::Error: Into<BoxError>,
+{
+    type Data = B::Data;
+    type Error = BoxError;
+    #[inline(always)]
+    fn poll_frame(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<http_body::Frame<Self::Data>, Self::Error>>> {
+        match self.project() {
+            TimeoutBodyProj::TotalTimeout { body } => body.poll_frame(cx),
+            TimeoutBodyProj::ReadTimeout { body } => body.poll_frame(cx),
+            TimeoutBodyProj::CombinedTimeout { body } => body.poll_frame(cx),
+            TimeoutBodyProj::Plain { body } => poll_and_map_body(body, cx),
+        }
+    }
+    #[inline(always)]
+    fn size_hint(&self) -> http_body::SizeHint {
+        match self {
+            TimeoutBody::TotalTimeout { body } => body.size_hint(),
+            TimeoutBody::ReadTimeout { body } => body.size_hint(),
+            TimeoutBody::CombinedTimeout { body } => body.size_hint(),
+            TimeoutBody::Plain { body } => body.size_hint(),
+        }
+    }
+    #[inline(always)]
+    fn is_end_stream(&self) -> bool {
+        match self {
+            TimeoutBody::TotalTimeout { body } => body.is_end_stream(),
+            TimeoutBody::ReadTimeout { body } => body.is_end_stream(),
+            TimeoutBody::CombinedTimeout { body } => body.is_end_stream(),
+            TimeoutBody::Plain { body } => body.is_end_stream(),
+        }
+    }
+}
+#[inline(always)]
+fn poll_and_map_body<B>(
+    body: Pin<&mut B>,
+    cx: &mut Context<'_>,
+) -> Poll<Option<Result<http_body::Frame<B::Data>, BoxError>>>
+where
+    B: Body,
+    B::Error: Into<BoxError>,
+{
+    Poll::Ready(
+        ready!(body.poll_frame(cx)).map(|opt| opt.map_err(Error::decode).map_err(Into::into)),
+    )
+}
+// ==== impl TotalTimeoutBody ====
+impl<B> Body for TotalTimeoutBody<B>
+where
+    B: Body,
+    B::Error: Into<BoxError>,
+{
+    type Data = B::Data;
+    type Error = BoxError;
+    fn poll_frame(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+    ) -> Poll<Option<Result<http_body::Frame<Self::Data>, Self::Error>>> {
+        let this = self.project();
+        if let Poll::Ready(()) = this.timeout.as_mut().poll(cx) {
+            return Poll::Ready(Some(Err(Error::body(TimedOut).into())));
+        }
+        poll_and_map_body(this.body, cx)
+    }
+    #[inline(always)]
+    fn size_hint(&self) -> http_body::SizeHint {
+        self.body.size_hint()
+    }
+    #[inline(always)]
+    fn is_end_stream(&self) -> bool {
+        self.body.is_end_stream()
+    }
+}
+/// ==== impl ReadTimeoutBody ====
+impl<B> Body for ReadTimeoutBody<B>
+where
+    B: Body,
+    B::Error: Into<BoxError>,
+{
+    type Data = B::Data;
+    type Error = BoxError;
+    fn poll_frame(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<http_body::Frame<Self::Data>, Self::Error>>> {
+        let mut this = self.project();
+        // Error if the timeout has expired.
+        if this.sleep.is_none() {
+            this.sleep.set(Some(sleep(*this.timeout)));
+        }
+        // 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))));
+            }
+        }
+        // Poll the actual body
+        match ready!(this.body.poll_frame(cx)) {
+            Some(Ok(frame)) => {
+                // Reset timeout on successful read
+                this.sleep.set(None);
+                Poll::Ready(Some(Ok(frame)))
+            }
+            Some(Err(err)) => Poll::Ready(Some(Err(err.into()))),
+            None => Poll::Ready(None),
+        }
+    }
+    #[inline(always)]
+    fn size_hint(&self) -> http_body::SizeHint {
+        self.body.size_hint()
+    }
+    #[inline(always)]
+    fn is_end_stream(&self) -> bool {
+        self.body.is_end_stream()
+    }
+}

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

@@ -0,0 +1,90 @@
+use std::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll, ready},
+    time::Duration,
+};
+use http::Response;
+use pin_project_lite::pin_project;
+use tokio::time::Sleep;
+use super::body::TimeoutBody;
+use crate::error::{BoxError, Error, TimedOut};
+pin_project! {
+    /// [`Timeout`] response future
+    pub struct ResponseFuture<F> {
+        #[pin]
+        pub(crate) response: F,
+        #[pin]
+        pub(crate) total_timeout: Option<Sleep>,
+        #[pin]
+        pub(crate) read_timeout: Option<Sleep>,
+    }
+}
+impl<F, T, E> Future for ResponseFuture<F>
+where
+    F: Future<Output = Result<T, E>>,
+    E: Into<BoxError>,
+{
+    type Output = Result<T, BoxError>;
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.project();
+        // First, try polling the future
+        match this.response.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>>| {
+            if let Some(sleep) = sleep {
+                if sleep.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().as_pin_mut()) {
+            return poll;
+        }
+        // Check read timeout
+        if let Some(poll) = check_timeout(this.read_timeout.as_mut().as_pin_mut()) {
+            return poll;
+        }
+        Poll::Pending
+    }
+}
+pin_project! {
+    /// Response future for [`ResponseBodyTimeout`].
+    pub struct ResponseBodyTimeoutFuture<Fut> {
+        #[pin]
+        pub(super) inner: Fut,
+        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>;
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        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));
+        Poll::Ready(Ok(res))
+    }
+}

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

@@ -0,0 +1,177 @@
+//! Middleware for setting a timeout on the response.
+mod body;
+mod future;
+use std::{
+    task::{Context, Poll},
+    time::Duration,
+};
+use http::{Request, Response};
+use tower::{Layer, Service};
+pub use self::body::TimeoutBody;
+use self::future::{ResponseBodyTimeoutFuture, ResponseFuture};
+use crate::{config::RequestConfig, error::BoxError};
+/// Options for configuring timeouts.
+#[derive(Clone, Copy, Default)]
+pub struct TimeoutOptions {
+    total_timeout: Option<Duration>,
+    read_timeout: Option<Duration>,
+}
+impl TimeoutOptions {
+    /// Sets the read timeout for the options.
+    #[inline]
+    pub fn read_timeout(&mut self, read_timeout: Duration) -> &mut Self {
+        self.read_timeout = Some(read_timeout);
+        self
+    }
+    /// Sets the total timeout for the options.
+    #[inline]
+    pub fn total_timeout(&mut self, total_timeout: Duration) -> &mut Self {
+        self.total_timeout = Some(total_timeout);
+        self
+    }
+}
+impl_request_config_value!(TimeoutOptions);
+/// [`Layer`] that applies a [`Timeout`] middleware to a service.
+// This layer allows you to set a total timeout and a read timeout for requests.
+#[derive(Clone)]
+pub struct TimeoutLayer {
+    timeout: RequestConfig<TimeoutOptions>,
+}
+impl TimeoutLayer {
+    /// Create a new [`TimeoutLayer`].
+    #[inline(always)]
+    pub const fn new(options: TimeoutOptions) -> Self {
+        TimeoutLayer {
+            timeout: RequestConfig::new(Some(options)),
+        }
+    }
+}
+impl<S> Layer<S> for TimeoutLayer {
+    type Service = Timeout<S>;
+    #[inline(always)]
+    fn layer(&self, service: S) -> Self::Service {
+        Timeout {
+            inner: service,
+            timeout: self.timeout,
+        }
+    }
+}
+/// Middleware that applies total and per-read timeouts to a [`Service`] response body.
+#[derive(Clone)]
+pub struct Timeout<T> {
+    inner: T,
+    timeout: RequestConfig<TimeoutOptions>,
+}
+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 Error = BoxError;
+    type Future = ResponseFuture<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());
+        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,
+        }
+    }
+}
+fn fetch_timeout_options(
+    opts: &RequestConfig<TimeoutOptions>,
+    extensions: &http::Extensions,
+) -> (Option<Duration>, Option<Duration>) {
+    match (opts.as_ref(), opts.fetch(extensions)) {
+        (Some(opts), Some(request_opts)) => (
+            request_opts.total_timeout.or(opts.total_timeout),
+            request_opts.read_timeout.or(opts.read_timeout),
+        ),
+        (Some(opts), None) => (opts.total_timeout, opts.read_timeout),
+        (None, Some(opts)) => (opts.total_timeout, opts.read_timeout),
+        (None, None) => (None, None),
+    }
+}

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

@@ -0,0 +1,15 @@
+//! Middleware for the client.
+pub mod config;
+#[cfg(feature = "cookies")]
+pub mod cookie;
+#[cfg(any(
+    feature = "gzip",
+    feature = "zstd",
+    feature = "brotli",
+    feature = "deflate",
+))]
+pub mod decoder;
+pub mod redirect;
+pub mod retry;
+pub mod timeout;