Trait actix_web::dev::Service[−][src]

pub trait Service<Req> {
    type Response;
    type Error;
    type Future: Future;
    pub fn poll_ready(
        &self, 
        ctx: &mut Context<'_>
    ) -> Poll<Result<(), Self::Error>>;

    pub fn call(&self, req: Req) -> Self::Future;
}

An asynchronous operation from Request to a Response.

The Service trait models a request/response interaction, receiving requests and returning replies. You can think about a service as a function with one argument that returns some result asynchronously. Conceptually, the operation looks like this:

ⓘ
async fn(Request) -> Result<Response, Err>

The Service trait just generalizes this form where each parameter is described as an associated type on the trait. Services can also have mutable state that influence computation.

Service provides a symmetric and uniform API; the same abstractions can be used to represent both clients and servers. Services describe only transformation operations which encourage simple API surfaces. This leads to simpler design of each service, improves test-ability and makes composition easier.

ⓘ
struct MyService;

impl Service for MyService {
     type Request = u8;
     type Response = u64;
     type Error = MyError;
     type Future = Pin<Box<Future<Output=Result<Self::Response, Self::Error>>>>;

     fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { ... }

     fn call(&self, req: Self::Request) -> Self::Future { ... }
}

Sometimes it is not necessary to implement the Service trait. For example, the above service could be rewritten as a simple function and passed to fn_service.

ⓘ
async fn my_service(req: u8) -> Result<u64, MyError>;

Associated Types

type Response[src]

Responses given by the service.

type Error[src]

Errors produced by the service when polling readiness or executing call.

type Future: Future[src]

The future response value.

Loading content...

Required methods

pub fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>[src]

Returns Ready when the service is able to process requests.

If the service is at capacity, then Pending is returned and the task is notified when the service becomes ready again. This function is expected to be called while on a task.

This is a best effort implementation. False positives are permitted. It is permitted for the service to return Ready from a poll_ready call and the next invocation of call results in an error.

Notes

  1. .poll_ready() might be called on different task from actual service call.
  2. In case of chained services, .poll_ready() get called for all services at once.

pub fn call(&self, req: Req) -> Self::Future[src]

Process the request and return the response asynchronously.

This function is expected to be callable off task. As such, implementations should take care to not call poll_ready. If the service is at capacity and the request is unable to be handled, the returned Future should resolve to an error.

Calling call without calling poll_ready is permitted. The implementation must be resilient to this fact.

Loading content...

Implementations on Foreign Types

impl<T, S, B, X, U> Service<(T, Option<SocketAddr>)> for H1ServiceHandler<T, S, B, X, U> where
    B: MessageBody,
    T: AsyncRead + AsyncWrite + Unpin,
    U: Service<(Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>, Framed<T, Codec>), Response = ()>,
    S: Service<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>,
    X: Service<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>, Response = Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>,
    <S as Service<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::Error: Into<Error>,
    <S as Service<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::Response: Into<Response<B>>,
    <X as Service<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::Error: Into<Error>,
    <U as Service<(Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>, Framed<T, Codec>)>>::Error: Display,
    <U as Service<(Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>, Framed<T, Codec>)>>::Error: Into<Error>, [src]

type Response = ()

type Error = DispatchError

type Future = Dispatcher<T, S, B, X, U>

impl Service<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>> for ExpectHandler[src]

type Response = Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>

type Error = Error

type Future = Ready<Result<<ExpectHandler as Service<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::Response, <ExpectHandler as Service<Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>>>::Error>>

impl<T> Service<(Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>, Framed<T, Codec>)> for UpgradeHandler[src]

type Response = ()

type Error = Error

type Future = Ready<Result<<UpgradeHandler as Service<(Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>, Framed<T, Codec>)>>::Response, <UpgradeHandler as Service<(Request<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>, Framed<T, Codec>)>>::Error>>

impl<'a, S, Req> Service<Req> for &'a mut S where
    S: Service<Req> + 'a, [src]

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

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

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

impl<S, Req> Service<Req> for Rc<RefCell<S>> where
    S: Service<Req>, [src]

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

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

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

