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