Method run

components/vm/src/vm.rs:208–255

(&mut self)

    }

    pub async fn run(&mut self) {
        self.emit_isolate_handle();

        info!("running runtime");
        self.guild_logger
            .log(CreateLogEntry::info("guild vm started".to_string()));

        let mut completed = false;
        while !self.check_terminated() {
            let fut = TickFuture {
                rx: &mut self.rx,
                rt: &mut self.runtime,
                wakeup: &mut self.wakeup_rx,
                completed,
            };

            completed = false;

            match fut.await {
                TickResult::Command(Some(cmd)) => {
                    self.handle_cmd(cmd).await;
                }
                TickResult::Command(None) => {
                    // sender was dropped, shut ourselves down?
                }
                TickResult::Continue => {}
                TickResult::VmError(e) => {
                    self.guild_logger.log(CreateLogEntry::error(format!(
                        "Script error occurred: {}",
                        e
                    )));
                }
                TickResult::Completed => {
                    let _ = self.tx.send(VmEvent::VmFinished);
                    completed = true;
                }
            }
        }

        info!("terminating runtime for guild");

        let shutdown_reason = { self.shutdown_handle.read_shutdown_reason() };

        if let Some(ShutdownReason::Request) = shutdown_reason {
            // cleanly finish the futures
            self.stop_vm().await;
        }
    }

    fn check_terminated(&mut self) -> bool {
        self.shutdown_handle