recording: keep one buffer per guild

1 files changed, 27 insertions, 20 deletions

diff --git a/src/voice/mod.rs b/src/voice/mod.rs
index 0b6022c..bbb73a0 100644
--- a/src/voice/mod.rs
+++ b/src/voice/mod.rs
@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::io::Cursor;
 use std::pin::Pin;
 use std::sync::Arc;
@@ -28,11 +29,13 @@ const RECORDING_SAMPLE_RATE: u32 = 48000;
 #[derive(Clone)]
 pub struct VoiceManager {
     pub songbird: Arc<Songbird>,
-    /// Live recorder for the bot's current voice connection, if any.
+    /// Live recorder per guild, if any.
     ///
-    /// `None` whenever the bot is not connected (or recording is disabled) —
-    /// so the ~86 MB ring only exists while actually recording a 15 min window.
-    pub recorder: Arc<Mutex<Option<Arc<Recorder>>>>,
+    /// Entries exist only while the bot is connected (and recording) in that
+    /// guild, so the ~86 MB ring only exists while actually recording. Keying
+    /// by guild prevents one guild's connection from replacing or stopping
+    /// another guild's buffer.
+    pub recorders: Arc<Mutex<HashMap<GuildId, Arc<Recorder>>>>,
     pub recording_enabled: bool,
     pub recording_window_seconds: u64,
 }
@@ -50,7 +53,7 @@ impl VoiceManager {
             ))?;
         Ok(Self {
             songbird,
-            recorder: Arc::new(Mutex::new(None)),
+            recorders: Arc::new(Mutex::new(HashMap::new())),
             recording_enabled,
             recording_window_seconds,
         })
@@ -60,10 +63,10 @@ impl VoiceManager {
         self.recording_enabled
     }
 
-    /// Construct a `Recorder`, register its `VoiceTick` handler on `call`, and
-    /// store the strong `Arc` in the slot. Idempotent: if the slot already
-    /// holds a recorder, the caller is responsible for not double-registering.
-    pub async fn start_recording(&self, call: &Arc<Mutex<Call>>) {
+    /// Construct a `Recorder` for `guild_id`, register its `VoiceTick` handler
+    /// on `call`, and store the strong `Arc`. Replacing an existing entry drops
+    /// the previous ring; its handler's `Weak` then no-ops.
+    pub async fn start_recording(&self, guild_id: GuildId, call: &Arc<Mutex<Call>>) {
         if !self.recording_enabled {
             return;
         }
@@ -79,25 +82,29 @@ impl VoiceManager {
                 handler,
             );
         }
-        *self.recorder.lock().await = Some(recorder);
+        self.recorders
+            .lock()
+            .await
+            .insert(guild_id, recorder);
         info!(
+            guild = %guild_id,
             window_secs = self.recording_window_seconds,
             "recording: started rolling buffer for this voice connection"
         );
     }
 
-    /// Drop the live recorder (frees the ring immediately). The songbird `Call`
-    /// may still exist briefly; the handler's `Weak` upgrades to `None` thereafter.
-    pub async fn stop_recording(&self) {
-        let prev = self.recorder.lock().await.take();
+    /// Drop this guild's live recorder (frees the ring immediately). The
+    /// songbird `Call` may still exist briefly; the handler's `Weak` then no-ops.
+    pub async fn stop_recording(&self, guild_id: GuildId) {
+        let prev = self.recorders.lock().await.remove(&guild_id);
         if prev.is_some() {
-            info!("recording: stopped, ring buffer freed");
+            info!(guild = %guild_id, "recording: stopped, ring buffer freed");
         }
     }
 
-    /// Clone of the live recorder `Arc`, if any — used by `/record` to snapshot.
-    pub async fn get_recorder(&self) -> Option<Arc<Recorder>> {
-        self.recorder.lock().await.clone()
+    /// Clone of this guild's live recorder, if any — used by `/record`.
+    pub async fn get_recorder(&self, guild_id: GuildId) -> Option<Arc<Recorder>> {
+        self.recorders.lock().await.get(&guild_id).cloned()
     }
 
     pub async fn connect(
@@ -115,7 +122,7 @@ impl VoiceManager {
                     // (The bot's own VoiceStateUpdate also reconciles, but may
                     // race songbird's Call creation — this never misses.)
                     if self.recording_enabled {
-                        self.start_recording(&call).await;
+                        self.start_recording(guild_id, &call).await;
                     }
                     return Ok(call);
                 }
@@ -143,7 +150,7 @@ impl VoiceManager {
     pub async fn disconnect(&self, guild_id: GuildId) -> Result<()> {
         // Free the ring before tearing down the Call — the handler's `Weak`
         // will then no-op any in-flight ticks until songbird drops it.
-        self.stop_recording().await;
+        self.stop_recording(guild_id).await;
         self.songbird
             .remove(guild_id)
             .await