Struct ExecutorService 

pub struct ExecutorService<S, E> { /* private fields */ }

A service that delegates request processing to an executor.

Each request is spawned as a new task on the executor, allowing parallel processing of multiple requests.

Requirements

The inner service must implement Clone so that each spawned task can have its own instance. This is the standard pattern for Tower services that need to be shared across tasks.

Cancellation

When the response future is dropped, the spawned task continues to run to completion. This is intentional to avoid partial processing. If you need cancellation, consider wrapping with a timeout layer.

Implementations

impl<S, E> ExecutorService<S, E>

pub fn new(service: S, executor: E) -> Self

Creates a new executor service.

pub fn get_ref(&self) -> &S

Returns a reference to the inner service.

pub fn get_mut(&mut self) -> &mut S

Returns a mutable reference to the inner service.

pub fn into_inner(self) -> S

Consumes the service and returns the inner service.

Trait Implementations

impl<S: Clone, E: Clone> Clone for ExecutorService<S, E>

fn clone(&self) -> ExecutorService<S, E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S, E, Req> Service<Req> for ExecutorService<S, E>

where S: Service<Req> + Clone + Send + 'static, S::Future: Send, S::Response: Send + 'static, S::Error: Send + 'static, E: Executor, Req: Send + 'static,

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

Responses given by the service.

type Error = ExecutorError<<S as Service<Req>>::Error>

Errors produced by the service.

type Future = ExecutorFuture<<S as Service<Req>>::Response, <S as Service<Req>>::Error>

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.