Struct `MakeBalanceLayer`

pub struct MakeBalanceLayer<D, Req> { /* private fields */ }

Construct load balancers (Balance) over dynamic service sets (Discover) produced by the "inner" service in response to requests coming from the "outer" service.

This construction may seem a little odd at first glance. This is not a layer that takes requests and produces responses in the traditional sense. Instead, it is more like MakeService in that it takes service descriptors (see Target on MakeService) and produces services. Since Balance spreads requests across a set of services, the inner service should produce a Discover, not just a single Service, given a service descriptor.

See the module-level documentation for details on load balancing.

Implementations

`impl<D, Req> MakeBalanceLayer<D, Req>`

const fn new() -> Self: Build balancers using operating system entropy.

Trait Implementations

`impl<D, Req> Clone for MakeBalanceLayer<D, Req>`

fn clone(&self) -> Self

`impl<D, Req> Debug for MakeBalanceLayer<D, Req>`

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

`impl<D, Req> Default for MakeBalanceLayer<D, Req>`

fn default() -> Self

`impl<S, Req> Layer<S> for MakeBalanceLayer<S, Req>`

type Service = MakeBalance<S, Req>;
fn layer(&self, make_discover: S) -> Self::Service

Auto Trait Implementations

`impl<D, Req> Freeze for MakeBalanceLayer<D, Req> where PhantomData<fn(D, Req)>: Freeze,`

`impl<D, Req> RefUnwindSafe for MakeBalanceLayer<D, Req> where PhantomData<fn(D, Req)>: RefUnwindSafe,`

`impl<D, Req> Send for MakeBalanceLayer<D, Req> where PhantomData<fn(D, Req)>: Send,`

`impl<D, Req> Sync for MakeBalanceLayer<D, Req> where PhantomData<fn(D, Req)>: Sync,`

`impl<D, Req> Unpin for MakeBalanceLayer<D, Req> where PhantomData<fn(D, Req)>: Unpin,`

`impl<D, Req> UnsafeUnpin for MakeBalanceLayer<D, Req> where PhantomData<fn(D, Req)>: UnsafeUnpin,`

`impl<D, Req> UnwindSafe for MakeBalanceLayer<D, Req> where PhantomData<fn(D, Req)>: UnwindSafe,`

Blanket Implementations

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

`impl<T> CloneToUninit for MakeBalanceLayer<D, Req> where T: Clone,`

unsafe fn clone_to_uninit(&self, dest: *mut u8)

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

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

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

`impl<T> ToOwned for MakeBalanceLayer<D, Req> where T: Clone,`

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

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

`impl<T, U> Into for MakeBalanceLayer<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 MakeBalanceLayer<D, Req> where U: Into<T>,`

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

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

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