Struct tower::steer::Steer [−][src]
steer
only.Steer
manages a list of Service
s which all handle the same type of request.
An example use case is a sharded service. It accepts new requests, then:
- Determines, via the provided
Picker
, whichService
the request coresponds to. - Waits (in
Service::poll_ready
) for all services to be ready. - Calls the correct
Service
with the request, and returns a future corresponding to the call.
Note that Steer
must wait for all services to be ready since it can’t know ahead of time
which Service
the next message will arrive for, and is unwilling to buffer items
indefinitely. This will cause head-of-line blocking unless paired with a Service
that does
buffer items indefinitely, and thus always returns Poll::Ready
. For example, wrapping each
component service with a Buffer
with a high enough limit (the maximum number of concurrent
requests) will prevent head-of-line blocking in Steer
.
Implementations
impl<S, F, Req> Steer<S, F, Req>
[src]
pub fn new(services: impl IntoIterator<Item = S>, router: F) -> Self
[src]
Make a new Steer
with a list of Service
’s and a Picker
.
Note: the order of the Service
’s is significant for Picker::pick
’s return value.
Trait Implementations
impl<S, F, Req> Clone for Steer<S, F, Req> where
S: Clone,
F: Clone,
[src]
S: Clone,
F: Clone,
fn clone(&self) -> Self
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<S: Debug, F: Debug, Req: Debug> Debug for Steer<S, F, Req>
[src]
impl<S, Req, F> Service<Req> for Steer<S, F, Req> where
S: Service<Req>,
F: Picker<S, Req>,
[src]
S: Service<Req>,
F: Picker<S, Req>,
Auto Trait Implementations
impl<S, F, Req> RefUnwindSafe for Steer<S, F, Req> where
F: RefUnwindSafe,
Req: RefUnwindSafe,
S: RefUnwindSafe,
F: RefUnwindSafe,
Req: RefUnwindSafe,
S: RefUnwindSafe,
impl<S, F, Req> Send for Steer<S, F, Req> where
F: Send,
Req: Send,
S: Send,
F: Send,
Req: Send,
S: Send,
impl<S, F, Req> Sync for Steer<S, F, Req> where
F: Sync,
Req: Sync,
S: Sync,
F: Sync,
Req: Sync,
S: Sync,
impl<S, F, Req> Unpin for Steer<S, F, Req> where
F: Unpin,
Req: Unpin,
S: Unpin,
F: Unpin,
Req: Unpin,
S: Unpin,
impl<S, F, Req> UnwindSafe for Steer<S, F, Req> where
F: UnwindSafe,
Req: UnwindSafe,
S: UnwindSafe,
F: UnwindSafe,
Req: UnwindSafe,
S: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for 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]
U: From<T>,
impl<T, Request> ServiceExt<Request> for T where
T: Service<Request> + ?Sized,
[src]
T: Service<Request> + ?Sized,
fn ready(&mut self) -> Ready<'_, Self, Request>ⓘ where
Self: Sized,
[src]
Self: Sized,
fn ready_and(&mut self) -> ReadyAnd<'_, Self, Request> where
Self: Sized,
[src]
Self: Sized,
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>
impl<T, Request> Future for ReadyOneshot<T, Request> where
T: Service<Request>, type Output = Result<T, T::Error>;
Self: Sized,
fn oneshot(self, req: Request) -> Oneshot<Self, Request>ⓘ where
Self: Sized,
[src]
Self: Sized,
fn call_all<S>(self, reqs: S) -> CallAll<Self, S> where
Self: Sized,
Self::Error: Into<BoxError>,
S: Stream<Item = Request>,
[src]
Self: Sized,
Self::Error: Into<BoxError>,
S: Stream<Item = Request>,
fn and_then<F>(self, f: F) -> AndThen<Self, F> where
Self: Sized,
F: Clone,
[src]
Self: Sized,
F: Clone,
fn map_response<F, Response>(self, f: F) -> MapResponse<Self, F> where
Self: Sized,
F: FnOnce(Self::Response) -> Response + Clone,
[src]
Self: Sized,
F: FnOnce(Self::Response) -> Response + Clone,
fn map_err<F, Error>(self, f: F) -> MapErr<Self, F> where
Self: Sized,
F: FnOnce(Self::Error) -> Error + Clone,
[src]
Self: Sized,
F: FnOnce(Self::Error) -> Error + Clone,
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]
Self: Sized,
Error: From<Self::Error>,
F: FnOnce(Result<Self::Response, Self::Error>) -> Result<Response, Error> + Clone,
fn map_request<F, NewRequest>(self, f: F) -> MapRequest<Self, F> where
Self: Sized,
F: FnMut(NewRequest) -> Request + Clone,
[src]
Self: Sized,
F: FnMut(NewRequest) -> Request + Clone,
fn filter<F, NewRequest>(self, filter: F) -> Filter<Self, F> where
Self: Sized,
F: Predicate<NewRequest>,
[src]
Self: Sized,
F: Predicate<NewRequest>,
fn filter_async<F, NewRequest>(self, filter: F) -> AsyncFilter<Self, F> where
Self: Sized,
F: AsyncPredicate<NewRequest>,
[src]
Self: Sized,
F: AsyncPredicate<NewRequest>,
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]
Self: Sized,
Error: From<Self::Error>,
F: FnOnce(Result<Self::Response, Self::Error>) -> Fut + Clone,
Fut: Future<Output = Result<Response, Error>>,
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]
Self: Sized,
F: FnMut(Self::Future) -> Fut,
Error: From<Self::Error>,
Fut: Future<Output = Result<Response, Error>>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
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]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion 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>,
V: MultiLane<T>,