From a225c14b4fdaafe390dc8840065946d8c2a2e4b8 Mon Sep 17 00:00:00 2001
From: Brendan Golden <git@brendan.ie>
Date: Mon, 21 Jul 2025 04:29:03 +0100
Subject: [PATCH] fix: was ddossing the poor database

guild_members_chunk is triggered for each chunk for each server it is on, and the bot is currently in 10 servers so it was runnign teh same thigns 10 times, clogging up conenctions
---
 src/bin/cleanup_committee.rs | 18 +++++++++++++-----
 src/bin/update_committee.rs  | 18 +++++++++++++-----
 src/bin/update_users.rs      | 27 ++++++++++++++++++++-------
 3 files changed, 46 insertions(+), 17 deletions(-)

diff --git a/src/bin/cleanup_committee.rs b/src/bin/cleanup_committee.rs
index c6485a7..188cc5b 100644
--- a/src/bin/cleanup_committee.rs
+++ b/src/bin/cleanup_committee.rs
@@ -52,15 +52,23 @@ async fn main() {
 struct Handler;
 #[async_trait]
 impl EventHandler for Handler {
-  async fn cache_ready(&self, ctx: Context, guilds: Vec<GuildId>) {
-    for guild in guilds {
-      ctx.shard.chunk_guild(guild, Some(2000), false, ChunkGuildFilter::None, None);
-    }
-    println!("Cache built successfully!");
+  async fn cache_ready(&self, ctx: Context, _guilds: Vec<GuildId>) {
+    let config_lock = {
+      let data_read = ctx.data.read().await;
+      data_read.get::<Config>().expect("Expected Config in TypeMap.").clone()
+    };
+    let config_global = config_lock.read().await;
+
+    let server = config_global.committee_server;
+
+    ctx.shard.chunk_guild(server, Some(2000), false, ChunkGuildFilter::None, None);
+
+    println!("Cache loaded");
   }
 
   async fn guild_members_chunk(&self, ctx: Context, chunk: GuildMembersChunkEvent) {
     if (chunk.chunk_index + 1) == chunk.chunk_count {
+      println!("Cache built successfully!");
       let db_lock = {
         let data_read = ctx.data.read().await;
         data_read.get::<DataBase>().expect("Expected Config in TypeMap.").clone()
diff --git a/src/bin/update_committee.rs b/src/bin/update_committee.rs
index b2792e0..b8cc6c2 100644
--- a/src/bin/update_committee.rs
+++ b/src/bin/update_committee.rs
@@ -47,15 +47,23 @@ async fn main() {
 struct Handler;
 #[async_trait]
 impl EventHandler for Handler {
-  async fn cache_ready(&self, ctx: Context, guilds: Vec<GuildId>) {
-    for guild in guilds {
-      ctx.shard.chunk_guild(guild, Some(2000), false, ChunkGuildFilter::None, None);
-    }
-    println!("Cache built successfully!");
+  async fn cache_ready(&self, ctx: Context, _guilds: Vec<GuildId>) {
+    let config_lock = {
+      let data_read = ctx.data.read().await;
+      data_read.get::<Config>().expect("Expected Config in TypeMap.").clone()
+    };
+    let config_global = config_lock.read().await;
+
+    let server = config_global.committee_server;
+
+    ctx.shard.chunk_guild(server, Some(2000), false, ChunkGuildFilter::None, None);
+
+    println!("Cache loaded");
   }
 
   async fn guild_members_chunk(&self, ctx: Context, chunk: GuildMembersChunkEvent) {
     if (chunk.chunk_index + 1) == chunk.chunk_count {
+      println!("Cache built successfully!");
       // u[date committee server
       committee::check_committee(&ctx).await;
 
diff --git a/src/bin/update_users.rs b/src/bin/update_users.rs
index 6ac9e00..0cb11ac 100644
--- a/src/bin/update_users.rs
+++ b/src/bin/update_users.rs
@@ -12,6 +12,7 @@ use skynet_discord_bot::{
   },
   get_config, Config,
 };
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::{process, sync::Arc};
 use tokio::sync::RwLock;
 
@@ -27,7 +28,10 @@ async fn main() {
   let intents = GatewayIntents::GUILDS | GatewayIntents::GUILD_MESSAGES | GatewayIntents::MESSAGE_CONTENT | GatewayIntents::GUILD_MEMBERS;
   // Build our client.
   let mut client = Client::builder(&config.discord_token, intents)
-    .event_handler(Handler {})
+    .event_handler(Handler {
+      server_count: Default::default(),
+      server_cached: Default::default(),
+    })
     .cache_settings(serenity::cache::Settings::default())
     .await
     .expect("Error creating client");
@@ -44,23 +48,32 @@ async fn main() {
   }
 }
 
-struct Handler;
+struct Handler {
+  server_count: AtomicUsize,
+  server_cached: AtomicUsize,
+}
 #[async_trait]
 impl EventHandler for Handler {
   async fn cache_ready(&self, ctx: Context, guilds: Vec<GuildId>) {
+    self.server_count.swap(guilds.len(), Ordering::SeqCst);
     for guild in guilds {
       ctx.shard.chunk_guild(guild, Some(2000), false, ChunkGuildFilter::None, None);
     }
-    println!("Cache built successfully!");
+    println!("Cache loaded {}", &self.server_count.load(Ordering::SeqCst));
   }
 
   async fn guild_members_chunk(&self, ctx: Context, chunk: GuildMembersChunkEvent) {
     if (chunk.chunk_index + 1) == chunk.chunk_count {
-      // this goes into each server and sets roles for each wolves member
-      check_bulk(&ctx).await;
+      self.server_cached.fetch_add(1, Ordering::SeqCst);
+      if (self.server_cached.load(Ordering::SeqCst) + 1) == self.server_count.load(Ordering::SeqCst) {
+        println!("Cache built successfully!");
 
-      // finish up
-      process::exit(0);
+        // this goes into each server and sets roles for each wolves member
+        check_bulk(&ctx).await;
+
+        // finish up
+        process::exit(0);
+      }
     }
   }
 }