refactor(stack/switch_ready): use Either<A, B> future (#3739)

this commit makes a noöp change to the `SwitchReady<A, B>` machinery
provided by our `linkerd-stack` library.

this commit is a small refactor that is intended to pave the way for an
impending upgrade to tower v0.5, which notably includes breaking changes
to the `tower::util::Either<A, B>` service.

as of tower v0.5, by way of tower-rs/tower#637,
the `Either<A, B>` service is no longer itself a `Future`. so, we can
instead use the future provided by `futures`.

for more information, see:
* linkerd/linkerd2#8733
* #3504
* https://github.com/linkerd/linkerd2-proxy/pull/3504/files#r1988082658
* tower-rs/tower#637

Signed-off-by: katelyn martin <[email protected]>

Author: cratelyn

linkerd/stack/src/switch_ready.rs

@@ -1,12 +1,13 @@
 use super::NewService;
+use futures::future::Either;
 use linkerd_error::Error;
 use std::{
     future::Future,
     pin::Pin,
     task::{Context, Poll},
 };
 use tokio::time;
-use tower::{spawn_ready::SpawnReady, util::Either};
+use tower::spawn_ready::SpawnReady;
 use tracing::{debug, trace};
 
 /// A service which falls back to a secondary service if the primary service
@@ -100,12 +101,13 @@ where
     Req: 'static,
     A: tower::Service<Req> + Send + 'static,
     A::Error: Into<Error>,
-    B: tower::Service<Req, Response = A::Response>,
+    B: tower::Service<Req, Response = A::Response, Error = Error>,
     B::Error: Into<Error>,
 {
     type Response = A::Response;
     type Error = Error;
-    type Future = Either<<SpawnReady<A> as tower::Service<Req>>::Future, B::Future>;
+    type Future =
+        Either<<SpawnReady<A> as tower::Service<Req>>::Future, <B as tower::Service<Req>>::Future>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         loop {
@@ -165,8 +167,8 @@ where
     fn call(&mut self, req: Req) -> Self::Future {
         trace!(state = ?self.state, "SwitchReady::call");
         match self.state {
-            State::Primary => Either::A(self.primary.call(req)),
-            State::Secondary => Either::B(self.secondary.call(req)),
+            State::Primary => Either::Left(self.primary.call(req)),
+            State::Secondary => Either::Right(self.secondary.call(req)),
             State::Waiting => panic!("called before ready!"),
         }
     }