Rustfmt

src/config/load/decode.rs

@@ -50,8 +50,7 @@ pub(super) fn decode_source_graph(graph: ConfigSourceGraph) -> Result<DecodedSou
         .unwrap_or(false);
     let legacy_top_level_beobachten = parsed_toml.get("beobachten").cloned();
     let legacy_top_level_beobachten_minutes = parsed_toml.get("beobachten_minutes").cloned();
-    let legacy_top_level_beobachten_flush_secs =
-        parsed_toml.get("beobachten_flush_secs").cloned();
+    let legacy_top_level_beobachten_flush_secs = parsed_toml.get("beobachten_flush_secs").cloned();
     let legacy_top_level_beobachten_file = parsed_toml.get("beobachten_file").cloned();
     let stun_servers_is_explicit = network_table
         .map(|table| table.contains_key("stun_servers"))
@@ -100,9 +99,7 @@ pub(super) fn decode_source_graph(graph: ConfigSourceGraph) -> Result<DecodedSou
         && let Some(value) = legacy_top_level_beobachten_flush_secs.as_ref()
     {
         let raw = value.as_integer().ok_or_else(|| {
-            ProxyError::Config(
-                "beobachten_flush_secs (top-level) must be an integer".to_string(),
-            )
+            ProxyError::Config("beobachten_flush_secs (top-level) must be an integer".to_string())
         })?;
         let parsed = u64::try_from(raw).map_err(|_| {
             ProxyError::Config(
@@ -112,9 +109,7 @@ pub(super) fn decode_source_graph(graph: ConfigSourceGraph) -> Result<DecodedSou
         config.general.beobachten_flush_secs = parsed;
         legacy_beobachten_applied = true;
     }
-    if !beobachten_file_is_explicit
-        && let Some(value) = legacy_top_level_beobachten_file.as_ref()
-    {
+    if !beobachten_file_is_explicit && let Some(value) = legacy_top_level_beobachten_file.as_ref() {
         let parsed = value.as_str().ok_or_else(|| {
             ProxyError::Config("beobachten_file (top-level) must be a string".to_string())
         })?;
@@ -126,8 +121,7 @@ pub(super) fn decode_source_graph(graph: ConfigSourceGraph) -> Result<DecodedSou
     }
 
     let legacy_nat_stun = config.general.middle_proxy_nat_stun.take();
-    let legacy_nat_stun_servers =
-        std::mem::take(&mut config.general.middle_proxy_nat_stun_servers);
+    let legacy_nat_stun_servers = std::mem::take(&mut config.general.middle_proxy_nat_stun_servers);
     let legacy_nat_stun_used = legacy_nat_stun.is_some() || !legacy_nat_stun_servers.is_empty();
     if stun_servers_is_explicit {
         let mut explicit_stun_servers = Vec::new();

src/config/load/effective.rs

@@ -45,12 +45,10 @@ pub(super) fn apply(config: &mut ProxyConfig) -> Result<()> {
     }
 
     let mut exclusive_mask = HashMap::with_capacity(config.censorship.exclusive_mask.len());
-    let mut exclusive_mask_targets =
-        HashMap::with_capacity(config.censorship.exclusive_mask.len());
+    let mut exclusive_mask_targets = HashMap::with_capacity(config.censorship.exclusive_mask.len());
     for (domain, target) in std::mem::take(&mut config.censorship.exclusive_mask) {
         let domain = normalize_domain_to_ascii(&domain, "censorship.exclusive_mask domain")?;
-        let target =
-            normalize_exclusive_mask_target(&target, "censorship.exclusive_mask target")?;
+        let target = normalize_exclusive_mask_target(&target, "censorship.exclusive_mask target")?;
         let Some((host, port)) = parse_exclusive_mask_target(&target) else {
             return Err(ProxyError::Config(format!(
                 "Invalid censorship.exclusive_mask target for '{}': '{}'. Expected host:port with port > 0",

src/config/load/validate_core.rs

@@ -207,8 +207,7 @@ pub(super) fn validate(config: &mut ProxyConfig) -> Result<()> {
         ));
     }
 
-    if config.timeouts.relay_client_idle_hard_secs < config.timeouts.relay_client_idle_soft_secs
-    {
+    if config.timeouts.relay_client_idle_hard_secs < config.timeouts.relay_client_idle_soft_secs {
         return Err(ProxyError::Config(
             "timeouts.relay_client_idle_hard_secs must be >= timeouts.relay_client_idle_soft_secs"
                 .to_string(),

src/config/load/validate_me.rs

@@ -168,8 +168,7 @@ pub(super) fn validate(config: &mut ProxyConfig) -> Result<()> {
     }
     if config.general.me_route_backpressure_base_timeout_ms > 5000 {
         return Err(ProxyError::Config(
-            "general.me_route_backpressure_base_timeout_ms must be within [1, 5000]"
-                .to_string(),
+            "general.me_route_backpressure_base_timeout_ms must be within [1, 5000]".to_string(),
         ));
     }
 
@@ -182,15 +181,13 @@ pub(super) fn validate(config: &mut ProxyConfig) -> Result<()> {
     }
     if config.general.me_route_backpressure_high_timeout_ms > 5000 {
         return Err(ProxyError::Config(
-            "general.me_route_backpressure_high_timeout_ms must be within [1, 5000]"
-                .to_string(),
+            "general.me_route_backpressure_high_timeout_ms must be within [1, 5000]".to_string(),
         ));
     }
 
     if !(1..=100).contains(&config.general.me_route_backpressure_high_watermark_pct) {
         return Err(ProxyError::Config(
-            "general.me_route_backpressure_high_watermark_pct must be within [1, 100]"
-                .to_string(),
+            "general.me_route_backpressure_high_watermark_pct must be within [1, 100]".to_string(),
         ));
     }
 

src/config/load/validate_runtime.rs

@@ -94,8 +94,7 @@ pub(super) fn validate(config: &mut ProxyConfig) -> Result<()> {
         ));
     }
 
-    if !(4096..=16 * 1024 * 1024)
-        .contains(&config.general.me_d2c_frame_buf_shrink_threshold_bytes)
+    if !(4096..=16 * 1024 * 1024).contains(&config.general.me_d2c_frame_buf_shrink_threshold_bytes)
     {
         return Err(ProxyError::Config(
             "general.me_d2c_frame_buf_shrink_threshold_bytes must be within [4096, 16777216]"
@@ -105,15 +104,13 @@ pub(super) fn validate(config: &mut ProxyConfig) -> Result<()> {
 
     if !(4096..=1024 * 1024).contains(&config.general.direct_relay_copy_buf_c2s_bytes) {
         return Err(ProxyError::Config(
-            "general.direct_relay_copy_buf_c2s_bytes must be within [4096, 1048576]"
-                .to_string(),
+            "general.direct_relay_copy_buf_c2s_bytes must be within [4096, 1048576]".to_string(),
         ));
     }
 
     if !(8192..=2 * 1024 * 1024).contains(&config.general.direct_relay_copy_buf_s2c_bytes) {
         return Err(ProxyError::Config(
-            "general.direct_relay_copy_buf_s2c_bytes must be within [8192, 2097152]"
-                .to_string(),
+            "general.direct_relay_copy_buf_s2c_bytes must be within [8192, 2097152]".to_string(),
         ));
     }
 
@@ -177,8 +174,7 @@ pub(super) fn validate(config: &mut ProxyConfig) -> Result<()> {
         || config.general.me_pool_drain_soft_evict_budget_per_core > 64
     {
         return Err(ProxyError::Config(
-            "general.me_pool_drain_soft_evict_budget_per_core must be within [1, 64]"
-                .to_string(),
+            "general.me_pool_drain_soft_evict_budget_per_core must be within [1, 64]".to_string(),
         ));
     }
 

src/config/load/validate_server.rs

@@ -1,8 +1,7 @@
 use super::*;
 
 pub(super) fn validate(config: &mut ProxyConfig) -> Result<()> {
-    if !(1..=MAX_API_REQUEST_BODY_LIMIT_BYTES)
-        .contains(&config.server.api.request_body_limit_bytes)
+    if !(1..=MAX_API_REQUEST_BODY_LIMIT_BYTES).contains(&config.server.api.request_body_limit_bytes)
     {
         return Err(ProxyError::Config(
             "server.api.request_body_limit_bytes must be within [1, 1048576]".to_string(),