✨ add feature settings

Author: Reverier-Xu

Cargo.toml

@@ -9,7 +9,7 @@ homepage     = "https://github.com/XDSEC/WebSocketReflectorX"
 license      = "MIT"
 repository   = "https://github.com/XDSEC/WebSocketReflectorX"
 rust-version = "1.89.0"
-version      = "0.5.11"
+version      = "0.5.12"
 
 [profile.release]
 codegen-units = 1
@@ -25,14 +25,14 @@ futures-util     = { version = "0.3", features = ["sink"] }
 local-ip-address = "0.6"
 rustls           = { version = "0.23", features = ["ring"] }
 thiserror        = "2.0"
-tokio            = { version = "1.47", features = ["full"] }
+tokio            = { version = "1.48", features = ["full"] }
 tokio-util       = { version = "0.7", features = ["codec"] }
 
 # optional
-tokio-tungstenite = { version = "0.27", features = ["rustls-tls-native-roots"] }
+tokio-tungstenite = { version = "0.28", features = ["rustls-tls-native-roots"] }
 
 # binary cli only
-bitflags           = { version = "2.9" }
+bitflags           = { version = "2.10" }
 chrono             = { version = "0.4", features = ["serde"] }
 clap               = { version = "4.5", features = ["derive"] }
 once_cell          = { version = "1.21" }
@@ -48,7 +48,7 @@ url                = { version = "2.5" }
 
 # GUI
 async-compat          = { version = "0.2" }
