Struct tower::steer::Steer

pub struct Steer<S, F, Req> { /* fields omitted */ }

This is supported on crate feature steer only.

Steer manages a list of Services which all handle the same type of request.

An example use case is a sharded service. It accepts new requests, then:

1. Determines, via the provided Picker, which Service the request coresponds to.
2. Waits (in Service::poll_ready) for all services to be ready.
3. 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>

pub fn new(services: impl IntoIterator<Item = S>, router: F) -> Self

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, 

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Debug, F: Debug, Req: Debug> Debug for Steer<S, F, Req>

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

Formats the value using the given formatter.

impl<S, Req, F> Service<Req> for Steer<S, F, Req> where
    S: Service<Req>,
    F: Picker<S, Req>, 

type Response = S::Response

Responses given by the service.

type Error = S::Error

Errors produced by the service.

type Future = S::Future

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, req: Req) -> Self::Future

Process the request and return the response asynchronously.