Getting collision panics after updating to v0.3.x

[Umenokin]

My current routes setup which does not working with new router:

let app = Router::new()
        .nest("/", service_method_routing::any(worker))
        .nest("/admin", admin_routes());

Where admin_routes is:

fn admin_routes() -> Router {
    let console = ConsoleService::new("./dist/admin");
    let manager = ManagerService::new();

    Router::new()
        .nest("/", service_method_routing::get(console).handle_error(handle_io_error))
        .nest("/api", manager)
}

With new routing, I understand that "/" and "/admin" would end up becoming collision but I cannot wrap my head around how to properly update it. The idea is simple:
If a user hits / any path should lead to the worker service .nest("/", service_method_routing::any(worker)) unless it starts from /admin. So I would describe it like /* except /admin

Same for the admin path: If the user hits /admin any path should lead to console service_method_routing::get(console).handle_error(handle_io_error)) unless it starts from /admin/api

I would say that update documentation feels less detailed.

[davidpdrsn]

Use Router::fallback instead of nest("/", _).

[Umenokin]

As always, thanks @davidpdrsn
Updating

let app = Router::new()
        .nest("/", service_method_routing::any(worker))
        .nest("/admin", admin_routes());

To

let app = Router::new()
        .nest("/admin", admin_routes())
        .fallback(service_method_routing::any(worker));

Helped and it seems very logical. Though the same trick does not work for the following:

fn admin_routes() -> Router {
    let console = ConsoleService::new("./dist/admin");
    let manager = ManagerService::new();

    Router::new()
        .nest("/api", manager)
        .fallback(service_method_routing::get(console).handle_error(handle_io_error))
}

/api based routes works like a charm. For example http://localhost:5000/admin/api/test1. But http://localhost:5000/admin would not. If I comment out the line .nest("/api", manager)

Though, here I think it is related to the implementation of the console which I need to take a look at first. Let me message here once I take a look.

As for the documentation, sorry I did not want to sound disrespectful. You guys are doing an amazing job. I understand that complaining does not make any sense if I am at least not giving any suggestions.
I just started updating my project from v0.25 to 0.31 and did not think there will be big changes in documentation. I will try to come up with feedback, though after you pointed me to the fallback handler, the updated code looks much more reasonable.

Thanks

[Umenokin]

Thanks again, @davidpdrsn . Can you help me with one more thing?
As I mentioned, the following snipping is not working properly:

fn admin_routes() -> Router {
    let console = ConsoleService::new("./dist/admin");
    let manager = ManagerService::new();

    Router::new()
        .nest("/api", manager)
        .fallback(service_method_routing::get(console).handle_error(handle_io_error))
}

The .nest("/api", manager) works as expected but the fallback does not. The original implementation of the console is:

#[derive(Clone)]
pub struct ConsoleService {
    content_dir: String,
    not_found_path: String
}

impl ConsoleService {
    pub fn new(content_dir: &'static str) -> Self {
        let content_dir = String::from(content_dir);
        let not_found_path = content_dir.clone() + "/" + NOT_FOUND_PAGE;

        ConsoleService {
            content_dir,
            not_found_path
        }
    }
}

impl<ReqBody> Service<Request<ReqBody>> for ConsoleService
    where ReqBody: Send + 'static,
{
    type Response = Response<BoxBody<Bytes, io::Error>>;
    type Error = io::Error;
    type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;

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

    fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
        let content_dir = self.content_dir.to_owned();
        let not_found_path = self.not_found_path.to_owned();

        Box::pin(async {
            let res = ServeDir::new(content_dir)
                .append_index_html_on_directories(true)
                .call(req).await?;

            let res = if res.status() == 404 {
                let not_found = ServeFile::new(not_found_path).call(()).await?;
                res.map(|_| BoxBody::new(not_found.into_body()))
            } else {
                res.map(|body| BoxBody::new(body))
            };

            Ok(res)
        })
    }
}

Which is essentially just a static file server.
So, what I am at trying to confirm is that fallback will reach the fn call but it does not. So if I would do something like:

fn call(&mut self, req: R) -> Self::Future {
        println!("Console handler");
        ...

I will never see the message println!("Console handler");

Also, I tried to make Console into copy of Worker which working for /admin fallback but the result is the same. Any hints what could be wrong?

[davidpdrsn]

/api based routes works like a charm. For example http://localhost:5000/admin/api/test1. But http://localhost:5000/admin would not. If I comment out the line .nest("/api", manager)

Make sure to read the docs on fallback carefully for how it interacts with merge and nest.

I think this case you can use .route("/*rest", _) and route based on rest, either calling manager or console. There might be a different way to build your routes that are simpler. Generally I recommend not over abstracting things since it can make it hard to follow which exact routes you have.

[davidpdrsn]

axum tries as much as possible to merge all your routes into a single Router that has all the routes, as it improves performance. This is why you can only have one fallback.

[Umenokin]

Thanks, @davidpdrsn . I will think about how I can restructure my routing.