best practice for own main() function

[LuckyTurtleDev]

The doc of rocket suggest to use the #[launch] or #[main]. This is regular fine.
But if you want to do some stuff before the async runtime has started. This is not possible with this.
I have run cargo-expand to get a idea, what the macro is doing.
It does call .launch() on the created rocket builder and await this future.
It looks like the async runtime is initialed with ::rocket::async_main, but I can not find any documentation about it.

What is the best practice for own main() function?

my expanded code:

fn main() {
    ::rocket::async_main(async move {
        let _res = {
            let ___rocket: ::rocket::Rocket<::rocket::Build> = {
                spawn_blocking(|| Lazy::force(&CONFIG)).await.unwrap();
                BUCKET
                    .list("/".to_owned(), Some("/".to_owned()))
                    .await
                    .expect("failed to connect to s3 bucket");
                Lazy::force(&SQL_POOL);
                let shield = Shield::default().disable::<rocket::shield::Frame>();
                rocket::build()
                    .mount(
                        "/",
                        {
                            let ___vec: ::std::vec::Vec<::rocket::Route> = <[_]>::into_vec(
                                #[rustc_box]
                                ::alloc::boxed::Box::new([
                                    {
                                        let ___struct = index {};
                                        let ___item: ::rocket::Route = ___struct.into_route();
                                        ___item
                                    },
                                ]),
                            );
                            ___vec
                        },
                    )
                    .mount(
                        "/",
                        {
                            let ___vec: ::std::vec::Vec<::rocket::Route> = <[_]>::into_vec(
                                #[rustc_box]
                                ::alloc::boxed::Box::new([
                                    {
                                        let ___struct = register {};
                                        let ___item: ::rocket::Route = ___struct.into_route();
                                        ___item
                                    },
                                ]),
                            );
                            ___vec
                        },
                    )
                    .attach(Template::fairing())
                    .attach(shield)
            };
            let ___rocket: ::rocket::Rocket<::rocket::Build> = ___rocket;
            ___rocket
        }
            .launch()
            .await;
    })
}

my new written code with own main:

fn main() {
	Lazy::force(&CONFIG);
	//Lazy::force(&SQL_POOL);
	::rocket::async_main(async move {
		let rocket = {
			BUCKET
				.list("/".to_owned(), Some("/".to_owned()))
				.await
				.expect("failed to connect to s3 bucket");
			let shield = Shield::default().disable::<rocket::shield::Frame>();
			rocket::build()
				.mount("/", routes![index])
				.mount("/", routes![register])
				.attach(Template::fairing())
				.attach(shield)
		};
		rocket.launch().await.expect("failed to launch the rocket");
	})
}

I did get a warning, that I must use Rocket.

warning: unused `Rocket` that must be used
   --> src/main.rs:144:3
    |
144 |         rocket.launch().await.expect("failed to launch the rocket");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `#[warn(unused_must_use)]` on by default

I am not sure why I must use the result. The expanded macro does only assign it to _res and never use it again.

Maybe something like #[tokio::main] for rocket would be nice.
This would allow the user to define a function as entrypoint for rocket, but would still allow to have a own main function.
Somethink like:

main() {
	do_something();
	rocket_main();
}

#[rocket::main]
async fn rocket_main() {
	do_something_else();
	rocket::build().mount("/", routes![index])
}

[blackghost1987]

I think you are looking for something like the fairly new rocket::execute() function. The implementation originated from this issue:
#1881

Check the examples here: 46c441a

Note: this is far from a "suggested use", see the comment by @SergioBenitez starting with For extreme and rare cases... 😃

Another useful trick: you should be able to put the launch / main macros on a function in a submodule. This way the generated main() function will be just a regular function, not the actual entrypoint of the application, and it could be called manually from outside the submodule.

I hope one of these solutions helps you a bit

[delan]

Another useful trick: you should be able to put the launch / main macros on a function in a submodule. This way the generated main() function will be just a regular function, not the actual entrypoint of the application, and it could be called manually from outside the submodule.

this worked great! we were even able to use this trick in other parts of the same program that needed #[tokio::main], as long as #[tokio::main] and #[rocket::main] are never started concurrently. the only downside seems to be that you can’t pass arguments to a submodule main with these macros.

[ar1a]

^ (implemented in ar1a/autost@9e223cf)