Trait actix_service::Service

pub trait Service<Request> {
    type Response;
    type Error;
    type Future: Future<Item = Self::Response, Error = Self::Error>;

    fn poll_ready(&mut self) -> Poll<(), Self::Error>;
    fn call(&mut self, req: Request) -> Self::Future;
}

An asynchronous function from Request to a Response.

Required Associated Types

type Response

Responses given by the service.

type Error

Errors produced by the service.

type Future: Future<Item = Self::Response, Error = Self::Error>

The future response value.

Required Methods

fn poll_ready(&mut self) -> Poll<(), Self::Error>

Returns Ready when the service is able to process requests.

If the service is at capacity, then NotReady 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.

fn call(&mut self, req: Request) -> Self::Future

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.

Implementations on Foreign Types

impl<'a, S, Request> Service<Request> for &'a mut Swhere
    S: Service<Request> + 'a,

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

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

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

fn poll_ready(&mut self) -> Poll<(), S::Error>

fn call(&mut self, request: Request) -> S::Future

impl<S, Request> Service<Request> for Box<S>where
    S: Service<Request> + ?Sized,

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

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

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

fn poll_ready(&mut self) -> Poll<(), S::Error>

fn call(&mut self, request: Request) -> S::Future

Implementors

impl<A, B, Request> Service<Request> for AndThen<A, B>where
    A: Service<Request>,
    B: Service<A::Response, Error = A::Error>,

type Response = <B as Service<<A as Service<Request>>::Response>>::Response

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

type Future = AndThenFuture<A, B, Request>

impl<A, B, Request> Service<Request> for Then<A, B>where
    A: Service<Request>,
    B: Service<Result<A::Response, A::Error>, Error = A::Error>,

type Response = <B as Service<Result<<A as Service<Request>>::Response, <A as Service<Request>>::Error>>>::Response

type Error = <B as Service<Result<<A as Service<Request>>::Response, <A as Service<Request>>::Error>>>::Error

type Future = ThenFuture<A, B, Request>

impl<A, E, Request> Service<Request> for FromErr<A, E>where
    A: Service<Request>,
    E: From<A::Error>,

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

type Error = E

type Future = FromErrFuture<A, E, Request>

impl<A, F, E, Request> Service<Request> for MapErr<A, F, E>where
    A: Service<Request>,
    F: Fn(A::Error) -> E + Clone,

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

type Error = E

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

impl<A, F, Request, Response> Service<Request> for Map<A, F, Response>where
    A: Service<Request>,
    F: Fn(A::Response) -> Response + Clone,

type Response = Response

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

type Future = MapFuture<A, F, Request, Response>

impl<F, Req, Resp, E, Fut> Service<Req> for FnService<F, Req, Resp, E, Fut>where
    F: Fn(Req) -> Fut,
    Fut: IntoFuture<Item = Resp, Error = E>,

type Response = Resp

type Error = E

type Future = <Fut as IntoFuture>::Future

impl<T, F, In, Out, Request> Service<In> for Apply<T, F, In, Out, Request>where
    T: Service<Request, Error = Out::Error>,
    F: Fn(In, &mut T) -> Out,
    Out: IntoFuture,

type Response = <Out as IntoFuture>::Item

type Error = <Out as IntoFuture>::Error

type Future = <Out as IntoFuture>::Future