tower/balance/p2c/
make.rs

1use super::Balance;
2use crate::discover::Discover;
3use pin_project_lite::pin_project;
4use std::hash::Hash;
5use std::marker::PhantomData;
6use std::{
7    fmt,
8    future::Future,
9    pin::Pin,
10    task::{ready, Context, Poll},
11};
12use tower_service::Service;
13
14/// Constructs load balancers over dynamic service sets produced by a wrapped "inner" service.
15///
16/// This is effectively an implementation of [`MakeService`] except that it forwards the service
17/// descriptors (`Target`) to an inner service (`S`), and expects that service to produce a
18/// service set in the form of a [`Discover`]. It then wraps the service set in a [`Balance`]
19/// before returning it as the "made" service.
20///
21/// See the [module-level documentation](crate::balance) for details on load balancing.
22///
23/// [`MakeService`]: crate::MakeService
24/// [`Discover`]: crate::discover::Discover
25/// [`Balance`]: crate::balance::p2c::Balance
26pub struct MakeBalance<S, Req> {
27    inner: S,
28    _marker: PhantomData<fn(Req)>,
29}
30
31pin_project! {
32    /// A [`Balance`] in the making.
33    ///
34    /// [`Balance`]: crate::balance::p2c::Balance
35    pub struct MakeFuture<F, Req> {
36        #[pin]
37        inner: F,
38        _marker: PhantomData<fn(Req)>,
39    }
40}
41
42impl<S, Req> MakeBalance<S, Req> {
43    /// Build balancers using operating system entropy.
44    pub const fn new(make_discover: S) -> Self {
45        Self {
46            inner: make_discover,
47            _marker: PhantomData,
48        }
49    }
50}
51
52impl<S, Req> Clone for MakeBalance<S, Req>
53where
54    S: Clone,
55{
56    fn clone(&self) -> Self {
57        Self {
58            inner: self.inner.clone(),
59            _marker: PhantomData,
60        }
61    }
62}
63
64impl<S, Target, Req> Service<Target> for MakeBalance<S, Req>
65where
66    S: Service<Target>,
67    S::Response: Discover,
68    <S::Response as Discover>::Key: Hash,
69    <S::Response as Discover>::Service: Service<Req>,
70    <<S::Response as Discover>::Service as Service<Req>>::Error: Into<crate::BoxError>,
71{
72    type Response = Balance<S::Response, Req>;
73    type Error = S::Error;
74    type Future = MakeFuture<S::Future, Req>;
75
76    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
77        self.inner.poll_ready(cx)
78    }
79
80    fn call(&mut self, target: Target) -> Self::Future {
81        MakeFuture {
82            inner: self.inner.call(target),
83            _marker: PhantomData,
84        }
85    }
86}
87
88impl<S, Req> fmt::Debug for MakeBalance<S, Req>
89where
90    S: fmt::Debug,
91{
92    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
93        let Self { inner, _marker } = self;
94        f.debug_struct("MakeBalance").field("inner", inner).finish()
95    }
96}
97
98impl<F, T, E, Req> Future for MakeFuture<F, Req>
99where
100    F: Future<Output = Result<T, E>>,
101    T: Discover,
102    <T as Discover>::Key: Hash,
103    <T as Discover>::Service: Service<Req>,
104    <<T as Discover>::Service as Service<Req>>::Error: Into<crate::BoxError>,
105{
106    type Output = Result<Balance<T, Req>, E>;
107
108    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
109        let this = self.project();
110        let inner = ready!(this.inner.poll(cx))?;
111        let svc = Balance::new(inner);
112        Poll::Ready(Ok(svc))
113    }
114}
115
116impl<F, Req> fmt::Debug for MakeFuture<F, Req>
117where
118    F: fmt::Debug,
119{
120    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
121        let Self { inner, _marker } = self;
122        f.debug_struct("MakeFuture").field("inner", inner).finish()
123    }
124}
tower/balance/p2c/make.rs

tower/balance/p2c/
make.rs
