I think the key problem is that lazy_static always uses a synchronous primitive for initialization, so its always going to block on the initialization.
What about building our own async initialization locking instead? Here's a snippet using once_cell to provide the mutable statics:
use once_cell::sync::OnceCell;
use tokio::sync::Mutex;
static MONGO: OnceCell<Client> = OnceCell::new();
static MONGO_INITIALIZED: OnceCell<Mutex<bool>> = OnceCell::new();
pub async fn get_mongo() -> &'static Client {
// this is racy, but that's OK: it's just a fast case
if let Some(v) = MONGO.get() {
return v;
}
// it hasn't been initialized yet, so let's grab the lock & try to
// initialize it
let initializing_mutex = MONGO_INITIALIZED.get_or_init(|| Mutex::new(false));
// this will wait if another task is currently initializing the client
let mut initialized = initializing_mutex.lock().await;
// if initialized is true, then someone else initialized it while we waited,
// and we can just skip this part.
if !*initialized {
// no one else has initialized it yet, so
let client = Client /* async code to initialize client here! */ ;
MONGO.set(client).expect(
"no one else should be initializing this \
as we hold MONGO_INITIALIZED lock",
);
*initialized = true;
drop(initialized);
}
MONGO.get().unwrap()
}
(playground link which compiles with stubs for the Client)
I'll let you look through that, but the gist of it is that we can use a tokio-based Mutex to ensure that only one task initializes the mongo database at a time, and besides that just use OnceCell for actually storing the initialized value.
OnceCell is very similar to lazy_static!, the main difference is that it requires a slightly newer rustc version, isn't macro-based, and forces whoever is accessing it to provide the initialization code, rather than building it into the definition.
We use two OnceCells since we have one for the actual data, and a separate one storing only a lock for initialization. I've written it this way so that in the fast case when it is already initialized, we don't have to lock the mutex or use it at all to access the data.
This code could also probably be improved - I don't think we need the boolean inside MONGO_INITIALIZED for instance, since it's redundant with MONGO's state. But regardless it should work.
Thoughts?