-i-slint-backend-winit = "1.12"
+i-slint-backend-winit = "1.14"
 open                  = "5.3"
 
 reqwest = { version = "0.12", default-features = false, features = [
@@ -59,7 +59,7 @@ reqwest = { version = "0.12", default-features = false, features = [
   "rustls-tls",
 ] }
 
-slint = { version = "1.12", default-features = false, features = [
+slint = { version = "1.14", default-features = false, features = [
   "accessibility",
   "backend-winit",
   "compat-1-2",
@@ -79,5 +79,5 @@ winit      = "0.30"
 build-target  = "0.8"
 git-version   = "0.3"
 rustc_version = "0.4"
-slint-build   = "1.12"
+slint-build   = "1.14"
 winres        = "0.1"

crates/desktop/Cargo.toml

@@ -40,6 +40,7 @@ chrono            = { workspace = true }
 reqwest           = { workspace = true }
 serde             = { workspace = true }
 serde_json        = { workspace = true }
+thiserror         = { workspace = true }
 tokio-tungstenite = { workspace = true }
 tokio-util        = { workspace = true }
 tower-http        = { workspace = true }

crates/desktop/src/bridges/ui_state.rs

@@ -15,6 +15,7 @@ pub fn setup(window: &MainWindow) {
             name: "localhost".into(),
             state: "pending".into(),
             features: "".into(),
+            settings: "{}".into(),
         });
 
         let window_weak = window_weak.clone();

crates/desktop/src/bridges/window_control.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use i_slint_backend_winit::{WinitWindowAccessor, WinitWindowEventResult};
+use i_slint_backend_winit::{EventResult, WinitWindowAccessor};
 use slint::ComponentHandle;
 use winit::window::ResizeDirection;
 
@@ -33,13 +33,13 @@ pub fn setup(window: &MainWindow) {
                 if window.get_main_window_minimized() != w.is_minimized() {
                     window.set_main_window_minimized(w.is_minimized());
                 }
-                WinitWindowEventResult::Propagate
+                EventResult::Propagate
             }
             winit::event::WindowEvent::CloseRequested => {
                 launcher::shutdown(&window_weak);
-                WinitWindowEventResult::PreventDefault
+                EventResult::PreventDefault
             }
-            _ => WinitWindowEventResult::Propagate,
+            _ => EventResult::Propagate,
         }
     });
 

crates/desktop/src/daemon/api_controller.rs

@@ -199,7 +199,9 @@ async fn launch_instance(
 
     tokio::spawn(async move {
         let client = reqwest::Client::new();
-        update_instance_latency(state_clone, instance, &client).await;
+        update_instance_latency(state_clone, instance, &client)
+            .await
+            .ok();
     });
 
     match slint::invoke_from_event_loop(move || {
@@ -335,10 +337,16 @@ async fn request_control(
     let json_body = axum::Json::<ScopeData>::from_request(req, &state)
         .await
         .ok();
-    let (scope_name, scope_features) = if let Some(json_body) = json_body {
-        (json_body.name.clone(), json_body.features)
+    let (scope_name, scope_features, scope_settings) = if let Some(Json(ScopeData {
+        name,
+        features,
+        settings,
+        ..
+    })) = json_body
+    {
+        (name, features, settings)
     } else {
-        (req_scope.clone(), FeatureFlags::Basic)
+        (req_scope.clone(), FeatureFlags::Basic, Default::default())
     };
 
     let mut scopes = state.scopes.write().await;
@@ -355,6 +363,7 @@ async fn request_control(
         host: req_scope.clone(),
         state: "pending".to_string(),
         features: scope_features,
+        settings: scope_settings.clone(),
     };
     scopes.push(scope);
 
@@ -371,6 +380,9 @@ async fn request_control(
             name: scope_name.into(),
             state: "pending".into(),
             features: scope_features.to_shared_string(),
+            settings: serde_json::to_string(&scope_settings)
+                .unwrap_or("{}".to_string())
+                .into(),
         };
         scopes.push(scope);
     }) {
@@ -420,6 +432,9 @@ async fn update_website_info(
                 name: scope_data.name.clone().into(),
                 state: state_d.into(),
                 features: scope_data.features.to_shared_string(),
+                settings: serde_json::to_string(&scope_data.settings)
+                    .unwrap_or("{}".to_string())
+                    .into(),
             };
             scopes.set_row_data(index, scope);
         }) {

crates/desktop/src/daemon/latency_worker.rs

@@ -1,6 +1,7 @@
 use reqwest::Method;
 use slint::{ComponentHandle, Model, VecModel};
-use tracing::debug;
+use thiserror::Error;
+use tracing::{debug, warn};
 
 use super::{
     model::{FeatureFlags, InstanceData, ServerState},
@@ -25,11 +26,10 @@ pub async fn start(state: ServerState) {
             let client = client.clone();
             let state = state.clone();
             tokio::spawn(async move {
-                if update_instance_latency(state.clone(), instance.clone(), &client)
-                    .await
-                    .is_none()
-                {
-                    pingfall(state, instance).await;
+                let result =
+                    update_instance_latency(state.clone(), instance.clone(), &client).await;
+                if let Err(e) = result {
+                    pingfall(state.clone(), instance.clone(), e).await;
                 }
             });
         }
@@ -40,25 +40,32 @@ pub async fn start(state: ServerState) {
     }
 }
 
+#[derive(Debug, Error)]
+pub enum LatencyError {
+    #[error("Request error: {0}")]
+    Rewqest(#[from] reqwest::Error),
+    #[error("Non-success status code")]
+    NonSuccessStatus(u16),
+}
+
 pub async fn update_instance_latency(
     state: ServerState, instance: InstanceData, client: &reqwest::Client,
-) -> Option<i32> {
+) -> Result<i32, LatencyError> {
     let req = client
         .request(Method::OPTIONS, instance.remote.replace("ws", "http"))
         .header("User-Agent", format!("wsrx/{}", env!("CARGO_PKG_VERSION")))
-        .build()
-        .ok()?;
+        .build()?;
 
     let start_time = std::time::Instant::now();
 
-    let resp = client.execute(req).await.ok()?;
+    let resp = client.execute(req).await?;
 
     let elapsed = if resp.status().is_success() {
         // always > 0
         start_time.elapsed().as_millis() as i32 / 2
     } else {
         debug!("Failed to ping instance: {}", resp.status());
-        return None;
+        return Err(LatencyError::NonSuccessStatus(resp.status().as_u16()));
     };
 
     for proxy_instance in state.instances.write().await.iter_mut() {
@@ -98,10 +105,10 @@ pub async fn update_instance_latency(
         break;
     }
 
-    Some(elapsed)
+    Ok(elapsed)
 }
 
-async fn pingfall(state: ServerState, instance: InstanceData) {
+async fn pingfall(state: ServerState, instance: InstanceData, err: LatencyError) {
     let scopes = state.scopes.read().await;
 
     let scope = scopes
@@ -111,6 +118,33 @@ async fn pingfall(state: ServerState, instance: InstanceData) {
     if let Some(scope) = scope
         && scope.features.contains(FeatureFlags::PingFall)
     {
-        on_instance_del(&state, &instance.local).await;
+        let settings = scope.settings.get(&FeatureFlags::PingFall);
+        if let Some(settings) = settings {
+            let pingfall_settings: super::model::PingFallSettings =
+                serde_json::from_value(settings.to_owned()).unwrap_or_default();
+
+            match err {
+                LatencyError::NonSuccessStatus(code) => {
+                    if pingfall_settings.fail_status.contains(&code)
+                        || pingfall_settings.fail_status.is_empty()
+                    {
+                        warn!(
+                            "PingFall triggered for instance {} due to status code {}",
+                            instance.local, code
+                        );
+                        on_instance_del(&state, &instance.local).await;
+                    }
+                }
+                LatencyError::Rewqest(_) => {
+                    if pingfall_settings.drop_unknown {
+                        warn!(
+                            "PingFall triggered for instance {} due to request error",
+                            instance.local
+                        );
+                        on_instance_del(&state, &instance.local).await;
+                    }
+                }
+            }
+        }
     }
 }

crates/desktop/src/daemon/mod.rs

@@ -78,6 +78,9 @@ pub fn setup(ui: &MainWindow) {
             name: scope.name.clone().into(),
             state: scope.state.clone().into(),
             features: scope.features.to_shared_string(),
+            settings: serde_json::to_string(&scope.settings)
+                .unwrap_or("{}".to_string())
+                .into(),
         });
     }
     let scoped_instances: Rc<VecModel<Instance>> = Rc::new(VecModel::default());
@@ -241,6 +244,7 @@ pub fn save_scopes(ui: &slint::Weak<MainWindow>) {
                 .split(",")
                 .map(|s| s.trim().to_string())
                 .into(),
+            settings: serde_json::from_str(scope.settings.to_string().as_str()).unwrap_or_default(),
         });
     }
     let proj_dirs = match ProjectDirs::from("org", "xdsec", "wsrx") {

crates/desktop/src/daemon/model.rs

@@ -1,7 +1,8 @@
-use std::{fmt::Display, sync::Arc};
+use std::{collections::HashMap, fmt::Display, sync::Arc};
 
 use bitflags::bitflags;
 use serde::{Deserialize, Serialize};
+use serde_json::Value;
 use tokio::{net::TcpListener, sync::RwLock};
 use wsrx::tunnel::Tunnel;
 
@@ -28,6 +29,8 @@ pub struct ScopeData {
     pub name: String,
     pub state: String,
     pub features: FeatureFlags,
+    #[serde(default)]
+    pub settings: HashMap<FeatureFlags, Value>,
 }
 
 #[derive(Clone)]
@@ -46,6 +49,16 @@ bitflags! {
     }
 }
 
+#[allow(dead_code)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BasicSettings {}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct PingFallSettings {
+    pub fail_status: Vec<u16>,
+    pub drop_unknown: bool,
+}
+
 const FEATURE_MAP: &[(&str, FeatureFlags)] = &[
     ("basic", FeatureFlags::Basic),
     ("pingfall", FeatureFlags::PingFall),

crates/desktop/src/daemon/ui_controller.rs

@@ -44,7 +44,9 @@ pub async fn on_instance_add(state: &ServerState, remote: &str, local: &str) {
 
     tokio::spawn(async move {
         let client = reqwest::Client::new();
-        update_instance_latency(state_clone, instance_data, &client).await;
+        update_instance_latency(state_clone, instance_data, &client)
+            .await
+            .ok();
     });
 
     let label = instance.label.clone();
@@ -120,11 +122,13 @@ pub async fn on_scope_allow(state: &ServerState, ui: slint::Weak<MainWindow>, sc
     let mut scopes = state.scopes.write().await;
     let scope_name;
     let scope_features;
+    let scope_settings;
 
     if let Some(scope) = scopes.iter_mut().find(|s| s.host == scope_host) {
         scope.state = "allowed".to_string();
         scope_name = scope.name.clone();
         scope_features = scope.features;
+        scope_settings = scope.settings.clone();
     } else {
         return;
     }
@@ -151,6 +155,9 @@ pub async fn on_scope_allow(state: &ServerState, ui: slint::Weak<MainWindow>, sc
                     name: scope_name.into(),
                     state: "allowed".into(),
                     features: scope_features.to_shared_string(),
+                    settings: serde_json::to_string(&scope_settings)
+                        .unwrap_or("{}".to_string())
+                        .into(),
                 },
             );
         }

crates/desktop/ui/blocks/bridges.slint

@@ -38,6 +38,7 @@ export struct Scope {
     name: string,
     state: string,
     features: string,
+    settings: string,
 }
 
 export global InstanceBridge {