Need help implementing my custom error handler

[bandrefilipe]

I need to transform some would-be 404 NOT_FOUND responses into 200 OK ones with some html in it to boot and I'm a little lost at it.

Why? Because of this:

In order for an external link to your webapp to work, the server must be configured to return the index.html file for any GET request that would otherwise return a 404 for any conceivable client-side route.

I looked at both the wrap_fn example here and at the actix_web::middleware::ErrorHandlers docs, but my limited knowledge of the language keeps me from finding a solution to it. (Or even if any of these two options are actually viable for my use case)

Can anyone please guide me?

[bandrefilipe]

Ok, the farthest I've made is this, but now I find myself fighting the borrow checker:

use std::collections::HashMap;

use actix_web::dev::{Service, ServiceResponse};
use actix_web::http::{Method, StatusCode};
use actix_web::{App, HttpResponse, HttpServer};
use actix_web_static_files::ResourceFiles;
use futures_util::FutureExt;
use static_files::Resource;

include!(concat!(env!("OUT_DIR"), "/generated.rs"));

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        let static_files: HashMap<&'static str, Resource> = generate();
        let index_html: &[u8] = static_files.get("index.html").unwrap().data;

        App::new()
            .wrap_fn(move |req, srv| {
                srv.call(req).map(|res| {
                    if let Ok(response) = &res {
                        let request = response.request();

                        if response.status() == StatusCode::NOT_FOUND
                            && request.method() == Method::GET
                            && !(request.path().starts_with("/api/"))
                        {
                            return Ok(ServiceResponse::new(
                                request.clone(),
                                HttpResponse::Ok().body(index_html),
                            ));
                        }
                    }
                    res
                })
            })
            .service(ResourceFiles::new("/", static_files))
    })
    .bind("0.0.0.0:8080")?
    .run()
    .await
}

error: lifetime may not live long enough
  --> src/main.rs:21:17
   |
20 |               .wrap_fn(move |req, srv| {
   |                        ---------------
   |                        |             |
   |                        |             return type of closure `futures_util::future::Map<Pin<Box<dyn futures_util::Future<Output = Result<ServiceResponse, actix_web::Error>>>>, [closure@src/main.rs:21:35: 36:18]>` contains a lifetime `'2`
   |                        lifetime `'1` represents this closure's body
21 | /                 srv.call(req).map(|res| {
22 | |                     if let Ok(response) = &res {
23 | |                         let request = response.request();
24 | |
...  |
35 | |                     res
36 | |                 })
   | |__________________^ returning this value requires that `'1` must outlive `'2`
   |
   = note: closure implements `Fn`, so references to captured variables can't escape the closure

[robjtede]

Give this a go, it removes a lot of the lifetime problems and is conceptually simpler.
https://docs.rs/actix-web-lab/0.16.1/actix_web_lab/middleware/fn.from_fn.html

[bandrefilipe]

Thanks again for your help!

It helped until I stumbled into async moves. Then I tried somethings different in my approach and in the end I managed it this way:

use std::collections::HashMap;
use std::ops::Not;

use actix_web::dev::{Service, ServiceResponse};
use actix_web::http::{Method, StatusCode};
use actix_web::{App, Error, HttpResponse, HttpServer};
use actix_web_static_files::ResourceFiles;
use futures_util::FutureExt;
use static_files::Resource;

include!(concat!(env!("OUT_DIR"), "/generated.rs"));

fn resources() -> HashMap<&'static str, Resource> {
    // this function is defined in generated.rs
    generate()
}

fn index_html() -> Resource {
    match resources().get("index.html") {
        None => panic!("Failed to locate file: index.html"),
        Some(resource) => Resource { ..*resource },
    }
}

trait IndexHtmlTest {
    fn shall_be_index_html(&self) -> bool;
}

impl IndexHtmlTest for ServiceResponse {
    fn shall_be_index_html(&self) -> bool {
        self.status() == StatusCode::NOT_FOUND
            && self.request().method() == Method::GET
            && self.request().path().starts_with("/api/").not()
    }
}

fn process_result(result: Result<ServiceResponse, Error>) -> Result<ServiceResponse, Error> {
    if let Ok(response) = &result {
        if response.shall_be_index_html() {
            let index_html = index_html(); // <--------- mostly because of this call here.
            return Ok(ServiceResponse::new(
                response.request().clone(),
                HttpResponse::Ok()
                    .append_header(("content-type", index_html.mime_type))
                    .body(index_html.data),
            ));
        }
    }
    result
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .wrap_fn(|req, srv| srv.call(req).map(|res| process_result(res)))
            .service(ResourceFiles::new("/", resources()))
    })
    .bind("0.0.0.0:8080")?
    .run()
    .await
}

Instead of trying to borrow/move/clone the original an entry in the same map that I was moving elsewhere, I simply created a new map.

It may well be that your suggestion could work too. I may try it later.
Thanks!