Struct tower::balance::p2c::Balance

pub struct Balance<D, Req> where
    D: Discover,
    D::Key: Hash,  { /* fields omitted */ }

Efficiently distributes requests across an arbitrary number of services.

See the module-level documentation for details.

Note that Balance requires that the Discover you use is Unpin in order to implement Service. This is because it needs to be accessed from Service::poll_ready, which takes &mut self. You can achieve this easily by wrapping your Discover in Box::pin before you construct the Balance instance. For more details, see #319.

Implementations

impl<D, Req> Balance<D, Req> where
    D: Discover,
    D::Key: Hash,
    D::Service: Service<Req>,
    <D::Service as Service<Req>>::Error: Into<BoxError>, 

pub fn new(discover: D) -> Self

Constructs a load balancer that uses operating system entropy.

pub fn from_rng<R: Rng>(discover: D, rng: R) -> Result<Self, Error>

Constructs a load balancer seeded with the provided random number generator.

pub fn len(&self) -> usize

Returns the number of endpoints currently tracked by the balancer.

pub fn is_empty(&self) -> bool

Returns whether or not the balancer is empty.

Trait Implementations

impl<D: Discover, Req> Debug for Balance<D, Req> where
    D: Debug,
    D::Key: Hash + Debug,
    D::Service: Debug,
    Req: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<D, Req> Service<Req> for Balance<D, Req> where
    D: Discover + Unpin,
    D::Key: Hash + Clone,
    D::Error: Into<BoxError>,
    D::Service: Service<Req> + Load,
    <D::Service as Load>::Metric: Debug,
    <D::Service as Service<Req>>::Error: Into<BoxError>, 

type Response = <D::Service as Service<Req>>::Response

Responses given by the service.

type Error = BoxError

Errors produced by the service.

type Future = MapErr<<D::Service as Service<Req>>::Future, fn(_: <D::Service as Service<Req>>::Error) -> BoxError>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, request: Req) -> Self::Future

Process the request and return the response asynchronously.