Manual forwarding e.g. by returning a None

[szabgab]

I was hoping to be able to forward a request from within a route by returning a None - not a guard. I tried this:

#[macro_use]
extern crate rocket;

use rocket::response::content;

#[get("/")]
fn index() -> content::RawHtml<String> {
    let html = format!(r#"
    <a href="/number/23">23</a>
    <a href="/number/42">42</a>
    "#);
    content::RawHtml(html)
}

#[get("/number/<num>", rank = 1)]
fn odd_number(num: u32) -> Option<content::RawHtml<String>> {
    if num % 2 == 1 {
        let html = format!("Odd number: {num:?}");
        return Some(content::RawHtml(html));
    }

    None
}


#[get("/number/<num>", rank = 2)]
fn any_number(num: u32) -> content::RawHtml<String> {
    let html = format!("Any number: {num:?}");
    return content::RawHtml(html);
}


#[launch]
fn rocket() -> _ {
    rocket::build().mount("/", routes![index, odd_number, any_number])
}

#[cfg(test)]
mod test {
    use super::rocket;

    use rocket::http::Status;
    use rocket::local::blocking::Client;

    #[test]
    fn test_main() {
        let client = Client::tracked(rocket()).unwrap();
        let response = client.get("/").dispatch();
        assert_eq!(response.status(), Status::Ok);
        let html = response.into_string().unwrap();
        assert!(html.contains(r#"<a href="/number/23">23</a>"#));
        assert!(html.contains(r#"<a href="/number/42">42</a>"#));
    }

    #[test]
    fn test_23() {
        let client = Client::tracked(rocket()).unwrap();
        let response = client.get("/number/23").dispatch();
        assert_eq!(response.status(), Status::Ok);
        let html = response.into_string().unwrap();
        assert_eq!(html, r#"Odd number: 23"#);
    }

    #[test]
    fn test_42() {
        let client = Client::tracked(rocket()).unwrap();
        let response = client.get("/number/42").dispatch();
        assert_eq!(response.status(), Status::Ok);
        let html = response.into_string().unwrap();
        assert_eq!(html, r#"Any number: 42"#);
    }

}

Unfortunately I get a 404 Not Found for the 42 and the any_number functions is not called.

Did I make a mistake in the example or is there some other way to do this from within the route?

[watsom27]

You can do this by implementing FromParam for a wrapper type:

struct OddNumber(u32);

impl<'a> FromParam<'a> for OddNumber {
    type Error = &'static str;

    fn from_param(param: &'a str) -> Result<Self, Self::Error> {
        if let Ok(number) = param.parse::<u32>() {
            if number % 2 == 1 {
                Ok(Self(number))
            } else {
                Err("Even Number")
            }
        } else {
            Err("Not a valid number")
        }
    }
}

#[get("/number/<num>", rank = 1)]
fn odd_number(num: OddNumber) -> Option<content::RawHtml<String>> {
    let html = format!("Odd number: {:?}", num.0);

    return Some(content::RawHtml(html));
}

#[get("/number/<num>", rank = 2)]
fn any_number(num: u32) -> content::RawHtml<String> {
    let html = format!("Any number: {num:?}");
    return content::RawHtml(html);
}

If the from_param function returns Err, then the parameter guard will forward

[the10thWiz]

A more general answer - you can't forward a request once a handler has executed. Rocket doesn't allow more than one handler to run for a given request. More specifically, Rocket can only run at most one data guard, since Rocket uses a streaming data model for the request body. @watsom27's answer would help for your specific situation listed here, but I this may not always be possible.