Method handle_session_events

components/scheduler/src/guild_handler.rs:325–406

Applies the side effects of the events produced by the session, returning false when the guild handler should stop.

(&mut self, events: Vec<SessionEvent>)

    /// Applies the side effects of the events produced by the session,
    /// returning false when the guild handler should stop.
    async fn handle_session_events(&mut self, events: Vec<SessionEvent>) -> bool {
        let mut keep_running = true;
        let mut broken_session_cleanup = false;

        let mut queue = VecDeque::from(events);
        while let Some(evt) = queue.pop_front() {
            match evt {
                SessionEvent::ScriptStarted(meta) => {
                    self.script_loaded(meta).await;
                }
                SessionEvent::TaskAcked(task_id) => {
                    self.scheduled_tasks_man.ack_triggered_task(task_id).await;
                }
                SessionEvent::TimerAcked(timer) => {
                    self.interval_timers_man.timer_ack(&timer).await;
                }
                SessionEvent::TaskDispatchCancelled(task_id) => {
                    self.scheduled_tasks_man.remove_pending(task_id);
                }
                SessionEvent::TimerDispatchCancelled(timer) => {
                    self.interval_timers_man.remove_pending(timer);
                }
                SessionEvent::TaskScheduled => {
                    self.scheduled_tasks_man.clear_next();
                }
                SessionEvent::VmIdle => {
                    if let Some(session) = self.session.take() {
                        self.note_worker_returned(session.worker_id());
                        session.return_idle(&self.worker_pool);
                    }
                }
                SessionEvent::VmShutdown { current_vm, reason } => {
                    if current_vm {
                        if let Some(session) = self.session.take() {
                            self.note_worker_returned(session.worker_id());
                            session.return_after_shutdown(&self.worker_pool);
                        }
                        self.force_load_scripts_next = true;
                    } else {
                        // an older vm of ours finished shutting down, the new
                        // vm will send us a new set of timers and tasks
                        self.scheduled_tasks_man.clear_task_names();
                        self.interval_timers_man.clear_loaded_timers();
                    }

                    match reason {
                        Some(ShutdownReason::DiscordInvalidRequestsRatelimit) => {
                            let _ = self
                                .scheduler_tx
                                .send(VmSessionEvent::ShutdownTooManyInvalidRequests);
                            keep_running = false;
                        }
                        Some(ShutdownReason::Runaway) => {
                            let _ = self.scheduler_tx.send(VmSessionEvent::ShutdownExcessCpu);
                            keep_running = false;
                        }
                        _ => {}
                    }