Struct tower::balance::p2c::Balance[−][src]

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

This is supported on crate feature balance only.

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

Constructs a load balancer that uses operating system entropy.

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

Returns the number of endpoints currently tracked by the balancer.

Returns whether or not the balancer is empty.

Trait Implementations

Responses given by the service.

Errors produced by the service.

The future response value.

Auto Trait Implementations

Blanket Implementations

The type returned in the event of a conversion error.

The type returned in the event of a conversion error.

Struct tower::balance::p2c::Balance⎘[−][src]

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>, [src]

pub fn new(discover: D) -> Self[src]

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

pub fn len(&self) -> usize[src]

pub fn is_empty(&self) -> bool[src]

Trait Implementations

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

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

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>, [src]

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

type Error = BoxError

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

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

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

Auto Trait Implementations

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

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

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

impl<D, Req> Unpin for Balance<D, Req> where D: Unpin, Req: Unpin,

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

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

pub fn type_id(&self) -> TypeId[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

pub fn borrow(&self) -> &T[src]

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

pub fn borrow_mut(&mut self) -> &mut T[src]

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

impl<T> Instrument for T[src]

pub fn instrument(self, span: Span) -> Instrumented<Self>[src]

pub fn in_current_span(self) -> Instrumented<Self>[src]

impl<T, U> Into<U> for T where U: From<T>, [src]

pub fn into(self) -> U[src]

impl<T, Request> ServiceExt<Request> for T where T: Service<Request> + ?Sized, [src]

fn ready(&mut self) -> Ready<'_, Self, Request>ⓘNotable traits for Ready<'a, T, Request>impl<'a, T, Request> Future for Ready<'a, T, Request> where T: Service<Request>, type Output = Result<&'a mut T, T::Error>; where Self: Sized, [src]

Notable traits for Ready<'a, T, Request>

fn ready_and(&mut self) -> ReadyAnd<'_, Self, Request> where Self: Sized, [src]

fn ready_oneshot(self) -> ReadyOneshot<Self, Request>ⓘNotable traits for ReadyOneshot<T, Request>impl<T, Request> Future for ReadyOneshot<T, Request> where T: Service<Request>, type Output = Result<T, T::Error>; where Self: Sized, [src]

Notable traits for ReadyOneshot<T, Request>

fn oneshot(self, req: Request) -> Oneshot<Self, Request>ⓘNotable traits for Oneshot<S, Req>impl<S, Req> Future for Oneshot<S, Req> where S: Service<Req>, type Output = Result<S::Response, S::Error>; where Self: Sized, [src]

Notable traits for Oneshot<S, Req>

fn call_all<S>(self, reqs: S) -> CallAll<Self, S> where Self: Sized, Self::Error: Into<BoxError>, S: Stream<Item = Request>, [src]

fn and_then<F>(self, f: F) -> AndThen<Self, F> where Self: Sized, F: Clone, [src]

fn map_response<F, Response>(self, f: F) -> MapResponse<Self, F> where Self: Sized, F: FnOnce(Self::Response) -> Response + Clone, [src]

fn map_err<F, Error>(self, f: F) -> MapErr<Self, F> where Self: Sized, F: FnOnce(Self::Error) -> Error + Clone, [src]

fn map_result<F, Response, Error>(self, f: F) -> MapResult<Self, F> where Self: Sized, Error: From<Self::Error>, F: FnOnce(Result<Self::Response, Self::Error>) -> Result<Response, Error> + Clone, [src]

fn map_request<F, NewRequest>(self, f: F) -> MapRequest<Self, F> where Self: Sized, F: FnMut(NewRequest) -> Request + Clone, [src]

fn filter<F, NewRequest>(self, filter: F) -> Filter<Self, F> where Self: Sized, F: Predicate<NewRequest>, [src]

fn filter_async<F, NewRequest>(self, filter: F) -> AsyncFilter<Self, F> where Self: Sized, F: AsyncPredicate<NewRequest>, [src]

fn then<F, Response, Error, Fut>(self, f: F) -> Then<Self, F> where Self: Sized, Error: From<Self::Error>, F: FnOnce(Result<Self::Response, Self::Error>) -> Fut + Clone, Fut: Future<Output = Result<Response, Error>>, [src]

fn map_future<F, Fut, Response, Error>(self, f: F) -> MapFuture<Self, F> where Self: Sized, F: FnMut(Self::Future) -> Fut, Error: From<Self::Error>, Fut: Future<Output = Result<Response, Error>>, [src]

impl<T, U> TryFrom<U> for T where U: Into<T>, [src]

type Error = Infallible

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

impl<T, U> TryInto<U> for T where U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]

