Rustfmt

src/maestro/generation/lifecycle.rs

@@ -137,10 +137,11 @@ mod tests {
 
         let drain_generation = Arc::clone(&generation);
         let drain = tokio::spawn(async move {
-            drain_generation.drain_sessions(Duration::from_secs(60)).await
+            drain_generation
+                .drain_sessions(Duration::from_secs(60))
+                .await
         });
-        while generation.session_admission.state.load(Ordering::Acquire)
-            & SESSION_ADMISSION_CLOSED
+        while generation.session_admission.state.load(Ordering::Acquire) & SESSION_ADMISSION_CLOSED
             == 0
         {
             tokio::task::yield_now().await;

src/maestro/helpers/tests.rs

@@ -1,276 +1,266 @@
-    use std::path::{Path, PathBuf};
+use std::path::{Path, PathBuf};
 
-    use super::{
-        expected_handshake_close_description, format_maestro_line, is_expected_handshake_eof,
-        peer_close_description, resolve_runtime_base_dir, resolve_runtime_config_path,
-    };
-    use crate::error::{ProxyError, StreamError};
+use super::{
+    expected_handshake_close_description, format_maestro_line, is_expected_handshake_eof,
+    peer_close_description, resolve_runtime_base_dir, resolve_runtime_config_path,
+};
+use crate::error::{ProxyError, StreamError};
 
-    #[test]
-    fn maestro_line_formatter_respects_disabled_colors() {
-        let plain = format_maestro_line("boot", false);
-        assert_eq!(plain, "MAESTRO: boot");
-        assert!(!plain.contains('\x1b'));
+#[test]
+fn maestro_line_formatter_respects_disabled_colors() {
+    let plain = format_maestro_line("boot", false);
+    assert_eq!(plain, "MAESTRO: boot");
+    assert!(!plain.contains('\x1b'));
+}
+
+#[test]
+fn maestro_line_formatter_keeps_color_when_enabled() {
+    let colored = format_maestro_line("boot", true);
+    assert!(colored.contains("\x1b[92mMAESTRO\x1b[0m"));
+}
+
+#[test]
+fn resolve_runtime_config_path_anchors_relative_to_startup_cwd() {
+    let nonce = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
+    let startup_cwd = std::env::temp_dir().join(format!("telemt_cfg_path_{nonce}"));
+    std::fs::create_dir_all(&startup_cwd).unwrap();
+    let target = startup_cwd.join("config.toml");
+    std::fs::write(&target, " ").unwrap();
+
+    let resolved = resolve_runtime_config_path("config.toml", &startup_cwd, true);
+    assert_eq!(resolved, target.canonicalize().unwrap());
+
+    let _ = std::fs::remove_file(&target);
+    let _ = std::fs::remove_dir(&startup_cwd);
+}
+
+#[test]
+fn resolve_runtime_config_path_keeps_absolute_for_missing_file() {
+    let nonce = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
+    let startup_cwd = std::env::temp_dir().join(format!("telemt_cfg_path_missing_{nonce}"));
+    std::fs::create_dir_all(&startup_cwd).unwrap();
+
+    let resolved = resolve_runtime_config_path("missing.toml", &startup_cwd, true);
+    assert_eq!(resolved, startup_cwd.join("missing.toml"));
+
+    let _ = std::fs::remove_dir(&startup_cwd);
+}
+
+#[cfg(unix)]
+#[test]
+fn runtime_paths_preserve_symlinks_for_descriptor_validation() {
+    use std::os::unix::fs::symlink;
+
+    let dir = tempfile::tempdir().unwrap();
+    let real_dir = dir.path().join("real");
+    let linked_dir = dir.path().join("linked");
+    std::fs::create_dir(&real_dir).unwrap();
+    std::fs::write(real_dir.join("config.toml"), " ").unwrap();
+    symlink(&real_dir, &linked_dir).unwrap();
+    let linked_config = linked_dir.join("config.toml");
+
+    let config = resolve_runtime_config_path(linked_config.to_str().unwrap(), dir.path(), true);
+    let runtime = resolve_runtime_base_dir(&linked_config, dir.path(), true, Some(&linked_dir));
+
+    assert_eq!(config, linked_config);
+    assert_eq!(runtime, linked_dir);
+}
+
+#[test]
+fn resolve_runtime_config_path_uses_startup_candidates_when_not_explicit() {
+    let nonce = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
+    let startup_cwd = std::env::temp_dir().join(format!("telemt_cfg_startup_candidates_{nonce}"));
+    std::fs::create_dir_all(&startup_cwd).unwrap();
+    let telemt = startup_cwd.join("telemt.toml");
+    std::fs::write(&telemt, " ").unwrap();
+
+    let resolved = resolve_runtime_config_path("config.toml", &startup_cwd, false);
+    assert_eq!(resolved, telemt.canonicalize().unwrap());
+
+    let _ = std::fs::remove_file(&telemt);
+    let _ = std::fs::remove_dir(&startup_cwd);
+}
+
+#[test]
+fn resolve_runtime_config_path_defaults_to_startup_config_when_none_found() {
+    let nonce = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
+    let startup_cwd = std::env::temp_dir().join(format!("telemt_cfg_startup_default_{nonce}"));
+    std::fs::create_dir_all(&startup_cwd).unwrap();
+
+    let resolved = resolve_runtime_config_path("config.toml", &startup_cwd, false);
+    assert_eq!(resolved, startup_cwd.join("config.toml"));
+
+    let _ = std::fs::remove_dir(&startup_cwd);
+}
+
+#[test]
+fn resolve_runtime_base_dir_prefers_cli_data_path() {
+    let nonce = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
+    let startup_cwd = std::env::temp_dir().join(format!("telemt_runtime_base_cwd_{nonce}"));
+    let data_path = std::env::temp_dir().join(format!("telemt_runtime_base_data_{nonce}"));
+    std::fs::create_dir_all(&startup_cwd).unwrap();
+    std::fs::create_dir_all(&data_path).unwrap();
+
+    let resolved = resolve_runtime_base_dir(
+        &startup_cwd.join("config.toml"),
+        &startup_cwd,
+        true,
+        Some(&data_path),
+    );
+    assert_eq!(resolved, data_path.canonicalize().unwrap());
+
+    let _ = std::fs::remove_dir(&data_path);
+    let _ = std::fs::remove_dir(&startup_cwd);
+}
+
+#[test]
+fn resolve_runtime_base_dir_uses_working_directory_before_explicit_config_parent() {
+    let nonce = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
+    let startup_cwd = std::env::temp_dir().join(format!("telemt_runtime_base_start_{nonce}"));
+    let config_dir = std::env::temp_dir().join(format!("telemt_runtime_base_cfg_{nonce}"));
+    std::fs::create_dir_all(&startup_cwd).unwrap();
+    std::fs::create_dir_all(&config_dir).unwrap();
+
+    let resolved =
+        resolve_runtime_base_dir(&config_dir.join("telemt.toml"), &startup_cwd, true, None);
+    assert_eq!(resolved, startup_cwd.canonicalize().unwrap());
+
+    let _ = std::fs::remove_dir(&config_dir);
+    let _ = std::fs::remove_dir(&startup_cwd);
+}
+
+#[test]
+fn resolve_runtime_base_dir_uses_explicit_config_parent_from_root() {
+    let nonce = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
+    let config_dir = std::env::temp_dir().join(format!("telemt_runtime_base_root_cfg_{nonce}"));
+    std::fs::create_dir_all(&config_dir).unwrap();
+
+    let resolved =
+        resolve_runtime_base_dir(&config_dir.join("telemt.toml"), Path::new("/"), true, None);
+    assert_eq!(resolved, config_dir.canonicalize().unwrap());
+
+    let _ = std::fs::remove_dir(&config_dir);
+}
+
+#[test]
+fn resolve_runtime_base_dir_uses_systemd_working_directory_before_etc() {
+    let nonce = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
+    let startup_cwd = std::env::temp_dir().join(format!("telemt_runtime_base_systemd_{nonce}"));
+    std::fs::create_dir_all(&startup_cwd).unwrap();
+
+    let resolved =
+        resolve_runtime_base_dir(&startup_cwd.join("config.toml"), &startup_cwd, false, None);
+    assert_eq!(resolved, startup_cwd.canonicalize().unwrap());
+
+    let _ = std::fs::remove_dir(&startup_cwd);
+}
+
+#[test]
+fn resolve_runtime_base_dir_falls_back_to_etc_from_root() {
+    let resolved = resolve_runtime_base_dir(
+        Path::new("/etc/telemt/config.toml"),
+        Path::new("/"),
+        false,
+        None,
+    );
+    assert_eq!(resolved, PathBuf::from("/etc/telemt"));
+}
+
+#[test]
+fn expected_handshake_eof_matches_connection_reset() {
+    let err = ProxyError::Io(std::io::Error::from(std::io::ErrorKind::ConnectionReset));
+    assert!(is_expected_handshake_eof(&err));
+}
+
+#[test]
+fn expected_handshake_eof_matches_stream_io_unexpected_eof() {
+    let err = ProxyError::Stream(StreamError::Io(std::io::Error::from(
+        std::io::ErrorKind::UnexpectedEof,
+    )));
+    assert!(is_expected_handshake_eof(&err));
+}
+
+#[test]
+fn peer_close_description_is_human_readable_for_all_peer_close_kinds() {
+    let cases = [
+        (
+            std::io::ErrorKind::ConnectionReset,
+            "Peer reset TCP connection (RST)",
+        ),
+        (
+            std::io::ErrorKind::ConnectionAborted,
+            "Peer aborted TCP connection during transport",
+        ),
+        (
+            std::io::ErrorKind::BrokenPipe,
+            "Peer closed write side (broken pipe)",
+        ),
+        (
+            std::io::ErrorKind::NotConnected,
+            "Socket was already closed by peer",
+        ),
+    ];
+
+    for (kind, expected) in cases {
+        let err = ProxyError::Io(std::io::Error::from(kind));
+        assert_eq!(peer_close_description(&err), Some(expected));
     }
+}
 
-    #[test]
-    fn maestro_line_formatter_keeps_color_when_enabled() {
-        let colored = format_maestro_line("boot", true);
-        assert!(colored.contains("\x1b[92mMAESTRO\x1b[0m"));
-    }
-
-    #[test]
-    fn resolve_runtime_config_path_anchors_relative_to_startup_cwd() {
-        let nonce = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos();
-        let startup_cwd = std::env::temp_dir().join(format!("telemt_cfg_path_{nonce}"));
-        std::fs::create_dir_all(&startup_cwd).unwrap();
-        let target = startup_cwd.join("config.toml");
-        std::fs::write(&target, " ").unwrap();
-
-        let resolved = resolve_runtime_config_path("config.toml", &startup_cwd, true);
-        assert_eq!(resolved, target.canonicalize().unwrap());
-
-        let _ = std::fs::remove_file(&target);
-        let _ = std::fs::remove_dir(&startup_cwd);
-    }
-
-    #[test]
-    fn resolve_runtime_config_path_keeps_absolute_for_missing_file() {
-        let nonce = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos();
-        let startup_cwd = std::env::temp_dir().join(format!("telemt_cfg_path_missing_{nonce}"));
-        std::fs::create_dir_all(&startup_cwd).unwrap();
-
-        let resolved = resolve_runtime_config_path("missing.toml", &startup_cwd, true);
-        assert_eq!(resolved, startup_cwd.join("missing.toml"));
-
-        let _ = std::fs::remove_dir(&startup_cwd);
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn runtime_paths_preserve_symlinks_for_descriptor_validation() {
-        use std::os::unix::fs::symlink;
-
-        let dir = tempfile::tempdir().unwrap();
-        let real_dir = dir.path().join("real");
-        let linked_dir = dir.path().join("linked");
-        std::fs::create_dir(&real_dir).unwrap();
-        std::fs::write(real_dir.join("config.toml"), " ").unwrap();
-        symlink(&real_dir, &linked_dir).unwrap();
-        let linked_config = linked_dir.join("config.toml");
-
-        let config = resolve_runtime_config_path(
-            linked_config.to_str().unwrap(),
-            dir.path(),
-            true,
-        );
-        let runtime = resolve_runtime_base_dir(
-            &linked_config,
-            dir.path(),
-            true,
-            Some(&linked_dir),
-        );
-
-        assert_eq!(config, linked_config);
-        assert_eq!(runtime, linked_dir);
-    }
-
-    #[test]
-    fn resolve_runtime_config_path_uses_startup_candidates_when_not_explicit() {
-        let nonce = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos();
-        let startup_cwd =
-            std::env::temp_dir().join(format!("telemt_cfg_startup_candidates_{nonce}"));
-        std::fs::create_dir_all(&startup_cwd).unwrap();
-        let telemt = startup_cwd.join("telemt.toml");
-        std::fs::write(&telemt, " ").unwrap();
-
-        let resolved = resolve_runtime_config_path("config.toml", &startup_cwd, false);
-        assert_eq!(resolved, telemt.canonicalize().unwrap());
-
-        let _ = std::fs::remove_file(&telemt);
-        let _ = std::fs::remove_dir(&startup_cwd);
-    }
-
-    #[test]
-    fn resolve_runtime_config_path_defaults_to_startup_config_when_none_found() {
-        let nonce = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos();
-        let startup_cwd = std::env::temp_dir().join(format!("telemt_cfg_startup_default_{nonce}"));
-        std::fs::create_dir_all(&startup_cwd).unwrap();
-
-        let resolved = resolve_runtime_config_path("config.toml", &startup_cwd, false);
-        assert_eq!(resolved, startup_cwd.join("config.toml"));
-
-        let _ = std::fs::remove_dir(&startup_cwd);
-    }
-
-    #[test]
-    fn resolve_runtime_base_dir_prefers_cli_data_path() {
-        let nonce = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos();
-        let startup_cwd = std::env::temp_dir().join(format!("telemt_runtime_base_cwd_{nonce}"));
-        let data_path = std::env::temp_dir().join(format!("telemt_runtime_base_data_{nonce}"));
-        std::fs::create_dir_all(&startup_cwd).unwrap();
-        std::fs::create_dir_all(&data_path).unwrap();
-
-        let resolved = resolve_runtime_base_dir(
-            &startup_cwd.join("config.toml"),
-            &startup_cwd,
-            true,
-            Some(&data_path),
-        );
-        assert_eq!(resolved, data_path.canonicalize().unwrap());
-
-        let _ = std::fs::remove_dir(&data_path);
-        let _ = std::fs::remove_dir(&startup_cwd);
-    }
-
-    #[test]
-    fn resolve_runtime_base_dir_uses_working_directory_before_explicit_config_parent() {
-        let nonce = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos();
-        let startup_cwd = std::env::temp_dir().join(format!("telemt_runtime_base_start_{nonce}"));
-        let config_dir = std::env::temp_dir().join(format!("telemt_runtime_base_cfg_{nonce}"));
-        std::fs::create_dir_all(&startup_cwd).unwrap();
-        std::fs::create_dir_all(&config_dir).unwrap();
-
-        let resolved =
-            resolve_runtime_base_dir(&config_dir.join("telemt.toml"), &startup_cwd, true, None);
-        assert_eq!(resolved, startup_cwd.canonicalize().unwrap());
-
-        let _ = std::fs::remove_dir(&config_dir);
-        let _ = std::fs::remove_dir(&startup_cwd);
-    }
-
-    #[test]
-    fn resolve_runtime_base_dir_uses_explicit_config_parent_from_root() {
-        let nonce = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos();
-        let config_dir = std::env::temp_dir().join(format!("telemt_runtime_base_root_cfg_{nonce}"));
-        std::fs::create_dir_all(&config_dir).unwrap();
-
-        let resolved =
-            resolve_runtime_base_dir(&config_dir.join("telemt.toml"), Path::new("/"), true, None);
-        assert_eq!(resolved, config_dir.canonicalize().unwrap());
-
-        let _ = std::fs::remove_dir(&config_dir);
-    }
-
-    #[test]
-    fn resolve_runtime_base_dir_uses_systemd_working_directory_before_etc() {
-        let nonce = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos();
-        let startup_cwd = std::env::temp_dir().join(format!("telemt_runtime_base_systemd_{nonce}"));
-        std::fs::create_dir_all(&startup_cwd).unwrap();
-
-        let resolved =
-            resolve_runtime_base_dir(&startup_cwd.join("config.toml"), &startup_cwd, false, None);
-        assert_eq!(resolved, startup_cwd.canonicalize().unwrap());
-
-        let _ = std::fs::remove_dir(&startup_cwd);
-    }
-
-    #[test]
-    fn resolve_runtime_base_dir_falls_back_to_etc_from_root() {
-        let resolved = resolve_runtime_base_dir(
-            Path::new("/etc/telemt/config.toml"),
-            Path::new("/"),
-            false,
-            None,
-        );
-        assert_eq!(resolved, PathBuf::from("/etc/telemt"));
-    }
-
-    #[test]
-    fn expected_handshake_eof_matches_connection_reset() {
-        let err = ProxyError::Io(std::io::Error::from(std::io::ErrorKind::ConnectionReset));
-        assert!(is_expected_handshake_eof(&err));
-    }
-
-    #[test]
-    fn expected_handshake_eof_matches_stream_io_unexpected_eof() {
-        let err = ProxyError::Stream(StreamError::Io(std::io::Error::from(
-            std::io::ErrorKind::UnexpectedEof,
-        )));
-        assert!(is_expected_handshake_eof(&err));
-    }
-
-    #[test]
-    fn peer_close_description_is_human_readable_for_all_peer_close_kinds() {
-        let cases = [
-            (
-                std::io::ErrorKind::ConnectionReset,
-                "Peer reset TCP connection (RST)",
-            ),
-            (
-                std::io::ErrorKind::ConnectionAborted,
-                "Peer aborted TCP connection during transport",
-            ),
-            (
-                std::io::ErrorKind::BrokenPipe,
-                "Peer closed write side (broken pipe)",
-            ),
-            (
-                std::io::ErrorKind::NotConnected,
-                "Socket was already closed by peer",
-            ),
-        ];
-
-        for (kind, expected) in cases {
-            let err = ProxyError::Io(std::io::Error::from(kind));
-            assert_eq!(peer_close_description(&err), Some(expected));
-        }
-    }
-
-    #[test]
-    fn handshake_close_description_is_human_readable_for_all_expected_kinds() {
-        let cases = [
-            (
-                ProxyError::Io(std::io::Error::from(std::io::ErrorKind::UnexpectedEof)),
-                "Peer closed before sending full 64-byte MTProto handshake",
-            ),
-            (
-                ProxyError::Io(std::io::Error::from(std::io::ErrorKind::ConnectionReset)),
-                "Peer reset TCP connection during initial MTProto handshake",
-            ),
-            (
-                ProxyError::Io(std::io::Error::from(std::io::ErrorKind::ConnectionAborted)),
-                "Peer aborted TCP connection during initial MTProto handshake",
-            ),
-            (
-                ProxyError::Io(std::io::Error::from(std::io::ErrorKind::BrokenPipe)),
-                "Peer closed write side before MTProto handshake completed",
-            ),
-            (
-                ProxyError::Io(std::io::Error::from(std::io::ErrorKind::NotConnected)),
-                "Handshake socket was already closed by peer",
-            ),
-            (
-                ProxyError::Stream(StreamError::UnexpectedEof),
-                "Peer closed before sending full 64-byte MTProto handshake",
-            ),
-        ];
-
-        for (err, expected) in cases {
-            assert_eq!(expected_handshake_close_description(&err), Some(expected));
-        }
+#[test]
+fn handshake_close_description_is_human_readable_for_all_expected_kinds() {
+    let cases = [
+        (
+            ProxyError::Io(std::io::Error::from(std::io::ErrorKind::UnexpectedEof)),
+            "Peer closed before sending full 64-byte MTProto handshake",
+        ),
+        (
+            ProxyError::Io(std::io::Error::from(std::io::ErrorKind::ConnectionReset)),
+            "Peer reset TCP connection during initial MTProto handshake",
+        ),
+        (
+            ProxyError::Io(std::io::Error::from(std::io::ErrorKind::ConnectionAborted)),
+            "Peer aborted TCP connection during initial MTProto handshake",
+        ),
+        (
+            ProxyError::Io(std::io::Error::from(std::io::ErrorKind::BrokenPipe)),
+            "Peer closed write side before MTProto handshake completed",
+        ),
+        (
+            ProxyError::Io(std::io::Error::from(std::io::ErrorKind::NotConnected)),
+            "Handshake socket was already closed by peer",
+        ),
+        (
+            ProxyError::Stream(StreamError::UnexpectedEof),
+            "Peer closed before sending full 64-byte MTProto handshake",
+        ),
+    ];
+
+    for (err, expected) in cases {
+        assert_eq!(expected_handshake_close_description(&err), Some(expected));
     }
+}

src/maestro/listeners/bind.rs

@@ -234,7 +234,10 @@ fn remove_stale_unix_socket(path: &Path) -> std::io::Result<()> {
     {
         return Err(IoError::new(
             ErrorKind::AlreadyExists,
-            format!("Unix listener path {} changed during cleanup", path.display()),
+            format!(
+                "Unix listener path {} changed during cleanup",
+                path.display()
+            ),
         ));
     }
     std::fs::remove_file(path)
@@ -373,7 +376,12 @@ mod tests {
         assert!(remove_stale_unix_socket(&regular).is_err());
         assert!(remove_stale_unix_socket(&link).is_err());
         assert_eq!(std::fs::read(&regular).unwrap(), b"preserve");
-        assert!(std::fs::symlink_metadata(&link).unwrap().file_type().is_symlink());
+        assert!(
+            std::fs::symlink_metadata(&link)
+                .unwrap()
+                .file_type()
+                .is_symlink()
+        );
     }
 
     #[test]

src/maestro/orchestrator.rs

@@ -49,9 +49,7 @@ pub(super) async fn run_telemt_core(
     } = bootstrap::bootstrap(privilege_drop_requested).await?;
 
     if privilege_drop_requested && config.server.conntrack_control.inline_conntrack_control {
-        warn!(
-            "Inline conntrack control is disabled when process privileges are dropped"
-        );
+        warn!("Inline conntrack control is disabled when process privileges are dropped");
         config.server.conntrack_control.inline_conntrack_control = false;
     }
 

src/maestro/reload_supervisor.rs

@@ -366,8 +366,8 @@ impl ReloadSupervisor {
         self.runtime_watch_tx
             .send_replace(Some(new_runtime.watch_state()));
         if !conntrack_firewall_published {
-            let warning = "conntrack firewall reconciler is unavailable after runtime activation"
-                .to_string();
+            let warning =
+                "conntrack firewall reconciler is unavailable after runtime activation".to_string();
             warn!(reload_id = command.reload_id, warning = %warning);
             self.control.add_warning(command.reload_id, warning).await;
         }

src/maestro/runtime_build.rs

@@ -11,9 +11,7 @@ use crate::config::{
 use crate::crypto::SecureRandom;
 use crate::ip_tracker::UserIpTracker;
 use crate::network::probe::{decide_network_capabilities, run_probe};
-use crate::proxy::direct_buffer_budget::{
-    DirectBufferBudget, run_direct_buffer_budget_controller,
-};
+use crate::proxy::direct_buffer_budget::{DirectBufferBudget, run_direct_buffer_budget_controller};
 use crate::proxy::route_mode::{RelayRouteMode, RouteRuntimeController};
 use crate::proxy::shared_state::ProxySharedState;
 use crate::proxy::traffic_limiter::TrafficLimiter;
@@ -29,9 +27,7 @@ use crate::transport::UpstreamManager;
 use crate::transport::middle_proxy::MePool;
 
 use super::admission;
-use super::generation::{
-    RuntimeGeneration, RuntimeTaskScope, RuntimeTaskScopePreparationGuard,
-};
+use super::generation::{RuntimeGeneration, RuntimeTaskScope, RuntimeTaskScopePreparationGuard};
 use super::listeners::listener_rebind_supported;
 use super::runtime_tasks::RuntimeLogFilter;
 use super::{me_startup, runtime_tasks, tls_bootstrap};

src/maestro/runtime_build_tests.rs

@@ -135,14 +135,9 @@ fn conntrack_control_policy_is_restart_only_as_one_process_owned_unit() {
         !old.server.conntrack_control.inline_conntrack_control;
     desired.server.conntrack_control.mode = crate::config::ConntrackMode::Notrack;
     desired.server.conntrack_control.backend = crate::config::ConntrackBackend::Iptables;
-    desired.server.conntrack_control.profile =
-        crate::config::ConntrackPressureProfile::Aggressive;
-    desired.server.conntrack_control.hybrid_listener_ips =
-        vec!["192.0.2.10".parse().unwrap()];
-    desired
-        .server
-        .conntrack_control
-        .pressure_high_watermark_pct = 90;
+    desired.server.conntrack_control.profile = crate::config::ConntrackPressureProfile::Aggressive;
+    desired.server.conntrack_control.hybrid_listener_ips = vec!["192.0.2.10".parse().unwrap()];
+    desired.server.conntrack_control.pressure_high_watermark_pct = 90;
     desired.server.conntrack_control.pressure_low_watermark_pct = 40;
     desired.server.conntrack_control.delete_budget_per_sec = old
         .server