Method handle_scheduler_command

components/scheduler/src/scheduler.rs:196–284

(&mut self, cmd: SchedulerCommand)

    }

    async fn handle_scheduler_command(&mut self, cmd: SchedulerCommand) {
        match cmd {
            // we shut down all previously running workers when a new broker connects
            // this is because we could be out of sync otherwise and running guilds we shouldn't run
            SchedulerCommand::BrokerHello(d) => {
                info!("new broker connected");
                self.shutdown_all();

                self.pending_starts = Vec::new();

                // start all the workers we can
                for g in d.connected_guilds {
                    if !self.try_unsuspend_guild(g) {
                        continue;
                    }

                    let worker = self.get_or_start_guild(g);
                    if worker.tx.is_none() {
                        // this worker shutting down, schedule it for restart
                        self.pending_starts.push(g)
                    }
                }
            }

            SchedulerCommand::BrokerDisconnected => {
                self.shutdown_all();
            }
            SchedulerCommand::BrokerConnected => {}
            SchedulerCommand::DiscordEvent(evt) => {
                crate::dispatch_metrics::record_stage("scheduler_recv", "discord", evt.timestamp);

                if !self.try_unsuspend_guild(evt.guild_id) {
                    return;
                }

                if let DiscordEventData::GuildDelete(_) = evt.event {
                    if let Some(worker) = self.guilds.get_mut(&evt.guild_id) {
                        // this will signal the worker to shut down
                        if let Some(tx) = worker.tx.take() {
                            let _ = tx.send(GuildCommand::Shutdown);
                        }
                    }
                } else {
                    self.send_or_queue_broker_evt(evt)
                }
            }
            SchedulerCommand::Shutdown => {
                panic!("should be handled by caller")
            }
            SchedulerCommand::ReloadGuildScripts(guild_id) => {
                // reset the blacklisted state
                if self.try_unsuspend_guild(guild_id) {
                    self.get_or_start_guild(guild_id);
                } else {
                    self.logger.log(LogEntry::error(
                        guild_id,
                        "can't unsuspend your guild yet, please wait 10 minutes".to_owned(),
                    ));