How to store a state in Rust

[milesegan]

If I need a persistent connection like to a database or a web socket or something like that if I create it in main and then pass it to handlers will that work?

Like this:

async fn main() {
    let conn = db::create_connection();
    let mut request_receiver = bridge::get_request_receiver();
    while let Some(request_unique) = request_receiver.recv().await {
        tokio::spawn(async {
            let response_unique = handle_request(&conn, request_unique).await;
            respond_to_dart(response_unique);
        });
    }
}

[temeddix]

Hi @milesegan , thank you for your participation!

Your code might work, but I recommend using OnceCell instead. If you use OnceCell, your conn becomes a global variable that you can access from anywhere via crate::conn_cell.

use std::cell::OnceCell;

let conn_cell = OnceCell::new();

async fn main() {
    let conn = db::create_connection();
    conn_cell.set(conn);
    let mut request_receiver = bridge::get_request_receiver();
    while let Some(request_unique) = request_receiver.recv().await {
        tokio::spawn(async {
            let response_unique = handle_request(request_unique).await;
            respond_to_dart(response_unique);
        });
    }
}

async fn some_other_function() {
    let conn = conn_cell.get().unwrap();
    // Do something with `conn`
}

(I haven't actually tested this code, but it should work)

[milesegan]

Thanks for your suggestion. I will give this a try and report back here.

[temeddix]

There's also LazyCell, whose syntax is more clear and concise. However, the docs states that it's not stabilized yet.

[temeddix]

If there is a problem with race condition, you may use this instead:

use std::cell::OnceCell;
use std::sync::Mutex;

let conn_cell: OnceCell<Mutex<db::Connection>> = OnceCell::new();

async fn main() {
    let conn = db::create_connection();
    conn_cell.set(Mutex::new(conn));
    let mut request_receiver = bridge::get_request_receiver();
    while let Some(request_unique) = request_receiver.recv().await {
        tokio::spawn(async {
            let response_unique = handle_request(request_unique).await;
            respond_to_dart(response_unique);
        });
    }
}

[milesegan]

Thanks very much for your detailed suggestion. That makes sense. I will give this a try!

[temeddix]

No problem! If you're enjoying Rinf, please consider giving a like to pub, star to github, and letting other developers know!