Background task is blocking

[Leastrio]

Running v0.5rc-1
Code:

#[launch]
async fn rocket() -> _ {
    let file = fs::read_to_string("stats.json").expect("Unable to read file");
    let stats: api::Stats = serde_json::from_str(&file).expect("Could not parse json");
    dotenv::dotenv().ok();
    rocket::build()
        .attach(Template::fairing())
        .attach(info::stage())
        .attach(api::stage())
        .mount("/", routes![index])
        .mount("/static", FileServer::from(relative!("static")))
        .manage(stats)
        .attach(rocket::fairing::AdHoc::on_liftoff(
            "Background task",
            |rocket| {
                Box::pin(async move {
                    let mut interval = rocket::tokio::time::interval(Duration::from_secs(600));
                    interval.tick().await;
                    loop {
                        interval.tick().await;
                        if let Some(state) = rocket.state::<Stats>() {
                            let json = serde_json::to_string(state).unwrap();
                            println!("{}", json);
                        }
                    }
                })
            },
        ))
}

When I run this, the loop runs but rocket seems to get blocked and just never starts, when I comment out the loop {} that allows rocket to not get blocked.

[SergioBenitez]

That's exactly what we would expect. From the docs:

Liftoff fairings are run concurrently; resolution of all fairings is awaited before resuming request serving.

Your fairing never terminates. If you want to run your loop in a background task, you need to task::spawn a new task.

[Leastrio]

Ive been trying to figure out how to do this for a little bit now, but cant figure out it for the life of me, where should I spawn the new task? This is what I got but it errors with a long lifetime error.

.attach(rocket::fairing::AdHoc::on_liftoff(
            "Background task",
            |rocket| {
                Box::pin(async move {
                    rocket::tokio::spawn(async move {
                        let mut interval = rocket::tokio::time::interval(Duration::from_secs(10));
                        interval.tick().await;
                        loop {
                            interval.tick().await;
                            if let Some(state) = rocket.state::<Stats>() {
                                let json = serde_json::to_string(state).unwrap();
                                println!("{}", json);
                            }
                        }
                    });
                })
            },
        ))

[the10thWiz]

rocket is passed as a reference, so you can't keep it. I don't know what the recommended solution is here, but I have in the past placed the state within an Arc, allowing the long running task to keep access to the state.