wreq-rb 0.3.0

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

@@ -0,0 +1,270 @@
+use std::{
+    future::Future,
+    pin::Pin,
+    str,
+    task::{Context, Poll, ready},
+};
+
+use futures_util::future::Either;
+use http::{
+    HeaderMap, Method, Request, Response, StatusCode, Uri,
+    header::{CONTENT_ENCODING, CONTENT_LENGTH, CONTENT_TYPE, LOCATION, TRANSFER_ENCODING},
+    request::Parts,
+};
+use http_body::Body;
+use pin_project_lite::pin_project;
+use tower::{Service, util::Oneshot};
+use url::Url;
+
+use super::{Action, Attempt, BodyRepr, Policy};
+use crate::{Error, error::BoxError, ext::RequestUri, into_uri::IntoUriSealed};
+
+/// Pending future state for handling redirects.
+pub struct Pending<ReqBody, Response> {
+    future: Pin<Box<dyn Future<Output = Action> + Send>>,
+    location: Uri,
+    body: ReqBody,
+    res: Response,
+}
+
+pin_project! {
+    /// Response future for [`FollowRedirect`].
+    #[project = ResponseFutureProj]
+    pub enum ResponseFuture<S, B, P>
+    where
+        S: Service<Request<B>>,
+    {
+        Redirect {
+            #[pin]
+            future: Either<S::Future, Oneshot<S, Request<B>>>,
+            pending_future: Option<Pending<B, S::Response>>,
+            service: S,
+            policy: P,
+            parts: Parts,
+            body_repr: BodyRepr<B>,
+        },
+
+        Direct {
+            #[pin]
+            future: S::Future,
+        },
+    }
+}
+
+impl<S, ReqBody, ResBody, P> Future for ResponseFuture<S, ReqBody, P>
+where
+    S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone,
+    S::Error: From<BoxError>,
+    P: Policy<ReqBody, S::Error>,
+    ReqBody: Body + Default,
+{
+    type Output = Result<Response<ResBody>, S::Error>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        match self.project() {
+            ResponseFutureProj::Direct { mut future } => future.as_mut().poll(cx),
+            ResponseFutureProj::Redirect {
+                mut future,
+                pending_future,
+                service,
+                policy,
+                parts,
+                body_repr,
+            } => {
+                // Check if we have a pending action to resolve
+                if let Some(mut state) = pending_future.take() {
+                    let action = match state.future.as_mut().poll(cx) {
+                        Poll::Ready(action) => action,
+                        Poll::Pending => {
+                            *pending_future = Some(state);
+                            return Poll::Pending;
+                        }
+                    };
+
+                    return handle_action(
+                        cx,
+                        RedirectAction {
+                            action,
+                            future: &mut future,
+                            service,
+                            policy,
+                            parts,
+                            body: state.body,
+                            body_repr,
+                            res: state.res,
+                            location: state.location,
+                        },
+                    );
+                }
+
+                // Poll the current future to get the response
+                let mut res = {
+                    let mut res = ready!(future.as_mut().poll(cx)?);
+                    res.extensions_mut().insert(RequestUri(parts.uri.clone()));
+                    res
+                };
+
+                // Determine if the response is a redirect
+                match res.status() {
+                    StatusCode::MOVED_PERMANENTLY | StatusCode::FOUND => {
+                        // User agents MAY change the request method from POST to GET
+                        // (RFC 7231 section 6.4.2. and 6.4.3.).
+                        if parts.method == Method::POST {
+                            parts.method = Method::GET;
+                            *body_repr = BodyRepr::Empty;
+                            drop_payload_headers(&mut parts.headers);
+                        }
+                    }
+                    StatusCode::SEE_OTHER => {
+                        // A user agent can perform a GET or HEAD request (RFC 7231 section 6.4.4.).
+                        if parts.method != Method::HEAD {
+                            parts.method = Method::GET;
+                        }
+                        *body_repr = BodyRepr::Empty;
+                        drop_payload_headers(&mut parts.headers);
+                    }
+                    StatusCode::TEMPORARY_REDIRECT | StatusCode::PERMANENT_REDIRECT => {}
+                    _ => {
+                        // Not a redirect status code, return the response as is.
+                        policy.on_response(&mut res);
+                        return Poll::Ready(Ok(res));
+                    }
+                };
+
+                // Extract the request body for potential reuse
+                let Some(body) = body_repr.take() else {
+                    return Poll::Ready(Ok(res));
+                };
+
+                // Get and resolve the Location header
+                let Some(location) = res
+                    .headers()
+                    .get(LOCATION)
+                    .and_then(|loc| loc.to_str().ok())
+                    .and_then(|loc| resolve_uri(loc, &parts.uri))
+                else {
+                    return Poll::Ready(Ok(res));
+                };
+
+                // Prepare the attempt for the policy decision
+                let attempt = Attempt {
+                    status: res.status(),
+                    headers: res.headers(),
+                    location: &location,
+                    previous: &parts.uri,
+                };
+
+                // Resolve the action, awaiting if it's pending
+                let action = match policy.redirect(attempt)? {
+                    Action::Pending(future) => {
+                        // Save the task and necessary state for next poll
+                        *pending_future = Some(Pending {
+                            future,
+                            location,
+                            body,
+                            res,
+                        });
+                        cx.waker().wake_by_ref();
+                        return Poll::Pending;
+                    }
+                    action => action,
+                };
+
+                handle_action(
+                    cx,
+                    RedirectAction {
+                        action,
+                        future: &mut future,
+                        service,
+                        policy,
+                        parts,
+                        body,
+                        body_repr,
+                        res,
+                        location,
+                    },
+                )
+            }
+        }
+    }
+}
+
+/// Try to resolve a URI reference `relative` against a base URI `base`.
+fn resolve_uri(relative: &str, base: &Uri) -> Option<Uri> {
+    Url::parse(&base.to_string())
+        .ok()?
+        .join(relative)
+        .map(String::from)
+        .ok()?
+        .into_uri()
+        .ok()
+}
+
+/// Handle the response based on its status code
+fn drop_payload_headers(headers: &mut HeaderMap) {
+    for header in &[
+        CONTENT_TYPE,
+        CONTENT_LENGTH,
+        CONTENT_ENCODING,
+        TRANSFER_ENCODING,
+    ] {
+        headers.remove(header);
+    }
+}
+
+type RedirectFuturePin<'a, S, ReqBody> =
+    Pin<&'a mut Either<<S as Service<Request<ReqBody>>>::Future, Oneshot<S, Request<ReqBody>>>>;
+
+struct RedirectAction<'a, S, ReqBody, ResBody, P>
+where
+    S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone,
+    P: Policy<ReqBody, S::Error>,
+{
+    action: Action,
+    future: &'a mut RedirectFuturePin<'a, S, ReqBody>,
+    service: &'a S,
+    policy: &'a mut P,
+    parts: &'a mut Parts,
+    body: ReqBody,
+    body_repr: &'a mut BodyRepr<ReqBody>,
+    res: Response<ResBody>,
+    location: Uri,
+}
+
+fn handle_action<S, ReqBody, ResBody, P>(
+    cx: &mut Context<'_>,
+    redirect: RedirectAction<'_, S, ReqBody, ResBody, P>,
+) -> Poll<Result<Response<ResBody>, S::Error>>
+where
+    S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone,
+    S::Error: From<BoxError>,
+    P: Policy<ReqBody, S::Error>,
+    ReqBody: Body + Default,
+{
+    match redirect.action {
+        Action::Follow => {
+            redirect.parts.uri = redirect.location;
+            redirect
+                .body_repr
+                .try_clone_from(&redirect.body, redirect.policy);
+
+            let mut req = Request::from_parts(redirect.parts.clone(), redirect.body);
+            redirect.policy.on_request(&mut req);
+            redirect
+                .future
+                .set(Either::Right(Oneshot::new(redirect.service.clone(), req)));
+
+            cx.waker().wake_by_ref();
+            Poll::Pending
+        }
+        Action::Stop => Poll::Ready(Ok(redirect.res)),
+        Action::Pending(_) => Poll::Ready(Err(S::Error::from(
+            Error::redirect(
+                "Nested pending Action is not supported in redirect policy",
+                redirect.parts.uri.clone(),
+            )
+            .into(),
+        ))),
+        Action::Error(err) => Poll::Ready(Err(err.into())),
+    }
+}

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

