fix: add timeout to SCGI requests to prevent background loop hang

backend/src/main.rs

@@ -45,6 +45,7 @@ pub struct AppState {
     pub db: db::Db,
     #[cfg(feature = "push-notifications")]
     pub push_store: push::PushSubscriptionStore,
+    pub notify_poll: Arc<tokio::sync::Notify>,
 }
 
 async fn auth_middleware(
@@ -336,6 +337,8 @@ async fn main() {
     #[cfg(not(feature = "push-notifications"))]
     let push_store = ();
 
+    let notify_poll = Arc::new(tokio::sync::Notify::new());
+
     let app_state = AppState {
         tx: tx.clone(),
         event_bus: event_bus.clone(),
@@ -343,6 +346,7 @@ async fn main() {
         db: db.clone(),
         #[cfg(feature = "push-notifications")]
         push_store,
+        notify_poll: notify_poll.clone(),
     };
 
     // Spawn background task to poll rTorrent
@@ -351,6 +355,7 @@ async fn main() {
     let socket_path = args.socket.clone(); // Clone for background task
     #[cfg(feature = "push-notifications")]
     let push_store_clone = app_state.push_store.clone();
+    let notify_poll_clone = notify_poll.clone();
 
     tokio::spawn(async move {
         let client = xmlrpc::RtorrentClient::new(&socket_path);
@@ -359,6 +364,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 +442,14 @@ async fn main() {
                     }
 
                     previous_torrents = new_torrents;
+
+                    // Success case: wait for the determined interval OR a wakeup notification
+                    tokio::select! {
+                        _ = tokio::time::sleep(loop_interval) => {},
+                        _ = notify_poll_clone.notified() => {
+                            tracing::debug!("Background loop awakened by new client connection");
+                        }
+                    }
                 }
                 Err(e) => {
                     tracing::error!("Error fetching torrents in background: {}", e);
@@ -449,20 +470,15 @@ async fn main() {
                         "Backoff: Sleeping for {:?} due to rTorrent error.",
                         backoff_duration
                     );
+                    
+                    tokio::time::sleep(backoff_duration).await;
                 }
             }
 
             // Handle Stats
-            match stats_result {
+            if let Ok(stats) = stats_result {
-                Ok(stats) => {
+                let _ = event_bus_tx.send(AppEvent::Stats(stats));
-                    let _ = event_bus_tx.send(AppEvent::Stats(stats));
-                }
-                Err(e) => {
-                    tracing::warn!("Error fetching global stats: {}", e);
-                }
             }
-
-            tokio::time::sleep(backoff_duration).await;
         }
     });
 

backend/src/scgi.rs

@@ -11,6 +11,8 @@ pub enum ScgiError {
     #[allow(dead_code)]
     #[error("Protocol Error: {0}")]
     Protocol(String),
+    #[error("Timeout: SCGI request took too long")]
+    Timeout,
 }
 
 pub struct ScgiRequest {
@@ -78,20 +80,30 @@ impl ScgiRequest {
 }
 
 pub async fn send_request(socket_path: &str, request: ScgiRequest) -> Result<Bytes, ScgiError> {
-    let mut stream = UnixStream::connect(socket_path).await?;
+    let perform_request = async {
-    let data = request.encode();
+        let mut stream = UnixStream::connect(socket_path).await?;
-    stream.write_all(&data).await?;
+        let data = request.encode();
+        stream.write_all(&data).await?;
 
-    let mut response = Vec::new();
+        let mut response = Vec::new();
-    stream.read_to_end(&mut response).await?;
+        stream.read_to_end(&mut response).await?;
+        Ok::<Vec<u8>, std::io::Error>(response)
+    };
+
+    let response = tokio::time::timeout(std::time::Duration::from_secs(10), perform_request)
+        .await
+        .map_err(|_| ScgiError::Timeout)??;
 
     let double_newline = b"\r\n\r\n";
-    if let Some(pos) = response
+    let mut response_vec = response;
+    if let Some(pos) = response_vec
         .windows(double_newline.len())
         .position(|window| window == double_newline)
     {
-        Ok(Bytes::from(response.split_off(pos + double_newline.len())))
+        Ok(Bytes::from(
+            response_vec.split_off(pos + double_newline.len()),
+        ))
     } else {
-        Ok(Bytes::from(response))
+        Ok(Bytes::from(response_vec))
     }
 }

backend/src/sse.rs

@@ -195,6 +195,9 @@ pub async fn fetch_global_stats(client: &RtorrentClient) -> Result<GlobalStats,
 pub async fn sse_handler(
     State(state): State<AppState>,
 ) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
+    // Notify background worker to wake up and poll immediately
+    state.notify_poll.notify_one();
+
     // Get initial value synchronously (from the watch channel's current state)
     let initial_rx = state.tx.subscribe();
     let initial_torrents = initial_rx.borrow().clone();

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
+        store.torrents.with(|map| {
-            .torrents
+            map.values()
-            .get()
+                .filter(|t| t.status == shared::TorrentStatus::Downloading)
-            .iter()
+                .count()
-            .filter(|t| t.status == shared::TorrentStatus::Downloading)
+        })
-            .count()
     };
     let seeding_count = move || {
-        store
+        store.torrents.with(|map| {
-            .torrents
+            map.values()
-            .get()
+                .filter(|t| t.status == shared::TorrentStatus::Seeding)
-            .iter()
+                .count()
-            .filter(|t| t.status == shared::TorrentStatus::Seeding)
+        })
-            .count()
     };
     let completed_count = move || {
-        store
+        store.torrents.with(|map| {
-            .torrents
+            map.values()
-            .get()
+                .filter(|t| {
-            .iter()
+                    t.status == shared::TorrentStatus::Seeding
-            .filter(|t| {
+                        || (t.status == shared::TorrentStatus::Paused && t.percent_complete >= 100.0)
-                t.status == shared::TorrentStatus::Seeding
+                })
-                    || (t.status == shared::TorrentStatus::Paused && t.percent_complete >= 100.0)
+                .count()
-            })
+        })
-            .count()
     };
     let paused_count = move || {
-        store
+        store.torrents.with(|map| {
-            .torrents
+            map.values()
-            .get()
+                .filter(|t| t.status == shared::TorrentStatus::Paused)
-            .iter()
+                .count()
-            .filter(|t| t.status == shared::TorrentStatus::Paused)
+        })
-            .count()
     };
     let inactive_count = move || {
-        store
+        store.torrents.with(|map| {
-            .torrents
+            map.values()
-            .get()
+                .filter(|t| {
-            .iter()
+                    t.status == shared::TorrentStatus::Paused
-            .filter(|t| {
+                        || t.status == shared::TorrentStatus::Error
-                t.status == shared::TorrentStatus::Paused
+                })
-                    || t.status == shared::TorrentStatus::Error
+                .count()
-            })
+        })
-            .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
+        // Convert HashMap values to Vec for filtering and sorting
-            .torrents
+        let torrents: Vec<shared::Torrent> = store.torrents.with(|map| map.values().cloned().collect());
-            .get()
+
+        let mut torrents = torrents
             .into_iter()
             .filter(|t| {
                 let filter = store.filter.get();
@@ -253,7 +254,7 @@ pub fn TorrentTable() -> impl IntoView {
                                  <div class="flex items-center">"Status" {move || sort_arrow(SortColumn::Status)}</div>
                             </th>
                             <th class="w-24 cursor-pointer hover:bg-base-300 group select-none" on:click=move |_| handle_sort(SortColumn::DownSpeed)>
-                                 <div class="flex items-center">"Down Speed" {move || sort_arrow(SortColumn::DownSpeed)}</div>
+                                 <div class="flex items-center">"DL Speed" {move || sort_arrow(SortColumn::DownSpeed)}</div>
                             </th>
                             <th class="w-24 cursor-pointer hover:bg-base-300 group select-none" on:click=move |_| handle_sort(SortColumn::UpSpeed)>
                                  <div class="flex items-center">"Up Speed" {move || sort_arrow(SortColumn::UpSpeed)}</div>
@@ -344,7 +345,7 @@ pub fn TorrentTable() -> impl IntoView {
                                                   (SortColumn::Size, "Size"),
                                                   (SortColumn::Progress, "Progress"),
                                                   (SortColumn::Status, "Status"),
-                                                  (SortColumn::DownSpeed, "Down Speed"),
+                                                  (SortColumn::DownSpeed, "DL Speed"),
                                                   (SortColumn::UpSpeed, "Up Speed"),
                                                   (SortColumn::ETA, "ETA"),
                                                   (SortColumn::AddedDate, "Date"),

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| {
+                                                    torrents.update(|map| {
-                                                        if let Some(t) = list.iter_mut().find(|t| t.hash == update.hash)
+                                                        if let Some(t) = map.get_mut(&update.hash) {
-                                                        {
                                                             if let Some(name) = update.name {
                                                                 t.name = name;
                                                             }