Struct tower::util::FutureService

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

Available on crate feature util only.

A type that implements Service for a Future that produces a Service.

See future_service for more details.

Implementations

impl<F, S> FutureService<F, S>

pub const fn new(future: F) -> Self

Returns a new FutureService for the given future.

A FutureService allows you to treat a future that resolves to a service as a service. This can be useful for services that are created asynchronously.

Example

use tower::{service_fn, Service, ServiceExt};
use tower::util::FutureService;
use std::convert::Infallible;

// A future which outputs a type implementing `Service`.
let future_of_a_service = async {
    let svc = service_fn(|_req: ()| async { Ok::<_, Infallible>("ok") });
    Ok::<_, Infallible>(svc)
};

// Wrap the future with a `FutureService`, allowing it to be used
// as a service without awaiting the future's completion:
let mut svc = FutureService::new(Box::pin(future_of_a_service));

// Now, when we wait for the service to become ready, it will
// drive the future to completion internally.
let svc = svc.ready().await.unwrap();
let res = svc.call(()).await.unwrap();

Regarding the Unpin bound

The Unpin bound on F is necessary because the future will be polled in Service::poll_ready which doesn’t have a pinned receiver (it takes &mut self and not self: Pin<&mut Self>). So we cannot put the future into a Pin without requiring Unpin.

This will most likely come up if you’re calling future_service with an async block. In that case you can use Box::pin(async { ... }) as shown in the example.

Trait Implementations

impl<F: Clone, S: Clone> Clone for FutureService<F, S>

fn clone(&self) -> FutureService<F, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F, S> Debug for FutureService<F, S>

where S: Debug,

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

Formats the value using the given formatter.

impl<F, S, R, E> Service<R> for FutureService<F, S>

where F: Future<Output = Result<S, E>> + Unpin, S: Service<R, Error = E>,

type Response = <S as Service<R>>::Response

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = <S as Service<R>>::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: R) -> Self::Future

Process the request and return the response asynchronously.