feat(api_server): simple config by default

protocol/ss/src/client.rs

@@ -15,6 +15,7 @@ use shadowsocks::{
 #[derive(Debug, Clone)]
 pub struct SSNetConfig {
     pub(crate) server: Address,
+    #[serde(skip_serializing_if = "rd_interface::config::detailed_field")]
     pub(crate) password: String,
     #[serde(default)]
     pub(crate) udp: bool,

protocol/ss/src/server.rs

@@ -18,6 +18,7 @@ mod source;
 #[derive(Debug, Clone)]
 pub struct SSServerConfig {
     pub(crate) bind: Address,
+    #[serde(skip_serializing_if = "rd_interface::config::detailed_field")]
     pub(crate) password: String,
     #[serde(default)]
     pub(crate) udp: bool,

protocol/trojan/src/client.rs

@@ -75,6 +75,7 @@ pub struct TrojanNetConfig {
     /// hostname:port
     server: Address,
     /// password in plain text
+    #[serde(skip_serializing_if = "rd_interface::config::detailed_field")]
     password: String,
 
     /// sni
@@ -100,6 +101,7 @@ pub struct TrojancNetConfig {
     /// hostname:port
     server: RdAddress,
     /// password in plain text
+    #[serde(skip_serializing_if = "rd_interface::config::detailed_field")]
     password: String,
 
     /// enabled websocket support

rabbit-digger/src/rabbit_digger.rs

@@ -12,7 +12,9 @@ use futures::{
     Stream, StreamExt, TryStreamExt,
 };
 use rd_interface::{
-    config::{CompactVecString, NetRef, VisitorContext},
+    config::{
+        serialize_with_fields, CompactVecString, NetRef, VisitorContext, ALL_SERIALIZE_FIELDS,
+    },
     registry::NetGetter,
     Arc, Error, IntoDyn, Net, Server, Value,
 };
@@ -37,7 +39,8 @@ struct RunningEntities {
 
 struct SerializedConfig {
     id: String,
-    str: String,
+    all_fields: String,
+    simple_fields: String,
 }
 
 #[allow(dead_code)]
@@ -158,19 +161,6 @@ impl RabbitDigger {
         Ok(())
     }
 
-    // get current config if it's running
-    pub async fn config(&self) -> Result<String> {
-        let state = self.inner.state.read().await;
-        match &*state {
-            State::Running(Running { config, .. }) => {
-                return Ok(config.read().await.str.clone());
-            }
-            _ => {
-                return Err(anyhow!("Not running"));
-            }
-        };
-    }
-
     // get current connection state
     pub async fn connection<F, R>(&self, f: F) -> R
     where
@@ -223,7 +213,10 @@ impl RabbitDigger {
 
         *state = State::Running(Running {
             config: RwLock::new(SerializedConfig {
-                str: serde_json::to_string(&config)?,
+                all_fields: serialize_with_fields(ALL_SERIALIZE_FIELDS.to_vec(), || {
+                    serde_json::to_string(&config)
+                })?,
+                simple_fields: serde_json::to_string(&config)?,
                 id: config.id,
             }),
             entities,
@@ -331,8 +324,9 @@ impl RabbitDigger {
                 entities: RunningEntities { nets, .. },
                 ..
             }) => {
-                let config_str = &mut config.write().await.str;
-                let mut config: config::Config = serde_json::from_str(config_str)?;
+                let mut serialized_config = config.write().await;
+                let mut config: config::Config =
+                    serde_json::from_str(&serialized_config.all_fields)?;
 
                 if let (Some(cfg), Some(running_net)) =
                     (config.net.get_mut(net_name), nets.get(net_name))
@@ -354,7 +348,11 @@ impl RabbitDigger {
                     running_net.update_net(net);
 
                     *cfg = new_cfg;
-                    *config_str = serde_json::to_string(&config)?;
+                    serialized_config.all_fields =
+                        serialize_with_fields(ALL_SERIALIZE_FIELDS.to_vec(), || {
+                            serde_json::to_string(&config)
+                        })?;
+                    serialized_config.simple_fields = serde_json::to_string(&config)?;
                 }
                 return Ok(());
             }
@@ -372,14 +370,14 @@ impl RabbitDigger {
         }
     }
 
-    pub async fn get_config<F, R>(&self, f: F) -> R
+    pub async fn get_config<F, R>(&self, f: F) -> Result<R>
     where
-        F: FnOnce(Option<&str>) -> R,
+        F: FnOnce(&str) -> R,
     {
         let state = self.inner.state.read().await;
         match state.running() {
-            Some(i) => f(Some(&*i.config.read().await.str)),
-            None => f(None),
+            Some(i) => Ok(f(&*i.config.read().await.simple_fields)),
+            None => Err(anyhow!("Not running")),
         }
     }
 

rd-interface/src/config.rs

@@ -1,3 +1,5 @@
+use std::cell::RefCell;
+
 use crate::{self as rd_interface, Address, Net};
 pub use resolvable::{Resolvable, ResolvableSchema};
 use schemars::{
@@ -209,3 +211,37 @@ impl JsonSchema for Address {
         .into()
     }
 }
+
+#[derive(PartialEq, Clone)]
+pub enum ConfigField {
+    /// Default field type
+    Common,
+    /// Field type for detailed mode, which may be very large
+    Detail,
+    /// Field type for sensitive mode, which may contain sensitive information
+    Sensitive,
+}
+
+pub const ALL_SERIALIZE_FIELDS: [ConfigField; 3] = [
+    ConfigField::Common,
+    ConfigField::Detail,
+    ConfigField::Sensitive,
+];
+thread_local!(static SERIALIZE_FIELDS: RefCell<Vec<ConfigField>> = RefCell::new(vec![ConfigField::Common]));
+
+pub fn detailed_field<T>(_: T) -> bool {
+    !SERIALIZE_FIELDS.with(|x| x.borrow().contains(&ConfigField::Detail))
+}
+
+pub fn sensitive_field<T>(_: T) -> bool {
+    !SERIALIZE_FIELDS.with(|x| x.borrow().contains(&ConfigField::Sensitive))
+}
+
+pub fn serialize_with_fields<T, F: FnOnce() -> T>(fields: Vec<ConfigField>, f: F) -> T {
+    SERIALIZE_FIELDS.with(|x| {
+        let old_fields = std::mem::replace(&mut *x.borrow_mut(), fields);
+        let ret = f();
+        *x.borrow_mut() = old_fields;
+        ret
+    })
+}

rd-std/src/rule/config.rs

@@ -160,6 +160,7 @@ impl RuleItem {
 pub struct RuleNetConfig {
     #[serde(default = "default_lru_cache_size")]
     pub lru_cache_size: usize,
+    #[serde(skip_serializing_if = "rd_interface::config::detailed_field")]
     pub rule: Vec<RuleItem>,
 }
 

src/api_server/handlers.rs

@@ -77,7 +77,7 @@ pub(super) async fn get_config(
         HeaderValue::from_static("application/json"),
     );
 
-    let config_str = rd.config().await?;
+    let config_str = rd.get_config(|c| c.to_owned()).await?;
     Ok((headers, config_str))
 }