Trait actix_service::Transform

source ·
pub trait Transform<S, Req> {
    type Response;
    type Error;
    type Transform: Service<Req, Response = Self::Response, Error = Self::Error>;
    type InitError;
    type Future: Future<Output = Result<Self::Transform, Self::InitError>>;

    // Required method
    fn new_transform(&self, service: S) -> Self::Future;
}
Expand description

Defines the interface of a service factory that wraps inner service during construction.

Transformers wrap an inner service and runs during inbound and/or outbound processing in the service lifecycle. It may modify request and/or response.

For example, a timeout service wrapper:

pub struct Timeout<S> {
    service: S,
    timeout: Duration,
}

impl<S: Service<Req>, Req> Service<Req> for Timeout<S> {
    type Response = S::Response;
    type Error = TimeoutError<S::Error>;
    type Future = TimeoutServiceResponse<S>;

    actix_service::forward_ready!(service);

    fn call(&self, req: Req) -> Self::Future {
        TimeoutServiceResponse {
            fut: self.service.call(req),
            sleep: Sleep::new(clock::now() + self.timeout),
        }
    }
}

This wrapper service is decoupled from the underlying service implementation and could be applied to any service.

The Transform trait defines the interface of a service wrapper. Transform is often implemented for middleware, defining how to construct a middleware Service. A Service that is constructed by the factory takes the Service that follows it during execution as a parameter, assuming ownership of the next Service.

A transform for the Timeout middleware could look like this:

pub struct TimeoutTransform {
    timeout: Duration,
}

impl<S: Service<Req>, Req> Transform<S, Req> for TimeoutTransform {
    type Response = S::Response;
    type Error = TimeoutError<S::Error>;
    type InitError = S::Error;
    type Transform = Timeout<S>;
    type Future = Ready<Result<Self::Transform, Self::InitError>>;

    fn new_transform(&self, service: S) -> Self::Future {
        ready(Ok(Timeout {
            service,
            timeout: self.timeout,
        }))
    }
}

Required Associated Types§

source

type Response

Responses produced by the service.

source

type Error

Errors produced by the service.

source

type Transform: Service<Req, Response = Self::Response, Error = Self::Error>

The TransformService value created by this factory

source

type InitError

Errors produced while building a transform service.

source

type Future: Future<Output = Result<Self::Transform, Self::InitError>>

The future response value.

Required Methods§

source

fn new_transform(&self, service: S) -> Self::Future

Creates and returns a new Transform component, asynchronously

Implementations on Foreign Types§

source§

impl<T, S, Req> Transform<S, Req> for Rc<T>
where T: Transform<S, Req>,

§

type Response = <T as Transform<S, Req>>::Response

§

type Error = <T as Transform<S, Req>>::Error

§

type Transform = <T as Transform<S, Req>>::Transform

§

type InitError = <T as Transform<S, Req>>::InitError

§

type Future = <T as Transform<S, Req>>::Future

source§

fn new_transform(&self, service: S) -> T::Future

source§

impl<T, S, Req> Transform<S, Req> for Arc<T>
where T: Transform<S, Req>,

§

type Response = <T as Transform<S, Req>>::Response

§

type Error = <T as Transform<S, Req>>::Error

§

type Transform = <T as Transform<S, Req>>::Transform

§

type InitError = <T as Transform<S, Req>>::InitError

§

type Future = <T as Transform<S, Req>>::Future

source§

fn new_transform(&self, service: S) -> T::Future

Implementors§

impl<S, B> Transform<S, ServiceRequest> for Cors
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>, S::Future: 'static, B: MessageBody + 'static,

impl<S, B> Transform<S, ServiceRequest> for Compress
where B: MessageBody, S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,

impl<S, B> Transform<S, ServiceRequest> for DefaultHeaders
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>, S::Future: 'static,

impl<S, B> Transform<S, ServiceRequest> for ErrorHandlers<B>
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static, S::Future: 'static, B: 'static,

impl<S, B> Transform<S, ServiceRequest> for Logger
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>, B: MessageBody,

impl<S, B> Transform<S, ServiceRequest> for NormalizePath
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>, S::Future: 'static,