impl<S, Req> Service<Req> for Box<S, Global> where
    S: Service<Req> + ?Sized, [src]

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

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

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

impl<F, Fut, Req, Res, Err> Service<Req> for FnServiceFactory<F, Fut, Req, Res, Err, ()> where
    F: Fn(Req) -> Fut + Clone,
    Fut: Future<Output = Result<Res, Err>>, [src]

type Response = Res

type Error = Err

type Future = Fut

impl<S, F, Fut, Req, In, Res, Err> Service<Req> for Apply<S, F, Req, In, Res, Err> where
    F: Fn(Req, &S) -> Fut,
    S: Service<In, Error = Err>,
    Fut: Future<Output = Result<Res, Err>>, [src]

type Response = Res

type Error = Err

type Future = Fut

impl<A, Req, F, E> Service<Req> for MapErr<A, Req, F, E> where
    F: Fn(<A as Service<Req>>::Error) -> E + Clone,
    A: Service<Req>, [src]

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

type Error = E

type Future = MapErrFuture<A, Req, F, E>

impl<S, Req> Service<Req> for Pipeline<S, Req> where
    S: Service<Req>, [src]

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

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

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

impl<A, F, Req, Res> Service<Req> for Map<A, F, Req, Res> where
    F: FnMut(<A as Service<Req>>::Response) -> Res + Clone,
    A: Service<Req>, [src]

type Response = Res

type Error = <A as Service<Req>>::Error

type Future = MapFuture<A, F, Req, Res>

impl<F, Fut, Req, Res, Err> Service<Req> for FnService<F, Fut, Req, Res, Err> where
    F: Fn(Req) -> Fut,
    Fut: Future<Output = Result<Res, Err>>, [src]

type Response = Res

type Error = Err

type Future = Fut

impl<S, Req> Service<Req> for RefCell<S> where
    S: Service<Req>, [src]

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

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

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

impl<T, U> Service<Connection<T, U>> for RustlsConnectorService where
    T: Address,
    U: AsyncRead + AsyncWrite + Unpin + Debug, [src]

type Response = Connection<T, TlsStream<U>>

type Error = Error

type Future = ConnectAsyncExt<T, U>

impl<T> Service<T> for AcceptorService where
    T: ActixStream, [src]

type Response = TlsStream<T>

type Error = Error

type Future = AcceptorServiceFut<T>

impl<T> Service<Connect<T>> for TcpConnector where
    T: Address, [src]

type Response = Connection<T, TcpStream>

type Error = ConnectError

type Future = TcpConnectorResponse<T>

impl<T> Service<Connect<T>> for Resolver where
    T: Address, [src]

type Response = Connect<T>

type Error = ConnectError

type Future = ResolverFuture<T>

impl<T> Service<Connect<T>> for TcpConnectService where
    T: Address, [src]

type Response = TcpStream

type Error = ConnectError

type Future = TcpConnectServiceResponse<T>

impl<T> Service<Connect<T>> for ConnectService where
    T: Address, [src]

type Response = Connection<T, TcpStream>

type Error = ConnectError

type Future = ConnectServiceResponse<T>

impl<T> Service<T> for AcceptorService where
    T: ActixStream, [src]

type Response = TlsStream<T>

type Error = Error

type Future = AcceptorServiceResponse<T>

impl<T> Service<Connect<T>> for OpensslConnectService where
    T: 'static + Address, [src]

type Response = SslStream<TcpStream>

type Error = ConnectError

type Future = OpensslConnectServiceResponse<T>

impl<T, U> Service<Connection<T, U>> for OpensslConnectorService where
    T: Address + 'static,
    U: AsyncRead + AsyncWrite + Unpin + Debug + 'static, [src]

type Response = Connection<T, SslStream<U>>

type Error = Error

type Future = ConnectAsyncExt<T, U>

impl<S, Req> Service<Req> for TimeoutService<S, Req> where
    S: Service<Req>, [src]

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

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

type Future = TimeoutServiceResponse<S, Req>

Loading content...

Implementors

Loading content...