@@ -0,0 +1,63 @@
+//! Tools for customizing the behavior of a [`FollowRedirect`][super::FollowRedirect] middleware.
+
+use std::{fmt, pin::Pin};
+
+use http::{HeaderMap, Request, Response, StatusCode, Uri};
+
+use crate::error::BoxError;
+
+/// Trait for the policy on handling redirection responses.
+pub trait Policy<B, E> {
+    /// Invoked when the service received a response with a redirection status code (`3xx`).
+    ///
+    /// This method returns an [`Action`] which indicates whether the service should follow
+    /// the redirection.
+    fn redirect(&mut self, attempt: Attempt<'_>) -> Result<Action, E>;
+
+    /// Returns whether redirection is currently permitted by this policy.
+    ///
+    /// This method is called to determine whether the client should follow redirects at all.
+    /// It allows policies to enable or disable redirection behavior based on the [`Request`].
+    fn follow_redirects(&mut self, _request: &mut Request<B>) -> bool;
+
+    /// Invoked right before the service makes a [`Request`].
+    fn on_request(&mut self, _request: &mut Request<B>);
+
+    /// Invoked right after the service received a [`Response`].
+    fn on_response<Body>(&mut self, _response: &mut Response<Body>);
+
+    /// Try to clone a request body before the service makes a redirected request.
+    fn clone_body(&self, _body: &B) -> Option<B>;
+}
+
+/// A type that holds information on a redirection attempt.
+pub struct Attempt<'a> {
+    pub(crate) status: StatusCode,
+    pub(crate) headers: &'a HeaderMap,
+    pub(crate) location: &'a Uri,
+    pub(crate) previous: &'a Uri,
+}
+
+/// A value returned by [`Policy::redirect`] which indicates the action
+/// [`FollowRedirect`][super::FollowRedirect] should take for a redirection response.
+pub enum Action {
+    /// Follow the redirection.
+    Follow,
+    /// Do not follow the redirection, and return the redirection response as-is.
+    Stop,
+    /// Pending async decision. The async task will be awaited to determine the final action.
+    Pending(Pin<Box<dyn Future<Output = Action> + Send>>),
+    /// An error occurred while determining the redirection action.
+    Error(BoxError),
+}
+
+impl fmt::Debug for Action {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Action::Follow => f.debug_tuple("Follow").finish(),
+            Action::Stop => f.debug_tuple("Stop").finish(),
+            Action::Pending(_) => f.debug_tuple("Pending").finish(),
+            Action::Error(_) => f.debug_tuple("Error").finish(),
+        }
+    }
+}

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