impl<S, T, Req> Transform<S, Req> for Compat<T>
where S: Service<Req>, T: Transform<S, Req>, T::Future: 'static, T::Response: MapServiceResponseBody, T::Error: Into<Error>,

impl<S, T, Req, BE, BD, Err> Transform<S, Req> for Condition<T>
where S: Service<Req, Response = ServiceResponse<BD>, Error = Err> + 'static, T: Transform<S, Req, Response = ServiceResponse<BE>, Error = Err>, T::Future: 'static, T::InitError: 'static, T::Transform: 'static,

impl<S: Service<Req>, Req> Transform<S, Req> for Identity

impl<S, B, E, Req, Type> Transform<S, ServiceRequest> for GrantsMiddleware<E, Req, Type>
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static, for<'a> E: PermissionsExtractor<'a, Req, Type> + 'static, Type: PartialEq + Clone + 'static,

impl<S, B, T, F, O> Transform<S, ServiceRequest> for HttpAuthentication<T, F>
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static, S::Future: 'static, F: Fn(ServiceRequest, T) -> O + 'static, O: Future<Output = Result<ServiceRequest, (Error, ServiceRequest)>> + 'static, T: FromRequest + 'static, B: MessageBody + 'static,

impl<S, B> Transform<S, ServiceRequest> for CatchPanic
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,

impl<S, B> Transform<S, ServiceRequest> for ErrorHandlers<B>
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static, S::Future: 'static, B: 'static,

impl<S, B> Transform<S, ServiceRequest> for NormalizePath
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>, S::Future: 'static,

impl<S, B> Transform<S, ServiceRequest> for RedirectHttps
where S: Service<ServiceRequest, Response = ServiceResponse<B>> + 'static,

impl<S, F, Fut, B, B2> Transform<S, ServiceRequest> for MapResBodyMiddleware<F>
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>, F: Fn(HttpRequest, B) -> Fut, Fut: Future<Output = Result<B2, Error>>, B2: MessageBody,

impl<S, F, Fut, B, B2> Transform<S, ServiceRequest> for MapResMiddleware<F>
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>, F: Fn(ServiceResponse<B>) -> Fut, Fut: Future<Output = Result<ServiceResponse<B2>, Error>>, B2: MessageBody,

impl<S, F, Fut, B, B2> Transform<S, ServiceRequest> for MiddlewareFn<F, ()>
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static, F: Fn(ServiceRequest, Next<B>) -> Fut + 'static, Fut: Future<Output = Result<ServiceResponse<B2>, Error>>, B2: MessageBody,

impl<S, F, Fut, B, B2, E1> Transform<S, ServiceRequest> for MiddlewareFn<F, (E1,)>
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static, F: Fn(E1, ServiceRequest, Next<B>) -> Fut + 'static, E1: FromRequest + 'static, Fut: Future<Output = Result<ServiceResponse<B2>, Error>> + 'static, B: MessageBody + 'static, B2: MessageBody + 'static,

impl<S, F, Fut, B, B2, E1, E2> Transform<S, ServiceRequest> for MiddlewareFn<F, (E1, E2)>
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static, F: Fn(E1, E2, ServiceRequest, Next<B>) -> Fut + 'static, E1: FromRequest + 'static, E2: FromRequest + 'static, Fut: Future<Output = Result<ServiceResponse<B2>, Error>> + 'static, B: MessageBody + 'static, B2: MessageBody + 'static,

impl<S, F, Fut, B, B2, E1, E2, E3> Transform<S, ServiceRequest> for MiddlewareFn<F, (E1, E2, E3)>
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static, F: Fn(E1, E2, E3, ServiceRequest, Next<B>) -> Fut + 'static, E1: FromRequest + 'static, E2: FromRequest + 'static, E3: FromRequest + 'static, Fut: Future<Output = Result<ServiceResponse<B2>, Error>> + 'static, B: MessageBody + 'static, B2: MessageBody + 'static,

