core: add cancellation, timeout, and resource guards for image/document/webpage/folder/binary/table

Author: visorcraft

apps/linsync-gui/qml/ImageComparePage.qml

@@ -160,6 +160,8 @@ Controls.Pane {
     property var lastResult: null
     property real imageZoom: 1.0
     property bool splitViewActive: false
+    property int imageRequestCounter: 0
+    property string activeImageRequestId: ""
 
     function bridgeGet(path, onLoad) {
         if (root.bridgeUrl === "") {
@@ -210,6 +212,9 @@ Controls.Pane {
         root.overlayUri = "";
         root.lastResult = null;
         root.statusText = "Comparing…";
+        root.imageRequestCounter += 1;
+        const reqId = "img-" + root.imageRequestCounter;
+        root.activeImageRequestId = reqId;
 
         const modeStr = modeCombo.currentText.toLowerCase();
         const tol = toleranceSpin.value;
@@ -218,14 +223,19 @@ Controls.Pane {
         // bridge expects; sending it unscaled made the threshold 10× too lenient.
         const deltaE = deltaESpin.value / 10;
         const frameMode = frameCombo.currentIndex === 1 ? "all" : "first";
-        const url = "/compare/image" + "?left=" + encodeURIComponent(root.leftPath) + "&right=" + encodeURIComponent(root.rightPath) + "&mode=" + modeStr + "&tolerance=" + tol + "&delta_e=" + deltaE + "&frames=" + frameMode + "&overlay=true";
+        const url = "/compare/image" + "?left=" + encodeURIComponent(root.leftPath) + "&right=" + encodeURIComponent(root.rightPath) + "&mode=" + modeStr + "&tolerance=" + tol + "&delta_e=" + deltaE + "&frames=" + frameMode + "&overlay=true" + "&request_id=" + encodeURIComponent(reqId);
 
         root.bridgeGet(url, function (ok, data) {
             root.running = false;
+            root.activeImageRequestId = "";
             if (!ok || !data) {
                 root.statusText = "Compare failed — check file paths and format support.";
                 return;
             }
+            if (data.cancelled === true) {
+                root.statusText = "Compare cancelled";
+                return;
+            }
             root.lastResult = data;
             if (data.session)
                 root.sessionUpdated(data);
@@ -409,6 +419,18 @@ Controls.Pane {
                     onClicked: root.runCompare()
                 }
 
+                AppButton {
+                    Layout.preferredHeight: 30
+                    Layout.preferredWidth: 100
+                    text: qsTr("Stop")
+                    icon.name: "media-playback-stop"
+                    enabled: root.running && root.activeImageRequestId !== ""
+                    onClicked: {
+                        root.bridgeGet("/cancel?id=" + encodeURIComponent(root.activeImageRequestId))
+                        root.statusText = qsTr("Cancelling…")
+                    }
+                }
+
                 Controls.BusyIndicator {
                     running: root.running
                     visible: root.running

apps/linsync-gui/qml/Main.qml

@@ -55,6 +55,10 @@ Kirigami.ApplicationWindow {
     property int progressCurrent: 0
     property int progressTotal: 0
     property string progressMessage: ""
+    // Defensive iteration cap for the progress timer so a missed cancel path
+    // cannot poll forever. At 200 ms intervals 30000 iterations == ~100 min.
+    property int progressPollCount: 0
+    readonly property int progressPollMax: 30000
     // Compare-profile selector state (Phase 1). `profileEntries` mirrors
     // /profiles/list (built-ins first, then user profiles); `activeProfileId`
     // is the persisted active pointer; `profileError` surfaces a 400/404 inline.
@@ -136,6 +140,12 @@ Kirigami.ApplicationWindow {
     // appending a fetched window (vs. loading a fresh comparison).
     property bool suppressTextScrollReset: false
     property var folderEntries: []
+    // Hard ceiling on how many folder rows the GUI will hold in memory for
+    // windowed folders. Further lazy-load pages are dropped once the cap is
+    // reached and the user is told to refine filters. Sort/filter/search changes
+    // reset the model via queryFolderPage(0, false), so the cap only bounds
+    // scroll-driven growth within one query.
+    readonly property int folderEntriesMax: 50000
     property var visibleFolderEntries: []
     // Table compare grid data. tableCells holds the currently-loaded window of
     // rows; tableHeaders is populated when the input has a header row. Windowing
@@ -2220,6 +2230,10 @@ Kirigami.ApplicationWindow {
                 }
             }
         }
+        // The progressTimer already provides a defensive ceiling for stuck
+        // compares; any non-200 response in onreadystatechange above also clears
+        // the flags. Keep the request path simple because QML's XMLHttpRequest
+        // subset does not expose timeout/onerror callbacks.
         request.open("GET", url)
         request.send()
     }
@@ -2434,6 +2448,10 @@ Kirigami.ApplicationWindow {
     function queryFolderPage(offset, append) {
         if (root.bridgeUrl === "" || root.compareMode !== "Folder" || root.folderWindowLoading)
             return
+        if (append && root.folderEntries.length >= root.folderEntriesMax) {
+            root.statusText = qsTr("Folder view limited to %1 entries; refine filters to load more.").arg(root.folderEntriesMax)
+            return
+        }
         root.folderWindowLoading = true
         let url = root.bridgeUrl + "/folder/query?left=" + encodeURIComponent(root.leftPath)
             + "&right=" + encodeURIComponent(root.rightPath)
@@ -2464,6 +2482,10 @@ Kirigami.ApplicationWindow {
             }
             const payload = JSON.parse(request.responseText)
             const entries = payload.entries || []
+            if (append && root.folderEntries.length + entries.length > root.folderEntriesMax) {
+                root.statusText = qsTr("Folder view limited to %1 entries; refine filters to load more.").arg(root.folderEntriesMax)
+                return
+            }
             root.folderEntries = append ? root.folderEntries.concat(entries) : entries
             if (payload.totalMatched !== undefined)
                 root.folderTotalEntries = Math.max(Number(payload.totalMatched), root.folderEntries.length)
@@ -2482,6 +2504,8 @@ Kirigami.ApplicationWindow {
             return
         if (root.folderEntries.length >= root.folderTotalEntries)
             return
+        if (root.folderEntries.length >= root.folderEntriesMax)
+            return
         if (view.contentHeight - (view.contentY + view.height) < view.height)
             root.queryFolderPage(root.folderEntries.length, true)
     }
@@ -6521,6 +6545,14 @@ Kirigami.ApplicationWindow {
                 progressTimer.stop()
                 return
             }
+            root.progressPollCount += 1
+            if (root.progressPollCount > root.progressPollMax) {
+                root.comparing = false
+                root.activeRequestId = ""
+                root.statusText = qsTr("Compare monitoring timed out")
+                progressTimer.stop()
+                return
+            }
             var req = new XMLHttpRequest()
             req.onreadystatechange = function () {
                 if (req.readyState === XMLHttpRequest.DONE && req.status === 200) {
@@ -6549,13 +6581,15 @@ Kirigami.ApplicationWindow {
             root.progressCurrent = 0
             root.progressTotal = 0
             root.progressMessage = ""
+            root.progressPollCount = 0
             progressTimer.start()
         } else {
             progressTimer.stop()
             root.progressPhase = "none"
             root.progressCurrent = 0
             root.progressTotal = 0
             root.progressMessage = ""
+            root.progressPollCount = 0
         }
     }
 }

apps/linsync-gui/src/bridge.rs

@@ -62,7 +62,7 @@ pub(crate) fn start_bridge_server(
         let active = Arc::new(AtomicUsize::new(0));
         for stream in listener.incoming() {
             match stream {
-                Ok(stream) => {
+                Ok(mut stream) => {
                     // Handle each connection on its own thread so a `/cancel`
                     // request can be served while a `/compare` is still running
                     // (the accept loop must not block on a single request).
@@ -71,7 +71,14 @@ pub(crate) fn start_bridge_server(
                             concurrent = active.load(Ordering::Relaxed),
                             "LinSync GUI bridge connection limit reached, rejecting"
                         );
-                        // Drain and drop the stream so the client doesn't hang.
+                        // Return a 503 so the client sees a retry signal rather than
+                        // a silently dropped connection.
+                        let response = b"HTTP/1.1 503 Service Unavailable\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";
+                        if let Err(err) = stream.write_all(response) {
+                            tracing::warn!(error = %err, "failed to write 503 to rejected bridge connection");
+                        } else if let Err(err) = stream.flush() {
+                            tracing::warn!(error = %err, "failed to flush 503 to rejected bridge connection");
+                        }
                         drop(stream);
                         continue;
                     }
@@ -311,7 +318,7 @@ pub(crate) fn bridge_response_with_token(
             let req =
                 register_cancellable_request(&params, state, "extracting", 3, "Extracting text");
             set_progress(
-                &req.progress,
+                &req.progress(),
                 "extracting",
                 1,
                 3,
@@ -325,7 +332,6 @@ pub(crate) fn bridge_response_with_token(
             // If the user hit Stop during the (potentially slow) plugin
             // extraction, discard the result and report cancellation.
             if req.is_cancelled() {
-                remove_cancellable_request(&req, state);
                 return http_response(
                     200,
                     "OK",
@@ -334,7 +340,7 @@ pub(crate) fn bridge_response_with_token(
                 );
             }
             set_progress(
-                &req.progress,
+                &req.progress(),
                 "finalizing",
                 2,
                 3,
@@ -367,8 +373,7 @@ pub(crate) fn bridge_response_with_token(
                     }
                 }
             }
-            set_progress(&req.progress, "done", 3, 3, String::new());
-            remove_cancellable_request(&req, state);
+            set_progress(&req.progress(), "done", 3, 3, String::new());
             http_response(200, "OK", "application/json", body.into_bytes())
         }
         "/profiles/list" => profiles_list_bridge_response(paths),
@@ -387,19 +392,20 @@ pub(crate) fn bridge_response_with_token(
             };
             let req =
                 register_cancellable_request(&params, state, "comparing", 1, "Comparing images");
-            let (mut body, result) =
-                linsync::image_compare_bridge_response_with_profile(query, &profile.image);
+            let (mut body, result) = linsync::image_compare_bridge_response_with_profile_and_cancel(
+                query,
+                &profile.image,
+                req.cancel_checker(),
+            );
             // If the user hit Stop during the compare, discard the result.
             if req.is_cancelled() {
-                remove_cancellable_request(&req, state);
                 return http_response(
                     200,
                     "OK",
                     "application/json",
                     br#"{"cancelled":true}"#.to_vec(),
                 );
             }
-            remove_cancellable_request(&req, state);
             let result_for_tab = result.clone();
             let overlay_path = serde_json::from_str::<serde_json::Value>(&body)
                 .ok()
@@ -447,7 +453,7 @@ pub(crate) fn bridge_response_with_token(
             let req =
                 register_cancellable_request(&params, state, "fetching", 3, "Fetching webpages");
             set_progress(
-                &req.progress,
+                &req.progress(),
                 "fetching",
                 1,
                 3,
@@ -461,7 +467,6 @@ pub(crate) fn bridge_response_with_token(
             // If the user hit Stop during the (potentially slow) fetch/render,
             // discard the result and report cancellation.
             if req.is_cancelled() {
-                remove_cancellable_request(&req, state);
                 return http_response(
                     200,
                     "OK",
@@ -470,7 +475,7 @@ pub(crate) fn bridge_response_with_token(
                 );
             }
             set_progress(
-                &req.progress,
+                &req.progress(),
                 "finalizing",
                 2,
                 3,
@@ -492,8 +497,7 @@ pub(crate) fn bridge_response_with_token(
                     state,
                 );
             }
-            set_progress(&req.progress, "done", 3, 3, String::new());
-            remove_cancellable_request(&req, state);
+            set_progress(&req.progress(), "done", 3, 3, String::new());
             http_response(200, "OK", "application/json", body.into_bytes())
         }
         "/compare/webpage/clear-cache" => {
@@ -1355,34 +1359,17 @@ pub(crate) fn compare_bridge_response(
     // cancel flag so a concurrent `/cancel?id=X` can abort this compare. The
     // flag is registered/removed under the state lock, but the long compare
     // below runs WITHOUT holding the lock, so `/cancel` is never blocked by it.
-    let (request_id, progress) =
-        register_progress_request(&params, state, "starting", 0, "Starting compare");
-    let should_cancel: Box<dyn Fn() -> bool> = if let Some(id) = &request_id {
-        let flag = Arc::new(AtomicBool::new(false));
-        if let Ok(mut state) = state.lock() {
-            state.compare_cancels.insert(id.clone(), Arc::clone(&flag));
-        }
-        Box::new(move || flag.load(Ordering::Relaxed))
-    } else {
-        Box::new(|| false)
-    };
+    let req = register_cancellable_request(&params, state, "starting", 0, "Starting compare");
 
     let maybe_tab = build_tab_for_paths_with_mode_cancellable_and_artifacts(
         Path::new(left),
         Path::new(right),
         query_value(&params, "mode"),
         &options,
-        &*should_cancel,
-        progress,
+        req.cancel_checker(),
+        req.progress(),
     );
 
-    if let Some(id) = &request_id
-        && let Ok(mut state) = state.lock()
-    {
-        state.compare_cancels.remove(id);
-    }
-    remove_progress_request(request_id.as_deref(), state);
-
     let Some((tab, artifact_dirs)) = maybe_tab else {
         // The compare was cancelled — leave the session state untouched.
         return http_response(
@@ -3125,26 +3112,17 @@ pub(crate) fn sessions_save_bridge_response(
     session_file.selected_view = compare_view_mode(&tab.mode);
     persist_tab_snapshot(&mut session_file, &tab);
     let store = RecentSessionStore::new(paths.recent_sessions_file(), recent_limit(paths));
-    let mut recent: RecentSessions = match store.load_or_default() {
-        Ok(value) => value,
-        Err(err) => {
-            return bridge_error(
-                500,
-                "Internal Server Error",
-                &format!("failed to load sessions: {err}"),
-            );
+    match store.add(session_file) {
+        Ok(_) => {
+            let body = serde_json::json!({"ok":true}).to_string();
+            http_response(200, "OK", "application/json", body.into_bytes())
         }
-    };
-    recent.sessions.insert(0, session_file);
-    if let Err(err) = store.save(&recent) {
-        return bridge_error(
+        Err(err) => bridge_error(
             500,
             "Internal Server Error",
             &format!("failed to save session: {err}"),
-        );
+        ),
     }
-    let body = serde_json::json!({"ok":true}).to_string();
-    http_response(200, "OK", "application/json", body.into_bytes())
 }
 
 pub(crate) fn filters_list_bridge_response(paths: &AppPaths) -> Vec<u8> {