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§
Required Methods§
sourcefn new_transform(&self, service: S) -> Self::Future
fn new_transform(&self, service: S) -> Self::Future
Creates and returns a new Transform component, asynchronously