impl<S, F, Fut, B, B2, E1, E2, E3, E4> Transform<S, ServiceRequest> for MiddlewareFn<F, (E1, E2, E3, E4)>
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static, F: Fn(E1, E2, E3, E4, ServiceRequest, Next<B>) -> Fut + 'static, E1: FromRequest + 'static, E2: FromRequest + 'static, E3: FromRequest + 'static, E4: FromRequest + 'static, Fut: Future<Output = Result<ServiceResponse<B2>, Error>> + 'static, B: MessageBody + 'static, B2: MessageBody + 'static,

impl<S, F, Fut, B, B2, E1, E2, E3, E4, E5> Transform<S, ServiceRequest> for MiddlewareFn<F, (E1, E2, E3, E4, E5)>
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static, F: Fn(E1, E2, E3, E4, E5, ServiceRequest, Next<B>) -> Fut + 'static, E1: FromRequest + 'static, E2: FromRequest + 'static, E3: FromRequest + 'static, E4: FromRequest + 'static, E5: FromRequest + 'static, Fut: Future<Output = Result<ServiceResponse<B2>, Error>> + 'static, B: MessageBody + 'static, B2: MessageBody + 'static,

impl<S, F, Fut, B, B2, E1, E2, E3, E4, E5, E6> Transform<S, ServiceRequest> for MiddlewareFn<F, (E1, E2, E3, E4, E5, E6)>
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static, F: Fn(E1, E2, E3, E4, E5, E6, ServiceRequest, Next<B>) -> Fut + 'static, E1: FromRequest + 'static, E2: FromRequest + 'static, E3: FromRequest + 'static, E4: FromRequest + 'static, E5: FromRequest + 'static, E6: FromRequest + 'static, Fut: Future<Output = Result<ServiceResponse<B2>, Error>> + 'static, B: MessageBody + 'static, B2: MessageBody + 'static,

impl<S, F, Fut, B, B2, E1, E2, E3, E4, E5, E6, E7> Transform<S, ServiceRequest> for MiddlewareFn<F, (E1, E2, E3, E4, E5, E6, E7)>
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static, F: Fn(E1, E2, E3, E4, E5, E6, E7, ServiceRequest, Next<B>) -> Fut + 'static, E1: FromRequest + 'static, E2: FromRequest + 'static, E3: FromRequest + 'static, E4: FromRequest + 'static, E5: FromRequest + 'static, E6: FromRequest + 'static, E7: FromRequest + 'static, Fut: Future<Output = Result<ServiceResponse<B2>, Error>> + 'static, B: MessageBody + 'static, B2: MessageBody + 'static,

impl<S, F, Fut, B, B2, E1, E2, E3, E4, E5, E6, E7, E8> Transform<S, ServiceRequest> for MiddlewareFn<F, (E1, E2, E3, E4, E5, E6, E7, E8)>
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static, F: Fn(E1, E2, E3, E4, E5, E6, E7, E8, ServiceRequest, Next<B>) -> Fut + 'static, E1: FromRequest + 'static, E2: FromRequest + 'static, E3: FromRequest + 'static, E4: FromRequest + 'static, E5: FromRequest + 'static, E6: FromRequest + 'static, E7: FromRequest + 'static, E8: FromRequest + 'static, Fut: Future<Output = Result<ServiceResponse<B2>, Error>> + 'static, B: MessageBody + 'static, B2: MessageBody + 'static,

impl<S, F, Fut, B, B2, E1, E2, E3, E4, E5, E6, E7, E8, E9> Transform<S, ServiceRequest> for MiddlewareFn<F, (E1, E2, E3, E4, E5, E6, E7, E8, E9)>
where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static, F: Fn(E1, E2, E3, E4, E5, E6, E7, E8, E9, ServiceRequest, Next<B>) -> Fut + 'static, E1: FromRequest + 'static, E2: FromRequest + 'static, E3: FromRequest + 'static, E4: FromRequest + 'static, E5: FromRequest + 'static, E6: FromRequest + 'static, E7: FromRequest + 'static, E8: FromRequest + 'static, E9: FromRequest + 'static, Fut: Future<Output = Result<ServiceResponse<B2>, Error>> + 'static, B: MessageBody + 'static, B2: MessageBody + 'static,

impl<S, Req> Transform<S, Req> for PanicReporter
where S: Service<Req>, S::Future: 'static,

impl<S: Service<Req>, Req> Transform<S, Req> for LoadShed