Struct Steer

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

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 corresponds 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>

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

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

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

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

type Response = <S as Service<Req>>::Response;
type Error = <S as Service<Req>>::Error;
type Future = <S as Service<Req>>::Future;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
fn call(&mut self, req: Req) -> Self::Future

Auto Trait Implementations

impl<S, F, Req> Freeze for Steer<S, F, Req> where F: Freeze, Vec<S>: Freeze, PhantomData<Req>: Freeze,

impl<S, F, Req> RefUnwindSafe for Steer<S, F, Req> where F: RefUnwindSafe, Vec<S>: RefUnwindSafe, PhantomData<Req>: RefUnwindSafe,

impl<S, F, Req> Send for Steer<S, F, Req> where F: Send, Vec<S>: Send, PhantomData<Req>: Send,

impl<S, F, Req> Sync for Steer<S, F, Req> where F: Sync, Vec<S>: Sync, PhantomData<Req>: Sync,

impl<S, F, Req> Unpin for Steer<S, F, Req> where F: Unpin, Vec<S>: Unpin, PhantomData<Req>: Unpin,

impl<S, F, Req> UnsafeUnpin for Steer<S, F, Req> where F: UnsafeUnpin, Vec<S>: UnsafeUnpin, PhantomData<Req>: UnsafeUnpin,

impl<S, F, Req> UnwindSafe for Steer<S, F, Req> where F: UnwindSafe, Vec<S>: UnwindSafe, PhantomData<Req>: UnwindSafe,

Blanket Implementations

impl<C, Target> MakeConnection<Target> for Steer<S, F, 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 Steer<S, F, 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 Steer<S, F, Req> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Steer<S, F, Req> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Steer<S, F, Req> where T: ?Sized,

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

impl<T> CloneToUninit for Steer<S, F, Req> where T: Clone,

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

impl<T> From<T> for Steer<S, F, Req>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Instrument for Steer<S, F, Req>

impl<T> ToOwned for Steer<S, F, Req> where T: Clone,

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

impl<T> WithSubscriber for Steer<S, F, Req>

impl<T, Request> ServiceExt<Request> for Steer<S, F, Req> where T: Service<Request> + ?Sized,

impl<T, U> Into<U> for Steer<S, F, 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<U> for Steer<S, F, Req> where U: Into<T>,

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

impl<T, U> TryInto<U> for Steer<S, F, Req> where U: TryFrom<T>,

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