Is there an idiomatic way to periodically execute a method on the app's state?

[ohmree]

My use-case for this is periodically removing unused entries from a SQL database.
I think something can be hacked together using tasks, async_io::Timer (or the tokio equivalent, I wouldn't know because I don't use tokio) and an Arc wrapping the state, but I was hoping there'd be a nicer solution.
Does such a solution exist?

[yoshuawuyts]

The way I'd approach this would be to create a copy of State on creation and move it into a separate task which can then indeed operate on a loop. State is already required to be Clone + Send, so that shouldn't be a problem. I'd imagine this would look something like this:

// Create an instance of your `State`
let state = State::new();

// Clone your `State` and pass it into a task where we'll perform the periodic cleanup
let cleanup_state = state.clone();
let handle = task::spawn(async move {
    while let Some(_) = async_std::task::sleep(Duration::from_secs(10)) {
        // SQL cleanup here
        cleanup_state.db().cleanup().await?;
    }
    Ok(())
});

// Create the tide app, and listen on a port
// If either the DB cleanup or tide server fail, the application will exit.
let mut app = tide::with_state(state);
app.at("/").get(|_| async { Ok("hello world") });
app.listen("localhost:8080").try_race(handle)?; // using async-std's `Future::try_race`

---

Tide currently does not handle any application lifecycle things such as restarts, wait groups, and the like. We expect people to use supporting libraries for that. Our hope is that by not building everything directly into Tide we can enable composition and competition, which in turn reduces the burden on us to build solutions for everything, and enables a composable async ecosystem to emerge.

I hope this answers your question!

[ohmree]

Thank you so much for the detailed and helpful answer!
I didn't know about race and try_race (and generally I'm pretty much a noob when it comes to futures, async, parallelism and concurrency) so that's great to know.

I ended up doing something like this (for some reason the anyhow::Error -> std::io::Error boilerplate code is necessary):

use routes::{details_for, update_details};
use state::State;

use anyhow::{anyhow, Result};
use async_std::{prelude::*, task};
use std::{env, time::Duration};

// how often should we remove unreferenced songs? (every 30 minutes).
const PERIODIC_CLEANUP_INTERVAL: u64 = 60 * 30;

#[async_std::main]
async fn main() -> Result<()> {
    dotenv::dotenv()?;

    tide::log::start();
    let state = State::new().await?;

    let cleanup_state = state.clone();
    let cleanup_handle = task::spawn(async move {
        task::sleep(Duration::from_secs(PERIODIC_CLEANUP_INTERVAL)).await;
        cleanup_state
            .delete_videos_not_being_played()
            .await
            .map_err(|e| {
                e.downcast::<std::io::Error>().unwrap_or_else(|_| {
                    std::io::Error::new(
                        std::io::ErrorKind::Other,
                        "error downcasting `anyhow::Error` into `std::io::Error`",
                    )
                })
            })?;
        Ok(())
    });

    let mut app = tide::with_state(state);

    app.at(":user_id").put(update_details);
    app.at(":user_id").get(details_for);

    app.listen(format!("http://localhost:{}", env::var("PORT")?))
        .try_race(cleanup_handle)
        .await?;
    Ok(())
}

I haven't checked if it works correcty yet but at least now I know how to go about this.

EDIT: I've switched from using plain sqlx to using tide-sqlx, and since the latter doesn't expose the database connection outside of request handlers I had to find a better solution.
Turns out there is one - it's called pgAgent and I'm now using it to run a bit of sql code periodically.