Unable to initialize statically the Database or causes deadlock

[milen-denev]

This is my code:

pub struct NativeDb<'a> {
    pub db: Arc<Database<'a>>
}

pub const NATIVE_DB_LOC: Lazy<String> = Lazy::new(|| {
    let loc = format!("{}{}{}", CACHE_DB_LOCATION.to_string(), helpers::get_system_char_delimiter(), "cache.native_db");
    return loc;
}); 

pub static DATABASE_BUILDER: Lazy<DatabaseBuilder> = Lazy::new(|| {
    let mut builder = DatabaseBuilder::new();
    builder.define::<NdbCachedItem>().unwrap();
    builder.set_cache_size(2_147_483_648);
    builder
});

pub static NATIVE_DB: Lazy<NativeDb<'static>> = Lazy::new(|| {
    NativeDb { db: Arc::new(init_database()) }
});

fn init_database() ->  Database<'static> {
    if helpers::file_exists(&NATIVE_DB_LOC) {
        DATABASE_BUILDER.open(Path::new(&NATIVE_DB_LOC.clone())).unwrap()
    }
    else {
        DATABASE_BUILDER.create(Path::new(&NATIVE_DB_LOC.clone())).unwrap()
    }
}

If I try to access this from an actix middleware, and I do requests that point to different database entries at the same time I am deadlocking the application (by application I mean every thread, or at least that's how it feels). I cannot create an instance from main() and pass it arround because simply that's impossible in my use case.

I tried putting DatabaseBuilder inside the NativeDb struct or withing the same Lazy but that's also impossible due to the way the DatabaseBuilder is made.

This is the middleware:

pub async fn cache_middleware<'a>(
    req: ServiceRequest,
    next: Next<impl MessageBody>,
) -> Result<ServiceResponse<impl MessageBody>, Error> {    
   let r_db = NATIVE_DB.db.r_transaction().unwrap();
   let cached_item_value_result: Option<NdbCachedItem> = r_db.get().primary(conn_str.clone()).unwrap();
   //some other code
}

[milen-denev]

I really like the extensive features and I hope to find a solution to make it work. Great project.

[vincent-herlemont]

@milen-denev Can you test by creating the database during your server initialization instead of in lazy static?

You will find an example here: src-tauri/src/main.rs#L79-L100

[milen-denev]

Thank you very much for the suggestion sadly (and that's why I included the example) I cannot do that. There are use cases (this type of middleware or background services) which doesn't allow to pass a reference neither a Arc.clone() or any other type (as of my knowledge).

I did a stress test in main (which may not exaclty cover my use case) and I think there something wrong with the DatabaseBuilder's lazy initialization and the Database's lazy initialization. If you combine this 2 lazy inits something goes wrong and it deadlocks (or the latency skyrockets to unimaginable levels). I don't know how the one correlates to the other, but with certainty I can say that the one is attached to the other.

[vincent-herlemont]

There are use cases (this type of middleware or background services) which doesn't allow to pass a reference neither a Arc.clone() or any other type (as of my knowledge).

@milen-denev You don't need to use Arc, because Native DB already uses such a mechanism, and consequently, there won't be this kind of problem.

You can move the database into the App Data app_data<U: 'static>(self, ext: U) here an example

...
    let db = DATABASE_BUILDER
        .create_in_memory()
        .expect("failed to create database");

    let data = web::Data::new(db);

    App::new()
        .app_data(data)
        .wrap_fn(|req, srv| {
            let db = req.app_data::<web::Data<Database>>().unwrap();
...

I used the wrap_fn function to create a very simple middleware, but you can do the same thing with the full version of the middleware. More information on this documentation middleware.