debug: log user value in SSE loop

frontend/src/app.rs

@@ -25,9 +25,7 @@ pub fn App() -> impl IntoView {
             match setup_res {
                 Ok(status) => {
                     if !status.completed {
-                        log::info!("Setup not completed, redirecting to /setup");
+                        log::info!("Setup not completed");
-                        let navigate = use_navigate();
-                        navigate("/setup", Default::default());
                         is_loading.1.set(false);
                         return;
                     }
@@ -48,27 +46,12 @@ pub fn App() -> impl IntoView {
                     }
 
                     is_authenticated.1.set(true);
-
-                    let pathname = window().location().pathname().unwrap_or_default();
-                    if pathname == "/login" || pathname == "/setup" {
-                        log::info!("Already authenticated, redirecting to home");
-                        let navigate = use_navigate();
-                        navigate("/", Default::default());
-                    }
                 }
                 Ok(false) => {
                     log::info!("Not authenticated");
-
-                    let pathname = window().location().pathname().unwrap_or_default();
-                    if pathname != "/login" && pathname != "/setup" {
-                        let navigate = use_navigate();
-                        navigate("/login", Default::default());
-                    }
                 }
                 Err(e) => {
                     log::error!("Auth check failed: {:?}", e);
-                    let navigate = use_navigate();
-                    navigate("/login", Default::default());
                 }
             }
 
@@ -92,10 +75,39 @@ pub fn App() -> impl IntoView {
         <div class="relative w-full h-screen" style="height: 100dvh;">
             <Router>
                 <Routes fallback=|| view! { <div class="p-4">"404 Not Found"</div> }>
-                    <Route path=leptos_router::path!("/login") view=move || view! { <Login /> } />
+                    <Route path=leptos_router::path!("/login") view=move || {
-                    <Route path=leptos_router::path!("/setup") view=move || view! { <Setup /> } />
+                        let authenticated = is_authenticated.0.get();
+                        
+                        Effect::new(move |_| {
+                            if authenticated {
+                                log::info!("Already authenticated, redirecting to home");
+                                let navigate = use_navigate();
+                                navigate("/", Default::default());
+                            }
+                        });
+                        
+                        view! { <Login /> }
+                    } />
+                    <Route path=leptos_router::path!("/setup") view=move || {
+                        Effect::new(move |_| {
+                            if is_authenticated.0.get() {
+                                let navigate = use_navigate();
+                                navigate("/", Default::default());
+                            }
+                        });
+                        
+                        view! { <Setup /> }
+                    } />
 
                     <Route path=leptos_router::path!("/") view=move || {
+                        Effect::new(move |_| {
+                            if !is_loading.0.get() && !is_authenticated.0.get() {
+                                log::info!("Not authenticated, redirecting to login");
+                                let navigate = use_navigate();
+                                navigate("/login", Default::default());
+                            }
+                        });
+                        
                         view! {
                             <Show when=move || !is_loading.0.get() fallback=|| view! {
                                 <div class="flex items-center justify-center h-screen bg-base-100">
@@ -112,6 +124,13 @@ pub fn App() -> impl IntoView {
                     }/>
 
                     <Route path=leptos_router::path!("/settings") view=move || {
+                        Effect::new(move |_| {
+                            if !is_authenticated.0.get() {
+                                let navigate = use_navigate();
+                                navigate("/login", Default::default());
+                            }
+                        });
+                        
                         view! {
                             <Show when=move || !is_loading.0.get() fallback=|| ()>
                                 <Show when=move || is_authenticated.0.get() fallback=|| ()>
@@ -128,4 +147,4 @@ pub fn App() -> impl IntoView {
             <ToastContainer />
         </div>
     }
-}
+}

frontend/src/components/torrent/table.rs

@@ -51,44 +51,49 @@ pub fn TorrentTable() -> impl IntoView {
     let sort_dir = signal(SortDirection::Descending);
 
     let filtered_hashes = move || {
-        store.torrents.with(|map| {
+        let torrents_map = store.torrents.get();
-            let mut torrents: Vec<&shared::Torrent> = map.values().filter(|t| {
+        log::debug!("TorrentTable: store.torrents has {} entries", torrents_map.len());
-                let filter = store.filter.get();
+        
-                let search = store.search_query.get().to_lowercase();
+        let filter = store.filter.get();
-                let matches_filter = match filter {
+        let search = store.search_query.get();
-                    crate::store::FilterStatus::All => true,
+        let search_lower = search.to_lowercase();
-                    crate::store::FilterStatus::Downloading => t.status == shared::TorrentStatus::Downloading,
+        
-                    crate::store::FilterStatus::Seeding => t.status == shared::TorrentStatus::Seeding,
+        let mut torrents: Vec<&shared::Torrent> = torrents_map.values().filter(|t| {
-                    crate::store::FilterStatus::Completed => t.status == shared::TorrentStatus::Seeding || (t.status == shared::TorrentStatus::Paused && t.percent_complete >= 100.0),
+            let matches_filter = match filter {
-                    crate::store::FilterStatus::Paused => t.status == shared::TorrentStatus::Paused,
+                crate::store::FilterStatus::All => true,
-                    crate::store::FilterStatus::Inactive => t.status == shared::TorrentStatus::Paused || t.status == shared::TorrentStatus::Error,
+                crate::store::FilterStatus::Downloading => t.status == shared::TorrentStatus::Downloading,
-                    _ => true,
+                crate::store::FilterStatus::Seeding => t.status == shared::TorrentStatus::Seeding,
-                };
+                crate::store::FilterStatus::Completed => t.status == shared::TorrentStatus::Seeding || (t.status == shared::TorrentStatus::Paused && t.percent_complete >= 100.0),
-                let matches_search = if search.is_empty() { true } else { t.name.to_lowercase().contains(&search) };
+                crate::store::FilterStatus::Paused => t.status == shared::TorrentStatus::Paused,
-                matches_filter && matches_search
+                crate::store::FilterStatus::Inactive => t.status == shared::TorrentStatus::Paused || t.status == shared::TorrentStatus::Error,
-            }).collect();
+                _ => true,
+            };
+            let matches_search = if search_lower.is_empty() { true } else { t.name.to_lowercase().contains(&search_lower) };
+            matches_filter && matches_search
+        }).collect();
 
-            torrents.sort_by(|a, b| {
+        log::debug!("TorrentTable: {} torrents after filtering", torrents.len());
-                let col = sort_col.0.get();
+
-                let dir = sort_dir.0.get();
+        torrents.sort_by(|a, b| {
-                let cmp = match col {
+            let col = sort_col.0.get();
-                    SortColumn::Name => a.name.to_lowercase().cmp(&b.name.to_lowercase()),
+            let dir = sort_dir.0.get();
-                    SortColumn::Size => a.size.cmp(&b.size),
+            let cmp = match col {
-                    SortColumn::Progress => a.percent_complete.partial_cmp(&b.percent_complete).unwrap_or(std::cmp::Ordering::Equal),
+                SortColumn::Name => a.name.to_lowercase().cmp(&b.name.to_lowercase()),
-                    SortColumn::Status => format!("{:?}", a.status).cmp(&format!("{:?}", b.status)),
+                SortColumn::Size => a.size.cmp(&b.size),
-                    SortColumn::DownSpeed => a.down_rate.cmp(&b.down_rate),
+                SortColumn::Progress => a.percent_complete.partial_cmp(&b.percent_complete).unwrap_or(std::cmp::Ordering::Equal),
-                    SortColumn::UpSpeed => a.up_rate.cmp(&b.up_rate),
+                SortColumn::Status => format!("{:?}", a.status).cmp(&format!("{:?}", b.status)),
-                    SortColumn::ETA => {
+                SortColumn::DownSpeed => a.down_rate.cmp(&b.down_rate),
-                        let a_eta = if a.eta <= 0 { i64::MAX } else { a.eta };
+                SortColumn::UpSpeed => a.up_rate.cmp(&b.up_rate),
-                        let b_eta = if b.eta <= 0 { i64::MAX } else { b.eta };
+                SortColumn::ETA => {
-                        a_eta.cmp(&b_eta)
+                    let a_eta = if a.eta <= 0 { i64::MAX } else { a.eta };
-                    }
+                    let b_eta = if b.eta <= 0 { i64::MAX } else { b.eta };
-                    SortColumn::AddedDate => a.added_date.cmp(&b.added_date),
+                    a_eta.cmp(&b_eta)
-                };
+                }
-                if dir == SortDirection::Descending { cmp.reverse() } else { cmp }
+                SortColumn::AddedDate => a.added_date.cmp(&b.added_date),
-            });
+            };
-            torrents.into_iter().map(|t| t.hash.clone()).collect::<Vec<String>>()
+            if dir == SortDirection::Descending { cmp.reverse() } else { cmp }
-        })
+        });
+        torrents.into_iter().map(|t| t.hash.clone()).collect::<Vec<String>>()
     };
 
     let handle_sort = move |col: SortColumn| {

frontend/src/store.rs

@@ -1,6 +1,7 @@
 use futures::StreamExt;
 use gloo_net::eventsource::futures::EventSource;
 use leptos::prelude::*;
+use leptos::task::spawn_local;
 use shared::{AppEvent, GlobalStats, NotificationLevel, SystemNotification, Torrent};
 use std::collections::HashMap;
 use serde::{Serialize, Deserialize};
@@ -11,10 +12,6 @@ pub struct NotificationItem {
     pub notification: SystemNotification,
 }
 
-// ============================================================================
-// Toast Helper Functions
-// ============================================================================
-
 pub fn show_toast_with_signal(
     notifications: RwSignal<Vec<NotificationItem>>,
     level: NotificationLevel,
@@ -29,7 +26,6 @@ pub fn show_toast_with_signal(
 
     notifications.update(|list| list.push(item));
 
-    // Auto-remove after 5 seconds
     leptos::prelude::set_timeout(
         move || {
             notifications.update(|list| list.retain(|i| i.id != id));
@@ -47,10 +43,6 @@ pub fn show_toast(level: NotificationLevel, message: impl Into<String>) {
 pub fn toast_success(message: impl Into<String>) { show_toast(NotificationLevel::Success, message); }
 pub fn toast_error(message: impl Into<String>) { show_toast(NotificationLevel::Error, message); }
 
-// ============================================================================
-// Action Message Mapping
-// ============================================================================
-
 pub fn get_action_messages(action: &str) -> (&'static str, &'static str) {
     match action {
         "start" => ("Torrent başlatıldı", "Torrent başlatılamadı"),
@@ -75,10 +67,6 @@ pub struct PushKeys {
     pub auth: String,
 }
 
-// ============================================================================
-// Store Definition
-// ============================================================================
-
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum FilterStatus {
     All, Downloading, Seeding, Completed, Paused, Inactive, Active, Error,
@@ -107,102 +95,105 @@ pub fn provide_torrent_store() {
     let store = TorrentStore { torrents, filter, search_query, global_stats, notifications, user };
     provide_context(store);
 
-    let notifications_for_effect = notifications;
+    let user_for_sse = user;
-    let global_stats_for_effect = global_stats;
+    let notifications_for_sse = notifications;
-    let torrents_for_effect = torrents;
+    let global_stats_for_sse = global_stats;
+    let torrents_for_sse = torrents;
     let show_browser_notification = show_browser_notification.clone();
 
-    Effect::new(move |_| {
+    spawn_local(async move {
-        let user_val = user.get();
+        let mut backoff_ms: u32 = 1000;
-        if user_val.is_none() {
+        let mut was_connected = false;
-            return;
+        let mut disconnect_notified = false;
-        }
 
-        let notifications = notifications_for_effect;
+        loop {
-        let global_stats = global_stats_for_effect;
+            let user_val = user_for_sse.get();
-        let torrents = torrents_for_effect;
+            log::debug!("SSE: user = {:?}", user_val);
-        let show_browser_notification = show_browser_notification.clone();
+            if user_val.is_none() {
+                log::debug!("SSE: User not authenticated, waiting...");
+                gloo_timers::future::TimeoutFuture::new(1000).await;
+                continue;
+            }
 
-        log::info!("SSE: Starting connection (user logged in)");
+            log::debug!("SSE: Creating EventSource...");
-
+            let es_result = EventSource::new("/api/events");
-        leptos::task::spawn_local(async move {
+            match es_result {
-            let mut backoff_ms: u32 = 1000;
+                Ok(mut es) => {
-            let mut was_connected = false;
+                    log::debug!("SSE: EventSource created, subscribing...");
-            let mut disconnect_notified = false;
+                    if let Ok(mut stream) = es.subscribe("message") {
-
+                        log::debug!("SSE: Subscribed to message channel");
-            loop {
+                        let mut got_first_message = false;
-                let es_result = EventSource::new("/api/events");
+                        while let Some(Ok((_, msg))) = stream.next().await {
-                match es_result {
+                            log::debug!("SSE: Received message");
-                    Ok(mut es) => {
+                            if !got_first_message {
-                        if let Ok(mut stream) = es.subscribe("message") {
+                                got_first_message = true;
-                            let mut got_first_message = false;
+                                backoff_ms = 1000;
-                            while let Some(Ok((_, msg))) = stream.next().await {
+                                if was_connected && disconnect_notified {
-                                if !got_first_message {
+                                    show_toast_with_signal(notifications_for_sse, NotificationLevel::Success, "Sunucu bağlantısı yeniden kuruldu");
-                                    got_first_message = true;
+                                    disconnect_notified = false;
-                                    backoff_ms = 1000;
-                                    if was_connected && disconnect_notified {
-                                        show_toast_with_signal(notifications, NotificationLevel::Success, "Sunucu bağlantısı yeniden kuruldu");
-                                        disconnect_notified = false;
-                                    }
-                                    was_connected = true;
                                 }
+                                was_connected = true;
+                            }
 
-                                if let Some(data_str) = msg.data().as_string() {
+                            if let Some(data_str) = msg.data().as_string() {
-                                    if let Ok(event) = serde_json::from_str::<AppEvent>(&data_str) {
+                                log::debug!("SSE: Parsing JSON: {}", data_str);
-                                        match event {
+                                if let Ok(event) = serde_json::from_str::<AppEvent>(&data_str) {
-                                            AppEvent::FullList { torrents: list, .. } => {
+                                    match event {
-                                                torrents.update(|map| {
+                                        AppEvent::FullList { torrents: list, .. } => {
-                                                    let new_hashes: std::collections::HashSet<String> = list.iter().map(|t| t.hash.clone()).collect();
+                                            log::info!("SSE: Received FullList with {} torrents", list.len());
-                                                    map.retain(|hash, _| new_hashes.contains(hash));
+                                            torrents_for_sse.update(|map| {
-                                                    for new_torrent in list {
+                                                let new_hashes: std::collections::HashSet<String> = list.iter().map(|t| t.hash.clone()).collect();
-                                                        map.insert(new_torrent.hash.clone(), new_torrent);
+                                                map.retain(|hash, _| new_hashes.contains(hash));
-                                                    }
+                                                for new_torrent in list {
-                                                });
+                                                    map.insert(new_torrent.hash.clone(), new_torrent);
-                                            }
-                                            AppEvent::Update(update) => {
-                                                torrents.update(|map| {
-                                                    if let Some(t) = map.get_mut(&update.hash) {
-                                                        if let Some(v) = update.name { t.name = v; }
-                                                        if let Some(v) = update.size { t.size = v; }
-                                                        if let Some(v) = update.down_rate { t.down_rate = v; }
-                                                        if let Some(v) = update.up_rate { t.up_rate = v; }
-                                                        if let Some(v) = update.percent_complete { t.percent_complete = v; }
-                                                        if let Some(v) = update.completed { t.completed = v; }
-                                                        if let Some(v) = update.eta { t.eta = v; }
-                                                        if let Some(v) = update.status { t.status = v; }
-                                                        if let Some(v) = update.error_message { t.error_message = v; }
-                                                        if let Some(v) = update.label { t.label = Some(v); }
-                                                    }
-                                                });
-                                            }
-                                            AppEvent::Stats(stats) => { global_stats.set(stats); }
-                                            AppEvent::Notification(n) => {
-                                                show_toast_with_signal(notifications, n.level.clone(), n.message.clone());
-                                                if n.message.contains("tamamlandı") || n.level == shared::NotificationLevel::Error {
-                                                    show_browser_notification("VibeTorrent", &n.message);
                                                 }
+                                            });
+                                            log::debug!("SSE: torrents map now has {} entries", torrents_for_sse.with(|m| m.len()));
+                                        }
+                                        AppEvent::Update(update) => {
+                                            torrents_for_sse.update(|map| {
+                                                if let Some(t) = map.get_mut(&update.hash) {
+                                                    if let Some(v) = update.name { t.name = v; }
+                                                    if let Some(v) = update.size { t.size = v; }
+                                                    if let Some(v) = update.down_rate { t.down_rate = v; }
+                                                    if let Some(v) = update.up_rate { t.up_rate = v; }
+                                                    if let Some(v) = update.percent_complete { t.percent_complete = v; }
+                                                    if let Some(v) = update.completed { t.completed = v; }
+                                                    if let Some(v) = update.eta { t.eta = v; }
+                                                    if let Some(v) = update.status { t.status = v; }
+                                                    if let Some(v) = update.error_message { t.error_message = v; }
+                                                    if let Some(v) = update.label { t.label = Some(v); }
+                                                }
+                                            });
+                                        }
+                                        AppEvent::Stats(stats) => { global_stats_for_sse.set(stats); }
+                                        AppEvent::Notification(n) => {
+                                            show_toast_with_signal(notifications_for_sse, n.level.clone(), n.message.clone());
+                                            if n.message.contains("tamamlandı") || n.level == shared::NotificationLevel::Error {
+                                                show_browser_notification("VibeTorrent", &n.message);
                                             }
                                         }
                                     }
                                 }
                             }
-                            if was_connected && !disconnect_notified {
-                                show_toast_with_signal(notifications, NotificationLevel::Warning, "Sunucu bağlantısı kesildi, yeniden bağlanılıyor...");
-                                disconnect_notified = true;
-                            }
                         }
-                    }
-                    Err(_) => {
                         if was_connected && !disconnect_notified {
-                            show_toast_with_signal(notifications, NotificationLevel::Warning, "Sunucu bağlantısı kurulamıyor...");
+                            show_toast_with_signal(notifications_for_sse, NotificationLevel::Warning, "Sunucu bağlantısı kesildi, yeniden bağlanılıyor...");
                             disconnect_notified = true;
                         }
                     }
                 }
-                gloo_timers::future::TimeoutFuture::new(backoff_ms).await;
+                Err(_) => {
-                backoff_ms = std::cmp::min(backoff_ms * 2, 30000);
+                    if was_connected && !disconnect_notified {
+                        show_toast_with_signal(notifications_for_sse, NotificationLevel::Warning, "Sunucu bağlantısı kurulamıyor...");
+                        disconnect_notified = true;
+                    }
+                }
             }
-        });
+            log::debug!("SSE: Reconnecting in {}ms...", backoff_ms);
+            gloo_timers::future::TimeoutFuture::new(backoff_ms).await;
+            backoff_ms = std::cmp::min(backoff_ms * 2, 30000);
+        }
     });
 }