@@ -0,0 +1,145 @@
+//! Middleware for following redirections.
+
+mod future;
+mod policy;
+
+use std::{
+    mem,
+    task::{Context, Poll},
+};
+
+use futures_util::future::Either;
+use http::{Request, Response};
+use http_body::Body;
+use tower::{Layer, Service};
+
+use self::future::ResponseFuture;
+pub use self::policy::{Action, Attempt, Policy};
+use crate::error::BoxError;
+
+enum BodyRepr<B> {
+    Some(B),
+    Empty,
+    None,
+}
+
+impl<B> BodyRepr<B>
+where
+    B: Body + Default,
+{
+    fn take(&mut self) -> Option<B> {
+        match mem::replace(self, BodyRepr::None) {
+            BodyRepr::Some(body) => Some(body),
+            BodyRepr::Empty => {
+                *self = BodyRepr::Empty;
+                Some(B::default())
+            }
+            BodyRepr::None => None,
+        }
+    }
+
+    fn try_clone_from<P, E>(&mut self, body: &B, policy: &P)
+    where
+        P: Policy<B, E>,
+    {
+        match self {
+            BodyRepr::Some(_) | BodyRepr::Empty => {}
+            BodyRepr::None => {
+                if body.size_hint().exact() == Some(0) {
+                    *self = BodyRepr::Some(B::default());
+                } else if let Some(cloned) = policy.clone_body(body) {
+                    *self = BodyRepr::Some(cloned);
+                }
+            }
+        }
+    }
+}
+
+/// [`Layer`] for retrying requests with a [`Service`] to follow redirection responses.
+#[derive(Clone, Copy, Default)]
+pub struct FollowRedirectLayer<P> {
+    policy: P,
+}
+
+impl<P> FollowRedirectLayer<P> {
+    /// Create a new [`FollowRedirectLayer`] with the given redirection [`Policy`].
+    #[inline(always)]
+    pub const fn with_policy(policy: P) -> Self {
+        FollowRedirectLayer { policy }
+    }
+}
+
+impl<S, P> Layer<S> for FollowRedirectLayer<P>
+where
+    S: Clone,
+    P: Clone,
+{
+    type Service = FollowRedirect<S, P>;
+
+    #[inline(always)]
+    fn layer(&self, inner: S) -> Self::Service {
+        FollowRedirect::with_policy(inner, self.policy.clone())
+    }
+}
+
+/// Middleware that retries requests with a [`Service`] to follow redirection responses.
+#[derive(Clone, Copy)]
+pub struct FollowRedirect<S, P> {
+    inner: S,
+    policy: P,
+}
+
+impl<S, P> FollowRedirect<S, P>
+where
+    P: Clone,
+{
+    /// Create a new [`FollowRedirect`] with the given redirection [`Policy`].
+    #[inline(always)]
+    pub const fn with_policy(inner: S, policy: P) -> Self {
+        FollowRedirect { inner, policy }
+    }
+}
+
+impl<ReqBody, ResBody, S, P> Service<Request<ReqBody>> for FollowRedirect<S, P>
+where
+    S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone,
+    S::Error: From<BoxError>,
+    P: Policy<ReqBody, S::Error> + Clone,
+    ReqBody: Body + Default,
+{
+    type Response = Response<ResBody>;
+    type Error = S::Error;
+    type Future = ResponseFuture<S, ReqBody, P>;
+
+    #[inline]
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.inner.poll_ready(cx)
+    }
+
+    fn call(&mut self, mut req: Request<ReqBody>) -> Self::Future {
+        if self.policy.follow_redirects(&mut req) {
+            let service = self.inner.clone();
+            let mut service = mem::replace(&mut self.inner, service);
+            let mut policy = self.policy.clone();
+
+            let mut body_repr = BodyRepr::None;
+            body_repr.try_clone_from(req.body(), &policy);
+            policy.on_request(&mut req);
+
+            let (parts, body) = req.into_parts();
+            let req = Request::from_parts(parts.clone(), body);
+            ResponseFuture::Redirect {
+                future: Either::Left(service.call(req)),
+                pending_future: None,
+                service,
+                policy,
+                parts,
+                body_repr,
+            }
+        } else {
+            ResponseFuture::Direct {
+                future: self.inner.call(req),
+            }
+        }
+    }
+}

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

