Struct `Balance`

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

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>,`

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) -> usize: Returns the number of endpoints currently tracked by the balancer.
fn is_empty(&self) -> bool: Returns whether or not the balancer is empty.

Trait Implementations

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

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

`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 as Discover>::Service as Service<Req>>::Response;
type Error = Box<dyn Error + Sync + Send>;
type Future = MapErr<<<D as Discover>::Service as Service<Req>>::Future, fn(<<D as Discover>::Service as Service<Req>>::Error) -> Box<dyn Error + Sync + Send>>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
fn call(&mut self, request: Req) -> Self::Future

Auto Trait Implementations

`impl<D, Req> !Freeze for Balance<D, Req>`

`impl<D, Req> !RefUnwindSafe for Balance<D, Req>`

`impl<D, Req> !UnwindSafe for Balance<D, Req>`

`impl<D, Req> Send for Balance<D, Req> where D: Send, ReadyCache<<D as Discover>::Key, <D as Discover>::Service, Req>: Send, PhantomData<Req>: Send,`

`impl<D, Req> Sync for Balance<D, Req> where D: Sync, ReadyCache<<D as Discover>::Key, <D as Discover>::Service, Req>: Sync, PhantomData<Req>: Sync,`

`impl<D, Req> Unpin for Balance<D, Req> where D: Unpin, ReadyCache<<D as Discover>::Key, <D as Discover>::Service, Req>: Unpin, PhantomData<Req>: Unpin,`

`impl<D, Req> UnsafeUnpin for Balance<D, Req> where D: UnsafeUnpin, ReadyCache<<D as Discover>::Key, <D as Discover>::Service, Req>: UnsafeUnpin, PhantomData<Req>: UnsafeUnpin,`

Blanket Implementations

`impl<C, Target> MakeConnection<Target> for Balance<D, Req> where C: Service<Target>, <C as Service<Target>>::Response: AsyncRead + AsyncWrite,`

type Connection = <C as Service<Target>>::Response;
type Error = <C as Service<Target>>::Error;
type Future = <C as Service<Target>>::Future;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), <C as MakeConnection<Target>>::Error>>
fn make_connection(&mut self, target: Target) -> <C as MakeConnection<Target>>::Future

`impl<M, S, Target, Request> MakeService<Target, Request> for Balance<D, Req> where M: Service<Target, Response = S>, S: Service<Request>,`

type Response = <S as Service<Request>>::Response;
type Error = <S as Service<Request>>::Error;
type Service = S;
type MakeError = <M as Service<Target>>::Error;
type Future = <M as Service<Target>>::Future;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), <M as MakeService<Target, Request>>::MakeError>>
fn make_service(&mut self, target: Target) -> <M as MakeService<Target, Request>>::Future

`impl<T> Any for Balance<D, Req> where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for Balance<D, Req> where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for Balance<D, Req> where T: ?Sized,`

fn borrow_mut(&mut self) -> &mut T

`impl<T> From<T> for Balance<D, Req>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> Instrument for Balance<D, Req>`

`impl<T> WithSubscriber for Balance<D, Req>`

`impl<T, Request> ServiceExt<Request> for Balance<D, Req> where T: Service<Request> + ?Sized,`

`impl<T, U> Into for Balance<D, Req> where U: From<T>,`

fn into(self) -> U

Calls U::from(self).

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

`impl<T, U> TryFrom for Balance<D, Req> where U: Into<T>,`

type Error = never;
fn try_from(value: U) -> Result<T, never>

`impl<T, U> TryInto for Balance<D, Req> where U: TryFrom<T>,`

type Error = >::Error;
fn try_into(self) -> Result<U, >::Error>