Mut self in Fairings

[ThomasMonkman]

Hello, First off, my rust, is well rusty, so I apologise if I'm using rust the wrong way to achieve what I want.

I am using rocket as a game server, I want a separate thread running the main game loop, to ensure it shuts down correctly I'm using
AdHoc::on_liftoff and AdHoc::on_shutdown to spawn both an thread, and then signal and wait for its shut down. This works, and I'll attach the code.

Adhoc version

let (shutdown_send, shutdown_recv) = tokio::sync::mpsc::channel(1);

// Shared handle for the background task
let loop_handle: Arc<Mutex<Option<JoinHandle<()>>>> = Arc::new(Mutex::new(None));

let _rocket = rocket::build()
    .mount("/", routes![index, data, get_map])
    .attach(AdHoc::on_liftoff("Launch Background Task", {
        let loop_handle_local = Arc::clone(&loop_handle);
        move |_| {
            Box::pin(async move {
                let handle = tokio::spawn(async move {
                    game_loop(shutdown_recv).await;
                });
                *loop_handle_local.lock().await = Some(handle);
            })
        }
    }))
    .attach(AdHoc::on_shutdown("Signal Shutdown", {
            move |_| {
                Box::pin(async move {
                    shutdown_send.send(true).await.unwrap();
                    let mut a = loop_handle.lock().await;
                    if let Some(b) = a.take() {
                        b.await.unwrap();
                    }
                })
            }
    }))
    .attach(Cors)
    .ignite().await?
    .launch().await?;

I saw that the same can be achieved with fairings, this to me seems far neater, as I can have it all self contained. However the callbacks in the fairings don't get access to &mut self?

Attempt at fairings version

pub struct GameLoop {
    shutdown_send: Sender<bool>,
    shutdown_recv: Option<Receiver<bool>>,
    loop_handle: Arc<Mutex<Option<JoinHandle<()>>>>,
}

impl GameLoop {
    fn new() -> GameLoop {
        let (shutdown_send, shutdown_recv) = tokio::sync::mpsc::channel(1);
        GameLoop {
            shutdown_send,
            shutdown_recv: Some(shutdown_recv),
            loop_handle: Arc::new(Mutex::new(None)),
        }
    }
}

#[rocket::async_trait]
impl Fairing for GameLoop {
    fn info(&self) -> Info {
        Info {
            name: "Game loop",
            kind: Kind::Liftoff | Kind::Shutdown,
        }
    }

    // here is the problem
    async fn on_liftoff(&mut self, _: &Rocket<Orbit>) {
        let loop_handle_local = Arc::clone(&(self.loop_handle));
        let mut shutdown = self.shutdown_recv.take().unwrap();
        let handle = tokio::spawn(async move {
            game_loop(shutdown).await;
        });
        *loop_handle_local.lock().await = Some(handle);
    }

    async fn on_shutdown(&self, _: &Rocket<Orbit>) {
        /* ... */
    }
}

Thank you very much, again my rust is not very good, so I appreciate I might be doing things the wrong way etc... but any help would be appreciated!

[huangjj27]

I don't think your GameLoop should responsable for holding the global handle itself. You may try to implement the Fairing using other struct, which will not change itself, but it is the same construction as the AdHoc implementation.