perf: implement dynamic polling interval based on active clients

backend/src/main.rs

@@ -359,6 +359,14 @@ async fn main() {
         let mut backoff_duration = Duration::from_secs(1);
 
         loop {
+            // Determine polling interval based on active clients
+            let active_clients = event_bus_tx.receiver_count();
+            let loop_interval = if active_clients > 0 {
+                Duration::from_secs(1)
+            } else {
+                Duration::from_secs(30)
+            };
+
             // 1. Fetch Torrents
             let torrents_result = sse::fetch_torrents(&client).await;
 
@@ -429,6 +437,9 @@ async fn main() {
                     }
 
                     previous_torrents = new_torrents;
+
+                    // Success case: sleep for the determined interval
+                    tokio::time::sleep(loop_interval).await;
                 }
                 Err(e) => {
                     tracing::error!("Error fetching torrents in background: {}", e);
@@ -449,20 +460,15 @@ async fn main() {
                         "Backoff: Sleeping for {:?} due to rTorrent error.",
                         backoff_duration
                     );
+                    
+                    tokio::time::sleep(backoff_duration).await;
                 }
             }
 
             // Handle Stats
-            match stats_result {
-                Ok(stats) => {
-                    let _ = event_bus_tx.send(AppEvent::Stats(stats));
-                }
-                Err(e) => {
-                    tracing::warn!("Error fetching global stats: {}", e);
-                }
+            if let Ok(stats) = stats_result {
+                let _ = event_bus_tx.send(AppEvent::Stats(stats));
             }
-
-            tokio::time::sleep(backoff_duration).await;
         }
     });
 

frontend/src/components/layout/sidebar.rs

@@ -6,52 +6,47 @@ use crate::api;
 pub fn Sidebar() -> impl IntoView {
     let store = use_context::<crate::store::TorrentStore>().expect("store not provided");
 
-    let total_count = move || store.torrents.get().len();
+    let total_count = move || store.torrents.with(|map| map.len());
     let downloading_count = move || {
-        store
-            .torrents
-            .get()
-            .iter()
-            .filter(|t| t.status == shared::TorrentStatus::Downloading)
-            .count()
+        store.torrents.with(|map| {
+            map.values()
+                .filter(|t| t.status == shared::TorrentStatus::Downloading)
+                .count()
+        })
     };
     let seeding_count = move || {
-        store
-            .torrents
-            .get()
-            .iter()
-            .filter(|t| t.status == shared::TorrentStatus::Seeding)
-            .count()
+        store.torrents.with(|map| {
+            map.values()
+                .filter(|t| t.status == shared::TorrentStatus::Seeding)
+                .count()
+        })
     };
     let completed_count = move || {
-        store
-            .torrents
-            .get()
-            .iter()
-            .filter(|t| {
-                t.status == shared::TorrentStatus::Seeding
-                    || (t.status == shared::TorrentStatus::Paused && t.percent_complete >= 100.0)
-            })
-            .count()
+        store.torrents.with(|map| {
+            map.values()
+                .filter(|t| {
+                    t.status == shared::TorrentStatus::Seeding
+                        || (t.status == shared::TorrentStatus::Paused && t.percent_complete >= 100.0)
+                })
+                .count()
+        })
     };
     let paused_count = move || {
-        store
-            .torrents
-            .get()
-            .iter()
-            .filter(|t| t.status == shared::TorrentStatus::Paused)
-            .count()
+        store.torrents.with(|map| {
+            map.values()
+                .filter(|t| t.status == shared::TorrentStatus::Paused)
+                .count()
+        })
     };
     let inactive_count = move || {
-        store
-            .torrents
-            .get()
-            .iter()
-            .filter(|t| {
-                t.status == shared::TorrentStatus::Paused
-                    || t.status == shared::TorrentStatus::Error
-            })
-            .count()
+        store.torrents.with(|map| {
+            map.values()
+                .filter(|t| {
+                    t.status == shared::TorrentStatus::Paused
+                        || t.status == shared::TorrentStatus::Error
+                })
+                .count()
+        })
     };
 
     let close_drawer = move || {

frontend/src/components/torrent/table.rs

@@ -82,9 +82,10 @@ pub fn TorrentTable() -> impl IntoView {
     let sort_dir = create_rw_signal(SortDirection::Descending);
 
     let filtered_torrents = move || {
-        let mut torrents = store
-            .torrents
-            .get()
+        // Convert HashMap values to Vec for filtering and sorting
+        let torrents: Vec<shared::Torrent> = store.torrents.with(|map| map.values().cloned().collect());
+
+        let mut torrents = torrents
             .into_iter()
             .filter(|t| {
                 let filter = store.filter.get();

frontend/src/store.rs

@@ -113,9 +113,11 @@ impl FilterStatus {
     }
 }
 
+use std::collections::HashMap;
+
 #[derive(Clone, Copy, Debug)]
 pub struct TorrentStore {
-    pub torrents: RwSignal<Vec<Torrent>>,
+    pub torrents: RwSignal<HashMap<String, Torrent>>,
     pub filter: RwSignal<FilterStatus>,
     pub search_query: RwSignal<String>,
     pub global_stats: RwSignal<GlobalStats>,
@@ -124,7 +126,7 @@ pub struct TorrentStore {
 }
 
 pub fn provide_torrent_store() {
-    let torrents = create_rw_signal(Vec::<Torrent>::new());
+    let torrents = create_rw_signal(HashMap::new());
     let filter = create_rw_signal(FilterStatus::All);
     let search_query = create_rw_signal(String::new());
     let global_stats = create_rw_signal(GlobalStats::default());
@@ -193,12 +195,15 @@ pub fn provide_torrent_store() {
                                         if let Ok(event) = serde_json::from_str::<AppEvent>(&data_str) {
                                             match event {
                                                 AppEvent::FullList { torrents: list, .. } => {
-                                                    torrents.set(list);
+                                                    let map: HashMap<String, Torrent> = list
+                                                        .into_iter()
+                                                        .map(|t| (t.hash.clone(), t))
+                                                        .collect();
+                                                    torrents.set(map);
                                                 }
                                                 AppEvent::Update(update) => {
-                                                    torrents.update(|list| {
-                                                        if let Some(t) = list.iter_mut().find(|t| t.hash == update.hash)
-                                                        {
+                                                    torrents.update(|map| {
+                                                        if let Some(t) = map.get_mut(&update.hash) {
                                                             if let Some(name) = update.name {
                                                                 t.name = name;
                                                             }