update deps, clean up some code

Author: 0x7d8

Cargo.lock

@@ -17,7 +17,6 @@ utoipa-axum = "0.2.0"
 reqwest = { version = "0.13.0", features = ["hickory-dns", "json", "multipart", "stream"] }
 tokio = { version = "1.43.0", features = ["full"] }
 chrono = { version = "0.4.40", features = ["serde"] }
-futures-util = "0.3.31"
 tokio-util = { version = "0.7.15", features = ["full"] }
 uuid = { version = "1.16.0", features = ["serde", "v4"] }
 rand = "0.9.1"

Cargo.toml

@@ -7,7 +7,7 @@ edition = "2024"
 [dependencies]
 unrar = { path = "../unrar-rs" }
 tracing = "0.1.41"
-tracing-subscriber = { version = "=0.3.19", features = ["chrono"] } # temporary pin to avoid new ansi escaping
+tracing-subscriber = { version = "0.3.19", features = ["chrono"] }
 tracing-appender = "0.2.3"
 anyhow = { workspace = true }
 axum = { workspace = true }
@@ -20,13 +20,12 @@ utoipa = { workspace = true }
 utoipa-axum = { workspace = true }
 reqwest = { workspace = true }
 tokio = { workspace = true }
-colored = "3.0.0"
 chrono = { workspace = true }
+colored = "3.0.0"
 nestify = "0.3.3"
 rayon = "1.10.0"
 serde_norway = "0.9.42"
 serde_default = "0.2.0"
-futures-util = { workspace = true }
 tokio-util = { workspace = true }
 uuid = { workspace = true }
 rand = { workspace = true }
@@ -89,9 +88,6 @@ sntpc = { version = "0.8.1", features = ["std"] }
 libz-ng-sys = "=1.1.23" # temporary pin due to riscv64 issues
 notify = "8.2.0"
 
-[target.'cfg(unix)'.dependencies]
-users = "0.11.0"
-
 [target.'cfg(all(target_os = "linux", target_arch = "x86_64"))'.dependencies]
 tikv-jemallocator = "0.6.0"
 

application/Cargo.toml

@@ -1204,25 +1204,43 @@ impl Config {
             return Ok(());
         }
 
-        if self.system.user.rootless.enabled {
-            let user = users::get_current_uid();
-            let group = users::get_current_gid();
-
-            if let Some(username) = users::get_current_username() {
-                self.system.username = username.to_string_lossy().to_compact_string();
-            }
+        if let Ok(current_pid) = sysinfo::get_current_pid() {
+            let mut sys = sysinfo::System::new_all();
+            sys.refresh_processes_specifics(
+                sysinfo::ProcessesToUpdate::Some(&[current_pid]),
+                false,
+                sysinfo::ProcessRefreshKind::nothing().with_memory(),
+            );
+            if let Some(process) = sys.process(current_pid) {
+                if self.system.user.rootless.enabled {
+                    if let Some(user) = process.user_id() {
+                        let users = sysinfo::Users::new_with_refreshed_list();
+                        if let Some(user) = users.get_user_by_id(user) {
+                            self.system.username = user.name().to_compact_string();
+                        }
 
-            self.system.user.uid = user;
-            self.system.user.gid = group;
+                        self.system.user.uid = **user;
+                    }
+                    if let Some(group) = process.group_id() {
+                        self.system.user.gid = *group;
+                    }
 
-            return Ok(());
-        }
+                    return Ok(());
+                }
 
-        if let Some(user) = users::get_user_by_name(&self.system.username) {
-            self.system.user.uid = user.uid();
-            self.system.user.gid = user.primary_group_id();
+                let mut found_user = false;
+                if let Some(user) = process.user_id() {
+                    self.system.user.uid = **user;
+                    found_user = true;
+                }
+                if let Some(group) = process.group_id() {
+                    self.system.user.gid = *group;
+                }
 
-            return Ok(());
+                if found_user {
+                    return Ok(());
+                }
+            }
         }
 
         let command = if release.contains("alpine") {
@@ -1258,11 +1276,21 @@ impl Config {
             );
         }
 
-        let user = users::get_user_by_name(&self.system.username)
-            .context(format!("failed to get user {}", self.system.username))?;
+        let users = sysinfo::Users::new_with_refreshed_list();
+
+        let Some(user) = users
+            .list()
+            .iter()
+            .find(|u| u.name() == self.system.username)
+        else {
+            return Err(anyhow::anyhow!(
+                "failed to find user {} after creating it",
+                self.system.username
+            ));
+        };
 
-        self.system.user.uid = user.uid();
-        self.system.user.gid = user.primary_group_id();
+        self.system.user.uid = **user.id();
+        self.system.user.gid = *user.group_id();
 
         Ok(())
     }