@@ -0,0 +1,105 @@
+use std::{error::Error as StdError, sync::Arc};
+
+use http::{Method, StatusCode, Uri};
+
+use super::{Req, Res};
+use crate::error::BoxError;
+
+pub trait Classify: Send + Sync + 'static {
+    fn classify(&self, req_rep: ReqRep<'_>) -> Action;
+}
+
+// For Future Whoever: making a blanket impl for any closure sounds nice,
+// but it causes inference issues at the call site. Every closure would
+// need to include `: ReqRep` in the arguments.
+//
+// An alternative is to make things like `ClassifyFn`. Slightly more
+// annoying, but also more forwards-compatible. :shrug:
+pub struct ClassifyFn<F>(pub(crate) F);
+
+impl<F> Classify for ClassifyFn<F>
+where
+    F: Fn(ReqRep<'_>) -> Action + Send + Sync + 'static,
+{
+    fn classify(&self, req_rep: ReqRep<'_>) -> Action {
+        (self.0)(req_rep)
+    }
+}
+
+/// Represents a request-response pair for classification purposes.
+#[derive(Debug)]
+pub struct ReqRep<'a>(&'a Req, Result<StatusCode, &'a BoxError>);
+
+impl ReqRep<'_> {
+    /// Returns the HTTP method of the request.
+    pub fn method(&self) -> &Method {
+        self.0.method()
+    }
+
+    /// Returns the URI of the request.
+    pub fn uri(&self) -> &Uri {
+        self.0.uri()
+    }
+
+    /// Returns the HTTP status code if the response was successful.
+    pub fn status(&self) -> Option<StatusCode> {
+        self.1.ok()
+    }
+
+    /// Returns the error if the request failed.
+    pub fn error(&self) -> Option<&(dyn StdError + 'static)> {
+        self.1.as_ref().err().map(|&e| &**e as _)
+    }
+
+    /// Returns a retryable action.
+    pub fn retryable(self) -> Action {
+        Action::Retryable
+    }
+
+    /// Returns a success action.
+    pub fn success(self) -> Action {
+        Action::Success
+    }
+}
+
+/// The action to take after classifying a request/response pair.
+#[must_use]
+pub enum Action {
+    /// The request was successful and should not be retried.
+    Success,
+    /// The request failed but can be retried.
+    Retryable,
+}
+
+/// Determines whether a request should be retried based on the response or error.
+#[derive(Clone)]
+pub(crate) enum Classifier {
+    /// Never retry any requests.
+    Never,
+    /// Retry protocol-level errors (connection issues, timeouts, etc.).
+    ProtocolNacks,
+    /// Use custom classification logic.
+    Dyn(Arc<dyn Classify>),
+}
+
+impl Classifier {
+    /// Classifies a request/response pair to determine the appropriate retry action.
+    pub(super) fn classify(&mut self, req: &Req, res: &Result<Res, BoxError>) -> Action {
+        let req_rep = ReqRep(req, res.as_ref().map(|r| r.status()));
+        match self {
+            Classifier::Never => Action::Success,
+            Classifier::ProtocolNacks => {
+                let is_protocol_nack = req_rep
+                    .error()
+                    .map(super::is_retryable_error)
+                    .unwrap_or(false);
+                if is_protocol_nack {
+                    Action::Retryable
+                } else {
+                    Action::Success
+                }
+            }
+            Classifier::Dyn(c) => c.classify(req_rep),
+        }
+    }
+}

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

