Struct `Balance`

struct Balance<D, Req> { ... }
where
    D: Discover,
    <D as >::Key: Hash

Efficiently distributes requests across an arbitrary number of services.

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

fn new(discover: D) -> Self: Constructs a load balancer that uses operating system entropy.
fn from_rng<R: Rng + Send + Sync + 'static>(discover: D, rng: R) -> Self: Constructs a load balancer seeded with the provided random number generator.
fn len(self: &Self) -> usize: Returns the number of endpoints currently tracked by the balancer.
fn is_empty(self: &Self) -> bool: Returns whether or not the balancer is empty.

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

fn poll_ready(self: &mut Self, cx: &mut Context<'_>) -> Poll<Result<(), <M as MakeService<Target, Request>>::MakeError>>
fn make_service(self: &mut Self, target: Target) -> <M as MakeService<Target, Request>>::Future

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.