application/src/config.rs

@@ -19,15 +19,10 @@ static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
 
 async fn handle_request(req: Request<Body>, next: Next) -> Result<Response<Body>, StatusCode> {
     tracing::info!(
-        "http {} {}{}",
+        path = req.uri().path(),
+        query = req.uri().query().unwrap_or_default(),
+        "http {}",
         req.method().to_string().to_lowercase(),
-        req.uri().path().cyan(),
-        if let Some(query) = req.uri().query() {
-            format!("?{query}")
-        } else {
-            "".to_string()
-        }
-        .bright_cyan()
     );
 
     Ok(wings_rs::response::ACCEPT_HEADER
@@ -156,11 +151,8 @@ async fn main() {
             tracing::info!("   \\_/\\_/ |_|_| |_|\\__, |___/__ ___ ");
             tracing::info!("                    __/ | | '__/ __|");
             tracing::info!("                   |___/  | |  \\__ \\");
-            tracing::info!(
-                "{: >25} |_|  |___/",
-                format!("{} (git-{})", wings_rs::VERSION, wings_rs::GIT_COMMIT)
-            );
-            tracing::info!("github.com/calagopus/wings\n");
+            tracing::info!("{: >25} |_|  |___/", wings_rs::VERSION);
+            tracing::info!("github.com/calagopus/wings#{}\n", wings_rs::GIT_COMMIT);
         }
     }
 
@@ -465,15 +457,10 @@ async fn main() {
                 ));
 
                 tracing::info!(
-                    "{} listening on {} {}",
-                    "ssh server".yellow(),
+                    "ssh server listening on {} (app@{}, {}ms)",
                     address.to_string().cyan(),
-                    format!(
-                        "(app@{}, {}ms)",
-                        wings_rs::VERSION,
-                        state.start_time.elapsed().as_millis()
-                    )
-                    .bright_black()
+                    wings_rs::VERSION,
+                    state.start_time.elapsed().as_millis()
                 );
 
                 match server.run_on_address(Arc::new(config), address).await {
@@ -516,11 +503,7 @@ async fn main() {
             .context("failed to load SSL certificate and key")
             .unwrap();
 
-            tracing::info!(
-                "{} listening on {}",
-                "https server".bright_red(),
-                address.to_string().cyan(),
-            );
+            tracing::info!("https listening on {}", address.to_string().cyan(),);
 
             match axum_server::bind_rustls(address, config)
                 .serve(router.into_make_service_with_connect_info::<SocketAddr>())
@@ -538,11 +521,7 @@ async fn main() {
                 }
             }
         } else {
-            tracing::info!(
-                "{} listening on {}",
-                "http server".bright_red(),
-                address.to_string().cyan(),
-            );
+            tracing::info!("http listening on {}", address.to_string().cyan(),);
 
             match axum::serve(
                 match tokio::net::TcpListener::bind(address).await {
@@ -578,11 +557,7 @@ async fn main() {
         {
             let socket_path = &state.config.api.host;
 
-            tracing::info!(
-                "{} listening on {}",
-                "http server".bright_red(),
-                socket_path.cyan(),
-            );
+            tracing::info!("http server listening on {}", socket_path.cyan(),);
 
             let router = router.layer(axum::middleware::from_fn(
                 |mut req: Request, next: Next| async move {

application/src/main.rs

@@ -13,7 +13,7 @@ mod post {
         extract::Query,
         http::{HeaderMap, StatusCode},
     };
-    use futures_util::StreamExt;
+    use futures::StreamExt;
     use serde::{Deserialize, Serialize};
     use tokio::io::AsyncWriteExt;
     use utoipa::ToSchema;

application/src/routes/api/servers/_server_/files/write.rs

@@ -13,7 +13,7 @@ pub async fn handle_ws(ws: WebSocketUpgrade, state: GetState) -> Response {
     ws.on_upgrade(move |socket| async move {
         let socket = Arc::new(tokio::sync::Mutex::new(socket));
 
-        type ReturnType = dyn futures_util::Future<Output = Result<(), anyhow::Error>> + Send;
+        type ReturnType = dyn Future<Output = Result<(), anyhow::Error>> + Send;
         let futures: [Pin<Box<ReturnType>>; 2] = [
             // Stats Listener
             Box::pin({
@@ -50,7 +50,7 @@ pub async fn handle_ws(ws: WebSocketUpgrade, state: GetState) -> Response {
             }),
         ];
 
-        if let Err(err) = futures_util::future::try_join_all(futures).await {
+        if let Err(err) = futures::future::try_join_all(futures).await {
             tracing::debug!("error while serving stats websocket: {:?}", err);
         }
     })