How do I pass a mutable State<T> across functions?

[Kapsyloffer]

I have this simple piece of code right here that I call which accepts the url of the game lobby, and 2 moves, p and a.

I've done unit tests and move_rocks works as it should, however the State does not update between these functions, neither may I pass state as mutable without it complaining. If I try to pass "shared" as mutable I get this:

the trait bound `&mut rocket::State<game_hodler::GameHodler>: FromRequest<'_>` is not satisfied
the trait `FromRequest<'_>` is implemented for `&rocket::State<_>`
`FromRequest<'_>` is implemented for `&rocket::State<game_hodler::GameHodler>`, but not for `&mut rocket::State<game_hodler::GameHodler>`

So I guess mut for state is not implemented yet?

This is the one that doesn't work properly:

#[get("/make_move/<url>/<p>/<a>")]
pub fn make_move(url: String, p: String, a: String, shared: &State<GameHodler>) -> RawJson<&'static str>
{
    if parse_move(&url, &p, &shared).is_err() 
    || parse_move(&url, &a, &shared).is_err() 
    || &a.as_bytes()[1] == &p.as_bytes()[1]
    {
        panic!("make_move messed up")
    }

    if move_rocks(&url, &p, &shared).is_ok() && move_rocks(&url, &a, &shared).is_ok()
    {
        return RawJson("we good");
    }

    //panic!()
    return RawJson("we not good");
}

Here is the move_rocks function, not that important but included it just in case. I also translated the comments for clarity.

pub fn move_rocks(url: &String, m: &String, shared: &State<GameHodler>) -> Result<(), ()>
{
    //Check if the move string is valid
    let parsed_move = parse_move(url, m, shared);

    //grab instance from shared
    let mut game_instance = shared.games.lock().expect("nut").get_mut(url).unwrap().clone();

    //If it ain't valid we abort
    if parsed_move.is_err()
    {
        println!("{:?}", parsed_move);
        return Err(());
    }

    let (homeside, colour, x1, y1, x2, y2, aggr) = parsed_move.unwrap();

    let mut board = game_instance.get_board(homeside, colour).unwrap().clone();
    
    let dx = (x2 - x1);
    let dy = (y2 - y1);

    //Get the direction
    let dir = ((dy as f32 / 2.0).round() as i8, (dx as f32 / 2.0).round() as i8);

    //i = amount of steps
    let i = dy.abs().max(dx.abs());

    //print!("\nx1: {}\ny1: {}\nx2: {}\ny2: {}\nΔy: {}\nΔx: {}\ndiry: {}\ndirx: {}\naggr: {}\n\n", x1, y1, x2, y2, dy, dx, dir.0, dir.1, aggr);

    //If our move is invalid we return false
    if !Tile::is_valid(board.get_state(), (x1, y1), (x2, y2), &i, true, (&dir.0, &dir.1))
    {
        println!("Move is not valid apparently.");
        return Err(());
    }
    
    //ELSE WE BALL
    match aggr
    {
        false => Tile::aggressive_move(&mut board, (x1, y1), (x2, y2)),
        true => Tile::passive_move(&mut board, (x1, y1), (x2, y2)),
    };

    println!("{:#?}", board);

    game_instance.get_board(homeside, colour).unwrap().set_state(board.get_state());

    let mut g_i = game_instance.clone();

    println!("{:#?}", g_i.get_board(homeside, colour).unwrap());

    //reinsert instance into shared
    shared.games.lock().expect("Failed to lock").insert(String::from(url), g_i);

    let board = shared.games.lock().expect("Failed to lock").get_mut(url).unwrap().get_board(homeside, colour).unwrap().clone();
    println!("{:#?}", board);
    Ok(())

This is the unit test I used on move_rocks, it allowed me to throw in mut tho 🤔

#[test]
fn test_move_rocks()
{
    let url = String::from("testcase");
    let maw = String::from("BB3210A");

    let binding = GameHodler::new();
    binding.games.lock().expect("nah").insert(url.clone(), Game::new_game());
    
    let mut shared = State::from(&binding);

    let mut game_instance = shared.games.lock().expect("failed to lock").get_mut(&url).unwrap().clone();

    let b4 = game_instance.get_board(Color::Black, Color::Black).unwrap().clone();

    if move_rocks(&url, &maw, &mut shared).is_err()
    {
        panic!("Move_rocks is err.")
    }

    let after = shared.games.lock().expect("failed to lock").get_mut("testcase").unwrap().get_board(Color::Black, Color::Black).unwrap().clone();
    
    assert_ne!(b4.get_state(), after.get_state());
}

Would love to get a proper way to do this, been struggling with this for a few days now.
Thank you in advance.

[SergioBenitez]

Without knowing what a GameHodler actually is, there's no way for anyone to know why your code doesn't do what you expect it to do. In any case, the problem is almost certainly a conceptual misunderstanding of how data sharing works in Rust. Here's the gist: in Rust, there's is no way to directly obtain a mutable borrow to a value in two different threads of execution at the same time. Allowing this would lead to mutable aliasing of said value which is strictly prohibited.

Instead, all mutable sharing of data occurs through shared immutable references, which are read-only and thus allowed to alias across threads, which control access to mutable references to the underlying data. In other words, to get two or more &mut references to data shared across threads, you must go through an & reference that controls access to &mut references. You can find such types in std::sync and tokio::sync. For example, a Mutex<T> allows retrieving an &mut T via lock(&self).

Connecting this to Rocket: any route handler can be executed in any thread at any time, including in parallel and/or concurrently. As such, obtaining an &mut State<T> is strictly prohibited by the same rules, otherwise you'd be able to mutably alias any data, which would be incorrect. As such, if you want to mutate shared data in a route handler, you have to use one of these synchronization types. Here's an example using the same Mutex<T>:

use rocket::tokio::sync::Mutex;

type MyData = Mutex<Data>;

#[get("/")]
fn shared(state: &State<MyData>) {
    let mut mutable = state.lock().await;
    *mutable = new_data();
}

#[launch]
fn rocket() -> _ {
    rocket::build()
        .manage(MyData::new())
        .mount("/", routes![shared])
}