better names

Author: unusual-thoughts

tower-http/src/builder.rs

@@ -174,7 +174,7 @@ pub trait ServiceBuilderExt<L>: sealed::Sealed<L> + Sized {
         Stack<
             crate::follow_redirect::FollowRedirectLayer<
                 crate::follow_redirect::policy::Standard,
-                crate::follow_redirect::PolicyExtension,
+                crate::follow_redirect::UriAndPolicyExtensions,
             >,
             L,
         >,
@@ -486,7 +486,7 @@ impl<L> ServiceBuilderExt<L> for ServiceBuilder<L> {
         Stack<
             crate::follow_redirect::FollowRedirectLayer<
                 crate::follow_redirect::policy::Standard,
-                crate::follow_redirect::PolicyExtension,
+                crate::follow_redirect::UriAndPolicyExtensions,
             >,
             L,
         >,

tower-http/src/follow_redirect/mod.rs

@@ -91,6 +91,39 @@
 //! # Ok(())
 //! # }
 //! ```
+//!
+//! ## Customizing extensions
+//!
+//! You can use [`FollowRedirectLayer::with_policy_extension()`]
+//! to also set the [`FollowedPolicy`] extension on the response.
+//!
+//! ```
+//! use http::{Request, Response};
+//! use bytes::Bytes;
+//! use http_body_util::Full;
+//! use tower::{Service, ServiceBuilder, ServiceExt};
+//! use tower_http::follow_redirect::{FollowRedirectLayer, FollowedPolicy, policy};
+//!
+//! # #[tokio::main]
+//! # async fn main() -> Result<(), std::convert::Infallible> {
+//! # let http_client =
+//! #     tower::service_fn(|_: Request<Full<Bytes>>| async { Ok::<_, std::convert::Infallible>(Response::new(Full::<Bytes>::default())) });
+//! let mut client = ServiceBuilder::new()
+//!     .layer(FollowRedirectLayer::with_policy_extension(policy::Limited::new(10)))
+//!     .service(http_client);
+//!
+//! let res = client.ready().await?.call(Request::default()).await?;
+//! assert_eq!(
+//!     res.extensions()
+//!         .get::<FollowedPolicy<policy::Limited>>()
+//!         .unwrap()
+//!         .0
+//!         .remaining,
+//!     10
+//! );
+//! # Ok(())
+//! # }
+//! ```
 
 pub mod policy;
 
@@ -120,9 +153,9 @@ use tower_service::Service;
 ///
 /// See the [module docs](self) for more details.
 #[derive(Clone, Copy, Debug, Default)]
-pub struct FollowRedirectLayer<P = Standard, CB = NoOp> {
+pub struct FollowRedirectLayer<P = Standard, CB = UriExtension> {
     policy: P,
-    callback: CB,
+    handler: CB,
 }
 
 impl FollowRedirectLayer {
@@ -137,12 +170,12 @@ impl<P> FollowRedirectLayer<P> {
     pub fn with_policy(policy: P) -> Self {
         Self {
             policy,
-            callback: NoOp::default(),
+            handler: UriExtension::default(),
         }
     }
 }
 
-impl<P> FollowRedirectLayer<P, PolicyExtension>
+impl<P> FollowRedirectLayer<P, UriAndPolicyExtensions>
 where
     P: Send + Sync + 'static,
 {
@@ -151,7 +184,7 @@ where
     pub fn with_policy_extension(policy: P) -> Self {
         Self {
             policy,
-            callback: PolicyExtension::default(),
+            handler: UriAndPolicyExtensions::default(),
         }
     }
 }
@@ -165,18 +198,18 @@ where
     type Service = FollowRedirect<S, P, CB>;
 
     fn layer(&self, inner: S) -> Self::Service {
-        FollowRedirect::with_policy_callback(inner, self.policy.clone(), self.callback)
+        FollowRedirect::with_policy_handler(inner, self.policy.clone(), self.handler)
     }
 }
 
 /// Middleware that retries requests with a [`Service`] to follow redirection responses.
 ///
 /// See the [module docs](self) for more details.
 #[derive(Clone, Copy, Debug)]
-pub struct FollowRedirect<S, P = Standard, CB = NoOp> {
+pub struct FollowRedirect<S, P = Standard, CB = UriExtension> {
     inner: S,
     policy: P,
-    callback: CB,
+    handler: CB,
 }
 
 impl<S> FollowRedirect<S> {
@@ -193,18 +226,22 @@ impl<S> FollowRedirect<S> {
     }
 }
 
-impl<S> FollowRedirect<S, Standard, PolicyExtension> {
+impl<S> FollowRedirect<S, Standard, UriAndPolicyExtensions> {
     /// Create a new [`FollowRedirect`] with a [`Standard`] redirection policy,
     /// that inserts the [`FollowedPolicy`] extension.
     pub fn with_extension(inner: S) -> Self {
-        Self::with_policy_callback(inner, Standard::default(), PolicyExtension::default())
+        Self::with_policy_handler(
+            inner,
+            Standard::default(),
+            UriAndPolicyExtensions::default(),
+        )
     }
 
     /// Returns a new [`Layer`] that wraps services with a `FollowRedirect` middleware
     /// that inserts the [`FollowedPolicy`] extension.
     ///
     /// [`Layer`]: tower_layer::Layer
-    pub fn layer_with_extension() -> FollowRedirectLayer<Standard, PolicyExtension> {
+    pub fn layer_with_extension() -> FollowRedirectLayer<Standard, UriAndPolicyExtensions> {
         FollowRedirectLayer::with_policy_extension(Standard::default())
     }
 }
@@ -218,7 +255,7 @@ where
         FollowRedirect {
             inner,
             policy,
-            callback: NoOp::default(),
+            handler: UriExtension::default(),
         }
     }
 
@@ -235,53 +272,53 @@ impl<S, P, CB> FollowRedirect<S, P, CB>
 where
     P: Clone,
 {
-    /// Create a new [`FollowRedirect`] with the given redirection [`Policy`] and [`ResponseCallback`].
-    fn with_policy_callback(inner: S, policy: P, callback: CB) -> Self {
+    /// Create a new [`FollowRedirect`] with the given redirection [`Policy`] and [`ResponseHandler`].
+    fn with_policy_handler(inner: S, policy: P, handler: CB) -> Self {
         FollowRedirect {
             inner,
             policy,
-            callback,
+            handler,
         }
     }
 
     define_inner_service_accessors!();
 }
 
 /// Called on each new response, can be used for example to add [`http::Extensions`]
-trait ResponseCallback<ReqBody, ResBody, S, P>: Sized
+trait ResponseHandler<ReqBody, ResBody, S, P>: Sized
 where
     S: Service<Request<ReqBody>>,
 {
-    fn handle(res: &mut Response<ResBody>, req: &RedirectingRequest<S, ReqBody, P>);
+    fn on_response(res: &mut Response<ResBody>, req: &RedirectingRequest<S, ReqBody, P>);
 }
 
-/// Default behavior: doesn't do anything
+/// Default behavior: adds a [`RequestUri`] extension to the response.
 #[derive(Default, Clone, Copy)]
-pub struct NoOp {}
+pub struct UriExtension {}
 
-impl<ReqBody, ResBody, S, P> ResponseCallback<ReqBody, ResBody, S, P> for NoOp
+impl<ReqBody, ResBody, S, P> ResponseHandler<ReqBody, ResBody, S, P> for UriExtension
 where
     S: Service<Request<ReqBody>>,
 {
-    fn handle(_res: &mut Response<ResBody>, _req: &RedirectingRequest<S, ReqBody, P>) {}
+    #[inline]
+    fn on_response(res: &mut Response<ResBody>, req: &RedirectingRequest<S, ReqBody, P>) {
+        res.extensions_mut().insert(RequestUri(req.uri.clone()));
+    }
 }
 
-/// Response [`Extensions`][http::Extensions] value that contains the redirect [`Policy`] that
-/// was run before the last request of the redirect chain by a [`FollowRedirectExtension`] middleware.
-#[derive(Clone)]
-pub struct FollowedPolicy<P>(pub P);
-
-/// Adds a [`FollowedPolicy`] extension to the response
-
+/// Adds a [`FollowedPolicy`] and [`RequestUri`] extension to the response.
 #[derive(Default, Clone, Copy)]
-pub struct PolicyExtension {}
+pub struct UriAndPolicyExtensions {}
 
-impl<ReqBody, ResBody, S, P> ResponseCallback<ReqBody, ResBody, S, P> for PolicyExtension
+impl<ReqBody, ResBody, S, P> ResponseHandler<ReqBody, ResBody, S, P> for UriAndPolicyExtensions
 where
     S: Service<Request<ReqBody>>,
     P: Clone + Send + Sync + 'static,
 {
-    fn handle(res: &mut Response<ResBody>, req: &RedirectingRequest<S, ReqBody, P>) {
+    #[inline]
+    fn on_response(res: &mut Response<ResBody>, req: &RedirectingRequest<S, ReqBody, P>) {
+        UriExtension::on_response(res, req);
+
         res.extensions_mut()
             .insert(FollowedPolicy(req.policy.clone()));
     }
@@ -292,7 +329,7 @@ where
     S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone,
     ReqBody: Body + Default,
     P: Policy<ReqBody, S::Error> + Clone,
-    CB: ResponseCallback<ReqBody, ResBody, S, P> + Copy,
+    CB: ResponseHandler<ReqBody, ResBody, S, P> + Copy,
 {
     type Response = Response<ResBody>;
     type Error = S::Error;
@@ -312,7 +349,7 @@ where
         ResponseFuture {
             future: Either::Left(request.service.call(req)),
             request,
-            callback: self.callback,
+            handler: self.handler,
         }
     }
 }
@@ -327,7 +364,7 @@ pin_project! {
         #[pin]
         future: Either<S::Future, Oneshot<S, Request<B>>>,
         request: RedirectingRequest<S, B, P>,
-        callback: CB
+        handler: CB
     }
 }
 
@@ -336,14 +373,14 @@ where
     S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone,
     ReqBody: Body + Default,
     P: Policy<ReqBody, S::Error>,
-    CB: ResponseCallback<ReqBody, ResBody, S, P>,
+    CB: ResponseHandler<ReqBody, ResBody, S, P>,
 {
     type Output = Result<Response<ResBody>, S::Error>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let mut this = self.project();
         let mut res = ready!(this.future.as_mut().poll(cx)?);
-        CB::handle(&mut res, &this.request);
+        CB::on_response(&mut res, &this.request);
 
         match this.request.handle_response(&mut res) {
             Ok(Some(pending)) => {
@@ -402,8 +439,6 @@ where
         &mut self,
         res: &mut Response<ResBody>,
     ) -> Result<Option<Oneshot<S, Request<ReqBody>>>, S::Error> {
-        res.extensions_mut().insert(RequestUri(self.uri.clone()));
-
         let drop_payload_headers = |headers: &mut HeaderMap| {
             for header in &[
                 CONTENT_TYPE,
@@ -483,6 +518,11 @@ where
 #[derive(Clone)]
 pub struct RequestUri(pub Uri);
 
+/// Response [`Extensions`][http::Extensions] value that contains the redirect [`Policy`] that
+/// was run before the last request of the redirect chain by a [`FollowRedirectExtension`] middleware.
+#[derive(Clone)]
+pub struct FollowedPolicy<P>(pub P);
+
 #[derive(Debug)]
 enum BodyRepr<B> {
     Some(B),
@@ -551,7 +591,7 @@ mod tests {
     #[tokio::test]
     async fn follows() {
         let svc = ServiceBuilder::new()
-            .layer(FollowRedirectLayer::with_policy(Action::Follow))
+            .layer(FollowRedirectLayer::with_policy_extension(Action::Follow))
             .buffer(1)
             .service_fn(handle);
         let req = Request::builder()
@@ -564,12 +604,18 @@ mod tests {
             res.extensions().get::<RequestUri>().unwrap().0,
             "http://example.com/0"
         );
+        assert!(res
+            .extensions()
+            .get::<FollowedPolicy<Action>>()
+            .unwrap()
+            .0
+            .is_follow());
     }
 
     #[tokio::test]
     async fn stops() {
         let svc = ServiceBuilder::new()
-            .layer(FollowRedirectLayer::with_policy(Action::Stop))
+            .layer(FollowRedirectLayer::with_policy_extension(Action::Stop))
             .buffer(1)
             .service_fn(handle);
         let req = Request::builder()
@@ -582,12 +628,18 @@ mod tests {
             res.extensions().get::<RequestUri>().unwrap().0,
             "http://example.com/42"
         );
+        assert!(res
+            .extensions()
+            .get::<FollowedPolicy<Action>>()
+            .unwrap()
+            .0
+            .is_stop());
     }
 
     #[tokio::test]
     async fn limited() {
         let svc = ServiceBuilder::new()
-            .layer(FollowRedirectLayer::with_policy(Limited::new(10)))
+            .layer(FollowRedirectLayer::with_policy_extension(Limited::new(10)))
             .buffer(1)
             .service_fn(handle);
         let req = Request::builder()
@@ -600,6 +652,14 @@ mod tests {
             res.extensions().get::<RequestUri>().unwrap().0,
             "http://example.com/32"
         );
+        assert_eq!(
+            res.extensions()
+                .get::<FollowedPolicy<Limited>>()
+                .unwrap()
+                .0
+                .remaining,
+            0
+        );
     }
 
     /// A server with an endpoint `GET /{n}` which redirects to `/{n-1}` unless `n` equals zero,

tower-http/src/follow_redirect/policy/limited.rs

@@ -3,7 +3,8 @@ use super::{Action, Attempt, Policy};
 /// A redirection [`Policy`] that limits the number of successive redirections.
 #[derive(Clone, Copy, Debug)]
 pub struct Limited {
-    pub(crate) remaining: usize,
+    /// The number or possible redirections remaining.
+    pub remaining: usize,
 }
 
 impl Limited {

tower-http/src/service_ext.rs

@@ -160,7 +160,7 @@ pub trait ServiceExt {
     ) -> crate::follow_redirect::FollowRedirect<
         Self,
         crate::follow_redirect::policy::Standard,
-        crate::follow_redirect::PolicyExtension,
+        crate::follow_redirect::UriAndPolicyExtensions,
     >
     where
         Self: Sized,