Struct tower_balance::p2c::Balance

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

Distributes requests across inner services using the Power of Two Choices.

As described in the Finagle Guide:

The algorithm randomly picks two services from the set of ready endpoints and selects the least loaded of the two. By repeatedly using this strategy, we can expect a manageable upper bound on the maximum load of any server.

The maximum load variance between any two servers is bound by ln(ln(n)) where n is the number of servers in the cluster.

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.

Methods

impl<D, Req> Balance<D, Req> where
    D: Discover,
    D::Service: Service<Req>,
    <D::Service as Service<Req>>::Error: Into<Box<dyn Error + Send + Sync>>, 

pub fn new(discover: D, rng: SmallRng) -> Self

Initializes a P2C load balancer from the provided randomization source.

pub fn from_entropy(discover: D) -> Self

Initializes a P2C load balancer from the OS's entropy source.

pub fn len(&self) -> usize

Returns the number of endpoints currently tracked by the balancer.

Trait Implementations

impl<D: Discover, Req> Debug for Balance<D, Req> where
    D: Debug,
    D::Key: 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: Clone,
    D::Error: Into<Box<dyn Error + Send + Sync>>,
    D::Service: Service<Req> + Load,
    <D::Service as Load>::Metric: Debug,
    <D::Service as Service<Req>>::Error: Into<Box<dyn Error + Send + Sync>>, 

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

Responses given by the service.

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.

type Future = MapErr<<D::Service as Service<Req>>::Future, fn(_: <D::Service as Service<Req>>::Error) -> Box<dyn Error + Send + Sync>>

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.