[][src]Struct tower::builder::ServiceBuilder

pub struct ServiceBuilder<L> { /* fields omitted */ }

Declaratively construct Service values.

ServiceBuilder provides a builder-like interface for composing layers to be applied to a Service.


A Service is a trait representing an asynchronous function of a request to a response. It is similar to async fn(Request) -> Result<Response, Error>.

A Service is typically bound to a single transport, such as a TCP connection. It defines how all inbound or outbound requests are handled by that connection.


The order in which layers are added impacts how requests are handled. Layers that are added first will be called with the request first. The argument to service will be last to see the request.


In the above example, the buffer layer receives the request first followed by concurrency_limit. buffer enables up to 100 request to be in-flight on top of the requests that have already been forwarded to the next layer. Combined with concurrency_limit, this allows up to 110 requests to be in-flight.


The above example is similar, but the order of layers is reversed. Now, concurrency_limit applies first and only allows 10 requests to be in-flight total.


A Service stack with a single layer:


A Service stack with multiple layers that contain rate limiting, in-flight request limits, and a channel-backed, clonable Service:

    .rate_limit(5, Duration::from_secs(1))


impl ServiceBuilder<Identity>[src]

pub fn new() -> Self[src]

Create a new ServiceBuilder.

impl<L> ServiceBuilder<L>[src]

pub fn layer<T>(self, layer: T) -> ServiceBuilder<Stack<T, L>>[src]

Add a new layer T into the ServiceBuilder.

pub fn buffer<Request>(
    bound: usize
) -> ServiceBuilder<Stack<BufferLayer<Request>, L>>

Buffer requests when when the next layer is out of capacity.

pub fn concurrency_limit(
    max: usize
) -> ServiceBuilder<Stack<ConcurrencyLimitLayer, L>>

Limit the max number of in-flight requests.

A request is in-flight from the time the request is received until the response future completes. This includes the time spent in the next layers.

pub fn load_shed(self) -> ServiceBuilder<Stack<LoadShedLayer, L>>[src]

Drop requests when the next layer is unable to respond to requests.

Usually, when a layer or service does not have capacity to process a request (i.e., poll_ready returns NotReady), the caller waits until capacity becomes available.

load_shed immediately responds with an error when the next layer is out of capacity.

pub fn rate_limit(
    num: u64,
    per: Duration
) -> ServiceBuilder<Stack<RateLimitLayer, L>>

Limit requests to at most num per the given duration

pub fn retry<P>(self, policy: P) -> ServiceBuilder<Stack<RetryLayer<P>, L>>[src]

Retry failed requests.

policy must implement Policy.

pub fn timeout(
    timeout: Duration
) -> ServiceBuilder<Stack<TimeoutLayer, L>>

Fail requests that take longer than timeout.

If the next layer takes more than timeout to respond to a request, processing is terminated and an error is returned.

pub fn into_inner(self) -> L[src]

Obtains the underlying Layer implementation.

pub fn service<S>(self, service: S) -> L::Service where
    L: Layer<S>, 

Wrap the service S with the layers.

Trait Implementations

impl<L: Clone> Clone for ServiceBuilder<L>[src]

impl<L: Debug> Debug for ServiceBuilder<L>[src]

Auto Trait Implementations

impl<L> RefUnwindSafe for ServiceBuilder<L> where
    L: RefUnwindSafe

impl<L> Send for ServiceBuilder<L> where
    L: Send

impl<L> Sync for ServiceBuilder<L> where
    L: Sync

impl<L> Unpin for ServiceBuilder<L> where
    L: Unpin

impl<L> UnwindSafe for ServiceBuilder<L> where
    L: UnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized

impl<T> Borrow<T> for T where
    T: ?Sized

impl<T> BorrowMut<T> for T where
    T: ?Sized

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

impl<T, U> Into<U> for T where
    U: From<T>, 

impl<T> ToOwned for T where
    T: Clone

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 

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

The type returned in the event of a conversion error.