How to make middleware which will return HTML/JSON

[Umenokin]

Hi everyone.
I am new to rust, axum, tower and pretty much anything else in the Rust ecosystem. Forgive me if my question is very silly.
Have a scenario in which I wanna assign middleware to any route (like "/*"). Plus in the case of this middleware, I do not want to get responses from potential predecessors and return HTML or any other form of response. I found the example implementing custom middleware: https://docs.rs/axum/0.2.4/axum/#writing-your-own-middleware

But I am struggling to adjust it to return HTML right away. I am trying different variations of which, let me post the simplest one:

let body: Vec<u8> = "hello, world!\n"
     as_bytes()
    .to_owned();

let res = Response::builder()
    .status(200)
    .header("X-Custom-Foo", "Bar")
    .body(body)
    .unwrap();

The error I am getting is:

expected enum `Result<Response<ResBody>, <S as Service<Request<ReqBody>>>::Error>`
found enum `Result<Response<Vec<u8>>, _>

I understand that it is related to rust's generic types below:

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for MyMiddleware<S>
    where
        S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone + Send + 'static,
        S::Future: Send + 'static,
        ReqBody: Send + 'static,
        ResBody: Send + 'static
{
    type Response = S::Response;
    type Error = S::Error;
    type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;

So, now, how can I update ResBody actually be able to accept Vec<u8>?

[3olkin]

I'm not sure that I understood right your use case, but it looks like that you need service, which will accept any request instead of middleware. Look at this example https://docs.rs/axum/0.2.4/axum/#routing-to-any-service.

[Umenokin]

Thanks, @Z4RX , but this option did not work for me. I needed to handle situations like:

  .route("/*", default_handler)  // It seems it is not possible with axum router
  .route("/console", console_handler)

But the one below it seems working fine:

.layer(layer_fn(|inner| MyMiddleware { inner }))
.route("/console", get(handler));

@davidpdrsn 's feedback below helped me a lot.

[davidpdrsn]

By declaring your middleware with

type Response = S::Response;

You're saying that it returns exactly the same type of response that the middleware it is wrapping returns. However if you want to return a different kind of response that isn't possible, because there is no way to generically construct the response.

You can change the type to

type Response = Response<axum::body::BoxBody>;

axum::body::BoxBody is a type erased body that allows you to merge different body types into one. You can convert a body into a BoxBody with axum::body::box_body. Something like this:

let bytes: Vec<u8> = "hello, world!\n"
     as_bytes()
    .to_owned();

let res = Response::builder()
    .status(200)
    .header("X-Custom-Foo", "Bar")
    .body(axum::body::box_body(axum::body::Full::from(bytes))
    .unwrap();

// res is now a `Response<axum::body::BoxBody>`

You can convert the response from the inner service in a similar way:

let response = inner_service.call(request).await?.map(axum::body::box_body);

Let me know if that made things more clear 😊

[Umenokin]

Thanks a lot, @davidpdrsn , It worked like a charm!