Function catalyzer::internals::crates::tower::layer::layer_fn

pub fn layer_fn<T>(f: T) -> LayerFn<T>

Returns a new LayerFn that implements Layer by calling the given function.

The Layer::layer method takes a type implementing Service and returns a different type implementing Service. In many cases, this can be implemented by a function or a closure. The LayerFn helper allows writing simple Layer implementations without needing the boilerplate of a new struct implementing Layer.

Example

// A middleware that logs requests before forwarding them to another service
pub struct LogService<S> {
    target: &'static str,
    service: S,
}

impl<S, Request> Service<Request> for LogService<S>
where
    S: Service<Request>,
    Request: fmt::Debug,
{
    type Response = S::Response;
    type Error = S::Error;
    type Future = S::Future;

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

    fn call(&mut self, request: Request) -> Self::Future {
        // Log the request
        println!("request = {:?}, target = {:?}", request, self.target);

        self.service.call(request)
    }
}

// A `Layer` that wraps services in `LogService`
let log_layer = layer_fn(|service| {
    LogService {
        service,
        target: "tower-docs",
    }
});

// An example service. This one uppercases strings
let uppercase_service = tower::service_fn(|request: String| async move {
    Ok::<_, Infallible>(request.to_uppercase())
});

// Wrap our service in a `LogService` so requests are logged.
let wrapped_service = log_layer.layer(uppercase_service);