Merge remote-tracking branch 'origin/master' into non-static

tower-rs · Mar 18, 2024 · 2449c10 · 2449c10
2 parents a8e4fe1 + 39adf5c
commit 2449c10
Show file tree

Hide file tree

Showing 2 changed files with 3 additions and 72 deletions.
diff --git a/guides/building-a-middleware-from-scratch.md b/guides/building-a-middleware-from-scratch.md
@@ -74,7 +74,7 @@ where
     type Future = S::Future;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        // Our middleware doesn't care about backpressure so its ready as long
+        // Our middleware doesn't care about backpressure, so it's ready as long
         // as the inner service is ready.
         self.inner.poll_ready(cx)
     }
@@ -192,9 +192,9 @@ where
 
 Ideally we want to write something like this:
 
-1. First poll `self.response_future` and if its ready return the response or error it
+1. First poll `self.response_future`, and if it's ready, return the response or error it
    resolved to.
-2. Otherwise poll `self.sleep` and if its ready return an error.
+2. Otherwise, poll `self.sleep`, and if it's ready, return an error.
 3. If neither future is ready return `Poll::Pending`.
 
 We might try:

diff --git a/tower/src/balance/p2c/service.rs b/tower/src/balance/p2c/service.rs
@@ -5,16 +5,13 @@ use crate::ready_cache::{error::Failed, ReadyCache};
 use crate::util::rng::{sample_floyd2, HasherRng, Rng};
 use futures_core::ready;
 use futures_util::future::{self, TryFutureExt};
-use pin_project_lite::pin_project;
 use std::hash::Hash;
 use std::marker::PhantomData;
 use std::{
     fmt,
-    future::Future,
     pin::Pin,
     task::{Context, Poll},
 };
-use tokio::sync::oneshot;
 use tower_service::Service;
 use tracing::{debug, trace};
 
@@ -58,25 +55,6 @@ where
     }
 }
 
-pin_project! {
-    /// A Future that becomes satisfied when an `S`-typed service is ready.
-    ///
-    /// May fail due to cancelation, i.e., if [`Discover`] removes the service from the service set.
-    struct UnreadyService<K, S, Req> {
-        key: Option<K>,
-        #[pin]
-        cancel: oneshot::Receiver<()>,
-        service: Option<S>,
-
-        _req: PhantomData<Req>,
-    }
-}
-
-enum Error<E> {
-    Inner(E),
-    Canceled,
-}
-
 impl<D, Req> Balance<D, Req>
 where
     D: Discover,
@@ -279,50 +257,3 @@ where
             .map_err(Into::into)
     }
 }
-
-impl<K, S: Service<Req>, Req> Future for UnreadyService<K, S, Req> {
-    type Output = Result<(K, S), (K, Error<S::Error>)>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
-
-        if let Poll::Ready(Ok(())) = this.cancel.poll(cx) {
-            let key = this.key.take().expect("polled after ready");
-            return Poll::Ready(Err((key, Error::Canceled)));
-        }
-
-        let res = ready!(this
-            .service
-            .as_mut()
-            .expect("poll after ready")
-            .poll_ready(cx));
-
-        let key = this.key.take().expect("polled after ready");
-        let svc = this.service.take().expect("polled after ready");
-
-        match res {
-            Ok(()) => Poll::Ready(Ok((key, svc))),
-            Err(e) => Poll::Ready(Err((key, Error::Inner(e)))),
-        }
-    }
-}
-
-impl<K, S, Req> fmt::Debug for UnreadyService<K, S, Req>
-where
-    K: fmt::Debug,
-    S: fmt::Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let Self {
-            key,
-            cancel,
-            service,
-            _req,
-        } = self;
-        f.debug_struct("UnreadyService")
-            .field("key", key)
-            .field("cancel", cancel)
-            .field("service", service)
-            .finish()
-    }
-}