Impact on using tokio runtime in actix context

[yageek]

I'm currently working inside a workspace where I have a main actix-web program and another one using rust-celery.

One crate is bootstrapped with [actix::main] and the other one by [tokio::main] and both are using ´sqlx`.

If I choose the sqlx runtime-tokio in one and ˋruntime-actix` in the other, the workspace do not compile. This is described in the issue #894.

As suggested, I switched the runtime to use the same features in both project. I choosed 'runtime-tokio` in both crates.

I now have in my actix-web based crate (using the actix runtime), a sqlx dependency configured with the runtime-tokio. I did some experiments and it looks to work fine.

However, I'm new to this and I would like to know if I am not doing a mistake by doing this?

[abonander]

We use this in our projects internally. You can even have both runtimes going in the same binary. In fact, the Actix runtime is just a wrapper around the Tokio runtime that forces it into single-threaded mode, and Tokio's notion of "current runtime" is set on a per-thread basis, so technically you could have a pool of threads each with its own Actix runtime if you want.

Since the Actix runtime is single-threaded, if we have a lot of background work in our app that we don't want clogging up the Actix thread, we'll start a Tokio threaded runtime in the background and spawn tasks into that. The tokio::net::TcpStream that underlies SQLx's connection types doesn't seem to mind being moved back and forth between Tokio runtimes so we just have one connection pool for the whole app.

Our basic app structure looks kinda like this:

src/main.rs

mod http;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let db: sqlx::PgPool = /* create PgPool */;

    sqlx::migrate!().run(&db).await?;

    // spawn background tasks
    tokio::spawn(async move { /* ... */ };

    // this causes the current thread to switch from the Tokio runtime to the Actix runtime
    // as the Tokio threaded runtime takes this out of its own core thread pool that runs async tasks
    tokio::task::block_in_place(move || http::run(db))
}

src/http/mod.rs

// this attribute doesn't actually care if it's decorating the crate's `main()` function
// it'll turn any `async fn` into a blocking function that starts an Actix runtime and wait until it completes
#[actix_web::main]
pub async fn run(db: PgPool) -> anyhow::Result<()> {
    let db = actix_web::web::Data::new(db);

    HttpServer::new(move || App::new().app_data(db.clone())/* ... add services and other app data */)
        .bind("0.0.0.0:8080")?
        .run()
        .await?;

    Ok(())
}

[yageek]

Great answer. Thank you for the snippets, they helped a lot. It is a little bit clearer now. I hope I will understand all the details about the different runtimes one day.