log auto scroll flag

Author: ssrlive

Cargo.toml

@@ -11,7 +11,7 @@ description = "A graphical user interface for managing OverTLS clients."
 
 [dependencies]
 arboard = { version = "3.6.1", default-features = false, features = ["image-data"] }
-chrono = "0.4.41"
+chrono = "0.4.42"
 dirs = "6.0.0"
 env_logger = "0.11.8"
 fltk = { version = "1.5.14", features = ["fltk-bundled"] }
@@ -27,7 +27,7 @@ serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.143"
 tokio = { version = "1.47.1", features = ["full"] }
 tray-icon = { version = "0.21.1", default-features = false, features = ["libxdo"] }
-tun2proxy = { version = "0.7.14", default-features = false }
+tun2proxy = { version = "0.7.15", default-features = false }
 
 [target.'cfg(target_os = "linux")'.dependencies]
 gtk = "0.18.2"

src/main.rs

@@ -160,7 +160,7 @@ async fn main() -> Result<(), BoxError> {
     let running_token_run = running_token.clone();
     let running_handle_run = running_handle.clone();
     let state_clone = state.clone();
-    menubar.add("&Main/Run", Shortcut::None, MenuFlag::Normal, move |_m| {
+    menubar.add("&Main/Run\t", Shortcut::Alt | 'r', MenuFlag::Normal, move |_m| {
         let Some(idx) = *current_node_index_run.borrow() else {
             rfd::MessageDialog::new()
                 .set_title("Error")
@@ -214,20 +214,33 @@ async fn main() -> Result<(), BoxError> {
         let title = config.remarks.clone().unwrap_or_default();
         let token = overtls::CancellationToken::new();
         *running_token_run.lock().unwrap() = Some(token.clone());
-        let handle = std::thread::spawn(move || core::main_task_block(config, tun2proxy_args, token));
+        let title_clone = title.clone();
+        let running_token = running_token_run.clone();
+        let running_handle = running_handle_run.clone();
+        let handle = std::thread::spawn(move || {
+            let res = core::main_task_block(config, tun2proxy_args, token);
+            if let Err(e) = &res {
+                log::error!("Node '{title_clone}' exited with error: {e}");
+            }
+            if let Ok(mut token) = running_token.try_lock()
+                && let Some(token) = token.take()
+            {
+                token.cancel();
+            }
+            if let Ok(mut handle) = running_handle.try_lock() {
+                handle.take();
+            }
+            res
+        });
         *running_handle_run.lock().unwrap() = Some(handle);
         log::debug!("Node '{title}' is starting...");
     });
 
     let running_token_stop = running_token.clone();
     let running_handle_stop = running_handle.clone();
-    menubar.add("&Main/Stop", Shortcut::None, MenuFlag::MenuDivider, move |_m| {
+    menubar.add("&Main/Stop\t", Shortcut::Alt | 's', MenuFlag::MenuDivider, move |_m| {
         if let Err(e) = stop_running_node(&running_token_stop, &running_handle_stop) {
-            rfd::MessageDialog::new()
-                .set_title("Error")
-                .set_description(format!("Failed to stop running node: {e}"))
-                .set_level(rfd::MessageLevel::Error)
-                .show();
+            log::error!("Failed to stop running node: {e}");
         }
     });
 
@@ -240,13 +253,13 @@ async fn main() -> Result<(), BoxError> {
         if let Some(token) = running_token.lock().map_err(f1)?.take() {
             token.cancel();
         } else {
-            err_info = Some("No running node.");
+            err_info = Some("No running node.".to_string());
         }
         let f2 = |e| std::io::Error::other(format!("running_handle lock error: {e}"));
         if let Some(handle) = running_handle.lock().map_err(f2)?.take()
-            && util::thread_handle_join_with_timeout(handle, 1000).is_none()
+            && let Err(e) = util::thread_handle_join_with_timeout(handle, 3000)
         {
-            err_info = Some("Node thread did not finish in 1 second, force exit.");
+            err_info = Some(format!("Failed to join running thread: {e:?}"));
         }
         err_info.map(|e| Err(std::io::Error::other(e))).unwrap_or(Ok(()))
     }
@@ -722,8 +735,10 @@ async fn main() -> Result<(), BoxError> {
                     style_buffer.set_text(new_style);
                 }
                 log_display.set_highlight_data(style_buffer.clone(), style_table);
-                let lines = log_buffer.count_lines(0, log_buffer.length());
-                log_display.scroll(lines, 0);
+                if state.borrow().system_settings.as_ref().unwrap().log_auto_scroll.unwrap_or(true) {
+                    let lines = log_buffer.count_lines(0, log_buffer.length());
+                    log_display.scroll(lines, 0);
+                }
             }
         }
     }

src/settings_dialog.rs

@@ -89,7 +89,7 @@ macro_rules! add_row_spin {
 /// Pop up the settings dialog, and send the result via channel to avoid idle closure accumulation.
 pub fn show_settings_dialog(win: &Window, system_settings: &SystemSettings, tx: std::sync::mpsc::Sender<SystemSettings>) {
     let dialog_w = 600;
-    let dialog_h = 320;
+    let dialog_h = 360;
     let x = win.x() + (win.width() - dialog_w) / 2;
     let y = win.y() + (win.height() - dialog_h) / 2;
     let mut dlg = Window::new(x, y, dialog_w, dialog_h, "Settings");
@@ -157,6 +157,7 @@ pub fn show_settings_dialog(win: &Window, system_settings: &SystemSettings, tx:
     let mut ipstack_log_level = add_row_choice!("Ipstack Log Level", ipstack_log_level, flex_logging, &log_level_options());
     let mut overtls_log_level = add_row_choice!("OverTls Log Level", overtls_log_level, flex_logging, &log_level_options());
     let mut tun2proxy_log_level = add_row_choice!("Tun2proxy Log Level", tun2proxy_log_level, flex_logging, &log_level_options());
+    let mut log_auto_scroll = add_row_check!("Log Auto Scroll", log_auto_scroll, flex_logging);
 
     tab_logging.end();
 
@@ -191,6 +192,7 @@ pub fn show_settings_dialog(win: &Window, system_settings: &SystemSettings, tx:
     ipstack_log_level.set_value(log_level_index(system_settings.ipstack_log_level.as_deref().unwrap_or("Info")));
     overtls_log_level.set_value(log_level_index(system_settings.overtls_log_level.as_deref().unwrap_or("Info")));
     tun2proxy_log_level.set_value(log_level_index(system_settings.tun2proxy_log_level.as_deref().unwrap_or("Info")));
+    log_auto_scroll.set_value(system_settings.log_auto_scroll.unwrap_or(true));
 
     let mut submit_btn = Button::new(dialog_w / 2 - 60, dialog_h - 45, 120, 35, "Submit");
     dlg.end();
@@ -228,6 +230,7 @@ pub fn show_settings_dialog(win: &Window, system_settings: &SystemSettings, tx:
         let ipstack_log_level_val = Some(log_level_by_index(ipstack_log_level.value()));
         let overtls_log_level_val = Some(log_level_by_index(overtls_log_level.value()));
         let tun2proxy_log_level_val = Some(log_level_by_index(tun2proxy_log_level.value()));
+        let log_auto_scroll_val = log_auto_scroll.value();
 
         let tun2proxy_cfg = Some(tun2proxy::Args {
             exit_on_fatal_error: exit_on_fatal_error_val,
@@ -255,6 +258,7 @@ pub fn show_settings_dialog(win: &Window, system_settings: &SystemSettings, tx:
             ipstack_log_level: ipstack_log_level_val,
             overtls_log_level: overtls_log_level_val,
             tun2proxy_log_level: tun2proxy_log_level_val,
+            log_auto_scroll: Some(log_auto_scroll_val),
         };
         let _ = tx.send(new_settings);
         dlg_cb.hide();

src/states_manager.rs

@@ -68,6 +68,9 @@ pub struct SystemSettings {
 
     #[serde(skip_serializing_if = "Option::is_none", default)]
     pub tun2proxy_log_level: Option<String>, // tun2proxy log level
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub log_auto_scroll: Option<bool>, // log auto scroll
 }
 
 impl Default for SystemSettings {
@@ -88,6 +91,7 @@ impl Default for SystemSettings {
             ipstack_log_level: Some("Debug".to_string()),
             overtls_log_level: Some("Debug".to_string()),
             tun2proxy_log_level: Some("Debug".to_string()),
+            log_auto_scroll: Some(true),
         }
     }
 }

src/util.rs

@@ -12,19 +12,50 @@ pub const fn host_os_name() -> &'static str {
     }
 }
 
-pub fn thread_handle_join_with_timeout<T>(handle: std::thread::JoinHandle<T>, timeout_ms: u64) -> Option<T> {
+// ===============================================================================================
+
+#[derive(Debug)]
+pub enum ThreadJoinError {
+    Timeout,
+    Panic(Box<dyn std::any::Any + Send + 'static>),
+}
+
+impl std::fmt::Display for ThreadJoinError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ThreadJoinError::Timeout => write!(f, "Thread join timed out"),
+            ThreadJoinError::Panic(p) => {
+                if let Some(s) = p.downcast_ref::<String>() {
+                    write!(f, "Thread panicked: {s}")
+                } else if let Some(s) = p.downcast_ref::<&str>() {
+                    write!(f, "Thread panicked: {s}")
+                } else if let Some(s) = p.downcast_ref::<std::io::Error>() {
+                    write!(f, "Thread panicked: {s}")
+                } else {
+                    write!(f, "Thread panicked with unknown type")
+                }
+            }
+        }
+    }
+}
+
+impl std::error::Error for ThreadJoinError {}
+
+pub fn thread_handle_join_with_timeout<T>(handle: std::thread::JoinHandle<T>, timeout_ms: u64) -> Result<T, ThreadJoinError> {
     let start = std::time::Instant::now();
     loop {
         if handle.is_finished() {
-            return handle.join().ok();
+            return handle.join().map_err(ThreadJoinError::Panic);
         }
         if start.elapsed() > std::time::Duration::from_millis(timeout_ms) {
-            return None;
+            return Err(ThreadJoinError::Timeout);
         }
         std::thread::sleep(std::time::Duration::from_millis(50));
     }
 }
 
+// ===============================================================================================
+
 pub fn file_chooser_open_file(title: &str, default_path: Option<&str>, filter: &str, filter_exts: &[&str]) -> Option<PathBuf> {
     rfd::FileDialog::new()
         .set_title(title)