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.

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.

Order

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.

ServiceBuilder::new()
    .buffer(100)
    .concurrency_limit(10)
    .service(svc)

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.

ServiceBuilder::new()
    .concurrency_limit(10)
    .buffer(100)
    .service(svc)

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.

Examples

A Service stack with a single layer:

ServiceBuilder::new()
    .concurrency_limit(5)
    .service(svc);

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

ServiceBuilder::new()
    .buffer(5)
    .concurrency_limit(5)
    .rate_limit(5, Duration::from_secs(1))
    .service(svc);

Implementations

impl ServiceBuilder<Identity>

pub fn new() -> Self

Create a new ServiceBuilder.

impl<L> ServiceBuilder<L>

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

Add a new layer T into the ServiceBuilder.

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

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

pub fn concurrency_limit(
    self,
    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>>

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(
    self,
    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>>

Retry failed requests.

policy must implement Policy.

pub fn timeout(
    self,
    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

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>

fn clone(&self) -> ServiceBuilder<L>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L: Debug> Debug for ServiceBuilder<L>

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

Formats the value using the given formatter.