impl<V, T> VZip<V> for T where V: MultiLane<T>,

pub fn vzip(self) -> V

Struct tower::balance::p2c::Balance[−][src]

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

`pub fn new(discover: D) -> Self`[src]

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

`pub fn len(&self) -> usize`[src]

`pub fn is_empty(&self) -> bool`[src]

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

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

`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>,` [src]

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

`type Error = BoxError`

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

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

`fn call(&mut self, request: Req) -> Self::Future`[src]

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

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

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

`impl<D, Req> Unpin for Balance<D, Req> where D: Unpin, Req: Unpin,`

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

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T> Instrument for T`[src]

`pub fn instrument(self, span: Span) -> Instrumented<Self>`[src]

`pub fn in_current_span(self) -> Instrumented<Self>`[src]

`impl<T, U> Into<U> for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<T, Request> ServiceExt<Request> for T where T: Service<Request> + ?Sized,` [src]

`fn ready(&mut self) -> Ready<'_, Self, Request>ⓘNotable traits for Ready<'a, T, Request> impl<'a, T, Request> Future for Ready<'a, T, Request> where T: Service<Request>, type Output = Result<&'a mut T, T::Error>; where Self: Sized,` [src]

`fn ready_and(&mut self) -> ReadyAnd<'_, Self, Request> where Self: Sized,` [src]

`fn ready_oneshot(self) -> ReadyOneshot<Self, Request>ⓘNotable traits for ReadyOneshot<T, Request> impl<T, Request> Future for ReadyOneshot<T, Request> where T: Service<Request>, type Output = Result<T, T::Error>; where Self: Sized,` [src]

`fn oneshot(self, req: Request) -> Oneshot<Self, Request>ⓘNotable traits for Oneshot<S, Req> impl<S, Req> Future for Oneshot<S, Req> where S: Service<Req>, type Output = Result<S::Response, S::Error>; where Self: Sized,` [src]

`fn call_all<S>(self, reqs: S) -> CallAll<Self, S> where Self: Sized, Self::Error: Into<BoxError>, S: Stream<Item = Request>,` [src]

`fn and_then<F>(self, f: F) -> AndThen<Self, F> where Self: Sized, F: Clone,` [src]

`fn map_response<F, Response>(self, f: F) -> MapResponse<Self, F> where Self: Sized, F: FnOnce(Self::Response) -> Response + Clone,` [src]

`fn map_err<F, Error>(self, f: F) -> MapErr<Self, F> where Self: Sized, F: FnOnce(Self::Error) -> Error + Clone,` [src]

`fn map_result<F, Response, Error>(self, f: F) -> MapResult<Self, F> where Self: Sized, Error: From<Self::Error>, F: FnOnce(Result<Self::Response, Self::Error>) -> Result<Response, Error> + Clone,` [src]

`fn map_request<F, NewRequest>(self, f: F) -> MapRequest<Self, F> where Self: Sized, F: FnMut(NewRequest) -> Request + Clone,` [src]

`fn filter<F, NewRequest>(self, filter: F) -> Filter<Self, F> where Self: Sized, F: Predicate<NewRequest>,` [src]

`fn filter_async<F, NewRequest>(self, filter: F) -> AsyncFilter<Self, F> where Self: Sized, F: AsyncPredicate<NewRequest>,` [src]

`fn then<F, Response, Error, Fut>(self, f: F) -> Then<Self, F> where Self: Sized, Error: From<Self::Error>, F: FnOnce(Result<Self::Response, Self::Error>) -> Fut + Clone, Fut: Future<Output = Result<Response, Error>>,` [src]

`fn map_future<F, Fut, Response, Error>(self, f: F) -> MapFuture<Self, F> where Self: Sized, F: FnMut(Self::Future) -> Fut, Error: From<Self::Error>, Fut: Future<Output = Result<Response, Error>>,` [src]

`impl<T, U> TryFrom<U> for T where U: Into<T>,` [src]

`type Error = Infallible`

`pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

`impl<T, U> TryInto<U> for T where U: TryFrom<T>,` [src]

`type Error = <U as TryFrom<T>>::Error`

`pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

`impl<V, T> VZip<V> for T where V: MultiLane<T>,`

`pub fn vzip(self) -> V`