@@ -0,0 +1,51 @@
+use std::sync::Arc;
+
+use super::Req;
+
+pub trait Scope: Send + Sync + 'static {
+    fn applies_to(&self, req: &super::Req) -> bool;
+}
+
+// I think scopes likely make the most sense being to hosts.
+// If that's the case, then it should probably be easiest to check for
+// the host. Perhaps also considering the ability to add more things
+// to scope off in the future...
+
+// For Future Whoever: making a blanket impl for any closure sounds nice,
+// but it causes inference issues at the call site. Every closure would
+// need to include `: ReqRep` in the arguments.
+//
+// An alternative is to make things like `ScopeFn`. Slightly more annoying,
+// but also more forwards-compatible. :shrug:
+
+pub struct ScopeFn<F>(pub(crate) F);
+
+impl<F> Scope for ScopeFn<F>
+where
+    F: Fn(&Req) -> bool + Send + Sync + 'static,
+{
+    fn applies_to(&self, req: &Req) -> bool {
+        (self.0)(req)
+    }
+}
+
+/// Defines the scope of requests that are eligible for retry.
+#[derive(Clone)]
+pub(crate) enum Scoped {
+    /// All requests are eligible for retry regardless of their properties.
+    Unscoped,
+    /// Use custom logic to determine if a request is eligible for retry.
+    Dyn(Arc<dyn Scope>),
+}
+
+impl Scoped {
+    /// Checks if the given request falls within the retry scope.
+    pub(super) fn applies_to(&self, req: &super::Req) -> bool {
+        let ret = match self {
+            Scoped::Unscoped => true,
+            Scoped::Dyn(s) => s.applies_to(req),
+        };
+        trace!("retry in scope: {ret}");
+        ret
+    }
+}