How to lazy load with async?

[ziimakc]

SO link.

I want to lazy init a struct with async database pool once and use it everywhere

#[derive(Debug)]
pub struct Database {
    pub pool: PgPool,
}

impl Database {
    pub async fn init() -> Self {
        let pool = Database::create_db_pool().await;

        Database { pool }
    }

    pub async fn create_db_pool() -> PgPool {
        PgPoolOptions::new()
            .max_connections(20)
            .acquire_timeout(Duration::from_secs(3))
            .connect(API_ENV.db_url)
            .await
            .expect("Can't connect to database")
    }
}

I can do this like so, but it requires to write DATABASE.get().unwrap() which I don't like:

pub static DATABASE: OnceCell<Database> = OnceCell::new();

async fn main() {
    let db = Database::init().await;
    DATABASE.set(db).unwrap();

    let db = DATABASE.get().unwrap();
}

Trying to do block_on as suggested in some examples

pub static DATABASE: Lazy<Database> = Lazy::new(|| {
    let pool: Database = Runtime::new()
        .unwrap()
        .block_on(async { Database::init().await });

    pool
});

async fn main() {
    let db = DATABASE.pool;
}

Leeds to an error:

Cannot start a runtime from within a runtime. This happens because a function (like block_on) attempted to block the current thread while the thread is being used to drive asynchronous tasks.

[davidpdrsn]

This isn’t an axum question and seems you already got some answers on stackoverflow.