Update Rust crate sysinfo to 0.34.0

Reviewed-on: #296

virtweb_backend/Cargo.toml

@@ -6,43 +6,43 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-log = "0.4.21"
-env_logger = "0.11.3"
-clap = { version = "4.5.20", features = ["derive", "env"] }
-light-openid = { version = "1.0.2", features = ["crypto-wrapper"] }
+log = "0.4.26"
+env_logger = "0.11.7"
+clap = { version = "4.5.32", features = ["derive", "env"] }
+light-openid = { version = "1.0.4", features = ["crypto-wrapper"] }
 lazy_static = "1.5.0"
-actix = "0.13.3"
-actix-web = "4.9.0"
+actix = "0.13.5"
+actix-web = "4.10.2"
 actix-remote-ip = "0.1.0"
-actix-session = { version = "0.10.0", features = ["cookie-session"] }
+actix-session = { version = "0.10.1", features = ["cookie-session"] }
 actix-identity = "0.8.0"
-actix-cors = "0.7.0"
-actix-files = "0.6.5"
-actix-web-actors = "4.3.0"
-actix-http = "3.9.0"
-serde = { version = "1.0.215", features = ["derive"] }
-serde_json = "1.0.132"
-quick-xml = { version = "0.37.1", features = ["serialize", "overlapped-lists"] }
+actix-cors = "0.7.1"
+actix-files = "0.6.6"
+actix-ws = "0.3.0"
+actix-http = "3.10.0"
+serde = { version = "1.0.219", features = ["derive"] }
+serde_json = "1.0.140"
+quick-xml = { version = "0.37.2", features = ["serialize", "overlapped-lists"] }
 futures-util = "0.3.31"
-anyhow = "1.0.93"
-actix-multipart = "0.7.0"
-tempfile = "3.14.0"
-reqwest = { version = "0.12.9", features = ["stream"] }
-url = "2.5.0"
-virt = "0.4.1"
-sysinfo = { version = "0.32.0", features = ["serde"] }
-uuid = { version = "1.11.0", features = ["v4", "serde"] }
-lazy-regex = "3.3.0"
-thiserror = "2.0.0"
-image = "0.25.4"
-rand = "0.8.5"
-bytes = "1.8.0"
-tokio = "1.41.1"
+anyhow = "1.0.97"
+actix-multipart = "0.7.2"
+tempfile = "3.19.1"
+reqwest = { version = "0.12.15", features = ["stream"] }
+url = "2.5.4"
+virt = "0.4.2"
+sysinfo = { version = "0.34.0", features = ["serde"] }
+uuid = { version = "1.16.0", features = ["v4", "serde"] }
+lazy-regex = "3.4.1"
+thiserror = "2.0.12"
+image = "0.25.5"
+rand = "0.9.0"
+bytes = "1.10.1"
+tokio = { version = "1.44.1", features = ["rt", "time", "macros"] }
 futures = "0.3.31"
-ipnetwork = "0.20.0"
+ipnetwork = { version = "0.21.1", features = ["serde"] }
 num = "0.4.2"
 rust-embed = { version = "8.5.0" }
-mime_guess = "2.0.4"
+mime_guess = "2.0.5"
 dotenvy = "0.15.7"
 nix = { version = "0.29.0", features = ["net"] }
 basic-jwt = "0.2.0"

virtweb_backend/src/actors/mod.rs

@@ -1,3 +1,3 @@
 pub mod libvirt_actor;
-pub mod vnc_actor;
+pub mod vnc_handler;
 pub mod vnc_tokens_actor;

virtweb_backend/src/actors/vnc_actor.rs

@@ -1,209 +0,0 @@
-use actix::{Actor, ActorContext, AsyncContext, Handler, StreamHandler};
-use actix_http::ws::Item;
-use actix_web_actors::ws;
-use actix_web_actors::ws::Message;
-use bytes::Bytes;
-use image::EncodableLayout;
-use std::path::Path;
-use std::time::{Duration, Instant};
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use tokio::net::unix::{OwnedReadHalf, OwnedWriteHalf};
-use tokio::net::UnixStream;
-
-/// How often heartbeat pings are sent
-const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(5);
-
-/// How long before lack of client response causes a timeout
-const CLIENT_TIMEOUT: Duration = Duration::from_secs(20);
-
-#[derive(thiserror::Error, Debug)]
-enum VNCError {
-    #[error("Socket file does not exists!")]
-    SocketDoesNotExists,
-}
-
-pub struct VNCActor {
-    /// Qemu -> WS
-    read_half: Option<OwnedReadHalf>,
-
-    /// WS -> Qemu
-    write_half: OwnedWriteHalf,
-
-    // Client must respond to ping at a specific interval, otherwise we drop connection
-    hb: Instant,
-}
-
-impl VNCActor {
-    pub async fn new(socket_path: &str) -> anyhow::Result<Self> {
-        let socket_path = Path::new(socket_path);
-
-        if !socket_path.exists() {
-            return Err(VNCError::SocketDoesNotExists.into());
-        }
-
-        let socket = UnixStream::connect(socket_path).await?;
-        let (read_half, write_half) = socket.into_split();
-
-        Ok(Self {
-            read_half: Some(read_half),
-            write_half,
-            hb: Instant::now(),
-        })
-    }
-
-    /// helper method that sends ping to client every second.
-    ///
-    /// also this method checks heartbeats from client
-    fn hb(&self, ctx: &mut ws::WebsocketContext<Self>) {
-        ctx.run_interval(HEARTBEAT_INTERVAL, |act, ctx| {
-            // check client heartbeats
-            if Instant::now().duration_since(act.hb) > CLIENT_TIMEOUT {
-                // heartbeat timed out
-                log::warn!("WebSocket Client heartbeat failed, disconnecting!");
-                ctx.stop();
-                return;
-            }
-
-            ctx.ping(b"");
-        });
-    }
-
-    fn send_to_socket(&mut self, bytes: Bytes, ctx: &mut ws::WebsocketContext<Self>) {
-        log::trace!("Received {} bytes for VNC socket", bytes.len());
-
-        if let Err(e) = futures::executor::block_on(self.write_half.write(bytes.as_bytes())) {
-            log::error!("Failed to relay bytes to VNC socket {e}");
-            ctx.close(None);
-        }
-    }
-
-    fn start_qemu_to_ws_end(&mut self, ctx: &mut ws::WebsocketContext<Self>) {
-        let mut read_half = self.read_half.take().unwrap();
-        let addr = ctx.address();
-        let future = async move {
-            let mut buff: [u8; 5000] = [0; 5000];
-            loop {
-                match read_half.read(&mut buff).await {
-                    Ok(mut l) => {
-                        if l == 0 {
-                            log::warn!("Got empty read!");
-
-                            // Ugly hack made to wait for next byte
-                            let mut one_byte_buff: [u8; 1] = [0; 1];
-                            match read_half.read_exact(&mut one_byte_buff).await {
-                                Ok(b) => {
-                                    if b == 0 {
-                                        log::error!("Did not get a byte !");
-                                        let _ = addr.send(CloseWebSocketReq).await;
-                                        break;
-                                    }
-                                    buff[0] = one_byte_buff[0];
-                                    l = 1;
-                                }
-                                Err(e) => {
-                                    log::error!("Failed to read 1 BYTE from remote socket. Stopping now... {:?}", e);
-                                    break;
-                                }
-                            }
-                        }
-
-                        let to_send = SendBytesReq(Vec::from(&buff[0..l]));
-                        if let Err(e) = addr.send(to_send).await {
-                            log::error!("Failed to send to websocket. Stopping now... {:?}", e);
-                            return;
-                        }
-                    }
-                    Err(e) => {
-                        log::error!("Failed to read from remote socket. Stopping now... {:?}", e);
-                        break;
-                    }
-                };
-            }
-
-            log::info!("Exited read loop");
-        };
-
-        tokio::spawn(future);
-    }
-}
-
-impl Actor for VNCActor {
-    type Context = ws::WebsocketContext<Self>;
-
-    fn started(&mut self, ctx: &mut Self::Context) {
-        self.hb(ctx);
-        self.start_qemu_to_ws_end(ctx);
-    }
-}
-
-impl StreamHandler<Result<Message, ws::ProtocolError>> for VNCActor {
-    fn handle(&mut self, msg: Result<Message, ws::ProtocolError>, ctx: &mut Self::Context) {
-        match msg {
-            Ok(Message::Ping(msg)) => ctx.pong(&msg),
-
-            Ok(Message::Text(_text)) => {
-                log::error!("Received unexpected text on VNC WebSocket!");
-            }
-
-            Ok(Message::Binary(bin)) => {
-                log::info!("Forward {} bytes to VNC server", bin.len());
-                self.send_to_socket(bin, ctx);
-            }
-
-            Ok(Message::Continuation(msg)) => match msg {
-                Item::FirstText(_) => {
-                    log::error!("Received unexpected split text!");
-                    ctx.close(None);
-                }
-                Item::FirstBinary(bin) | Item::Continue(bin) | Item::Last(bin) => {
-                    self.send_to_socket(bin, ctx);
-                }
-            },
-
-            Ok(Message::Pong(_)) => {
-                log::trace!("Received PONG message");
-                self.hb = Instant::now();
-            }
-
-            Ok(Message::Close(r)) => {
-                log::info!("WebSocket closed. Reason={r:?}");
-                ctx.close(r);
-            }
-
-            Ok(Message::Nop) => {
-                log::debug!("Received Nop message")
-            }
-
-            Err(e) => {
-                log::error!("WebSocket protocol error! {e}");
-                ctx.close(None)
-            }
-        }
-    }
-}
-
-#[derive(actix::Message)]
-#[rtype(result = "()")]
-pub struct SendBytesReq(Vec<u8>);
-
-impl Handler<SendBytesReq> for VNCActor {
-    type Result = ();
-
-    fn handle(&mut self, msg: SendBytesReq, ctx: &mut Self::Context) -> Self::Result {
-        log::trace!("Send {} bytes to WS", msg.0.len());
-        ctx.binary(msg.0);
-    }
-}
-
-#[derive(actix::Message)]
-#[rtype(result = "()")]
-pub struct CloseWebSocketReq;
-
-impl Handler<CloseWebSocketReq> for VNCActor {
-    type Result = ();
-
-    fn handle(&mut self, _msg: CloseWebSocketReq, ctx: &mut Self::Context) -> Self::Result {
-        log::trace!("Close websocket, because VNC socket has terminated");
-        ctx.close(None);
-    }
-}

virtweb_backend/src/actors/vnc_handler.rs

@@ -0,0 +1,129 @@
+use actix_http::ws::Message;
+use futures_util::StreamExt as _;
+use std::time::{Duration, Instant};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::UnixStream;
+use tokio::select;
+use tokio::time::interval;
+
+/// How often heartbeat pings are sent
+const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(5);
+
+/// How long before lack of client response causes a timeout
+const CLIENT_TIMEOUT: Duration = Duration::from_secs(20);
+
+/// Broadcast text & binary messages received from a client, respond to ping messages, and monitor
+/// connection health to detect network issues and free up resources.
+pub async fn handle(
+    mut session: actix_ws::Session,
+    mut msg_stream: actix_ws::MessageStream,
+    mut socket: UnixStream,
+) {
+    log::info!("Connected to websocket");
+
+    let mut last_heartbeat = Instant::now();
+    let mut interval = interval(HEARTBEAT_INTERVAL);
+
+    let mut buf_socket = [0u8; 1024];
+
+    let reason = loop {
+        // waits for either `msg_stream` to receive a message from the client, the broadcast channel
+        // to send a message, or the heartbeat interval timer to tick, yielding the value of
+        // whichever one is ready first
+        select! {
+
+            // heartbeat interval ticked
+            _tick = interval.tick() => {
+                // if no heartbeat ping/pong received recently, close the connection
+                if Instant::now().duration_since(last_heartbeat) > CLIENT_TIMEOUT {
+                    log::info!(
+                        "client has not sent heartbeat in over {CLIENT_TIMEOUT:?}; disconnecting"
+                    );
+
+                    break None;
+                }
+
+                // send heartbeat ping
+                let _ = session.ping(b"").await;
+            }
+
+            msg = msg_stream.next() => {
+                let msg = match msg {
+                    // received message from WebSocket client
+                    Some(Ok(msg)) => msg,
+
+                    // client WebSocket stream error
+                    Some(Err(err)) => {
+                        log::error!("{err}");
+                        break None;
+                    }
+
+                    // client WebSocket stream ended
+                    None => break None
+                };
+
+                log::debug!("msg: {msg:?}");
+
+                match msg {
+                    Message::Text(_) => {
+                        log::error!("Received unexpected text on VNC WebSocket!");
+                    }
+
+                    Message::Binary(bin) => {
+                        log::info!("Forward {} bytes to VNC server", bin.len());
+                        if let Err(e) = socket.write(&bin).await {
+                            log::error!("Failed to relay bytes to VNC socket {e}");
+                            break None;
+                        }
+                    }
+
+                    Message::Close(reason) => {
+                        break reason;
+                    }
+
+                    Message::Ping(bytes) => {
+                        last_heartbeat = Instant::now();
+                        let _ = session.pong(&bytes).await;
+                    }
+
+                    Message::Pong(_) => {
+                        last_heartbeat = Instant::now();
+                    }
+
+                    Message::Continuation(_) => {
+                        log::warn!("no support for continuation frames");
+                    }
+
+                    // no-op; ignore
+                    Message::Nop => {}
+                };
+            }
+
+            // Forward socket packet to WS client
+            count = socket.read(&mut buf_socket) => {
+                let count = match count {
+                    Ok(count) => count,
+                    Err(e) => {
+                        log::error!("[VNC] Failed to read from upstream! {e}");
+                        break None;
+                    }
+                };
+
+                if count == 0 {
+                    log::warn!("[VNC] infinite loop (upstream), closing connection");
+                    break None;
+                }
+
+                if let Err(e)=session.binary(buf_socket[0..count].to_vec()).await{
+                    log::error!("[VNC] Failed to forward messages to upstream, will close connection! {e}");
+                    break None
+                }
+            }
+        }
+    };
+
+    // attempt to close connection gracefully
+    let _ = session.close(reason).await;
+
+    log::info!("Disconnected from websocket");
+}

virtweb_backend/src/controllers/server_controller.rs

@@ -136,16 +136,13 @@ pub async fn server_info(client: LibVirtReq) -> HttpResult {
     system.refresh_all();
 
     let mut components = Components::new();
-    components.refresh_list();
-    components.refresh();
+    components.refresh(true);
 
     let mut disks = Disks::new();
-    disks.refresh_list();
-    disks.refresh();
+    disks.refresh(true);
 
     let mut networks = Networks::new();
-    networks.refresh_list();
-    networks.refresh();
+    networks.refresh(true);
 
     Ok(HttpResponse::Ok().json(ServerInfo {
         hypervisor: client.get_info().await?,

virtweb_backend/src/controllers/vm_controller.rs

@@ -1,11 +1,12 @@
-use crate::actors::vnc_actor::VNCActor;
+use crate::actors::vnc_handler;
 use crate::actors::vnc_tokens_actor::VNCTokensManager;
 use crate::controllers::{HttpResult, LibVirtReq};
 use crate::libvirt_lib_structures::domain::DomainState;
 use crate::libvirt_lib_structures::XMLUuid;
 use crate::libvirt_rest_structures::vm::VMInfo;
-use actix_web::{web, HttpRequest, HttpResponse};
-use actix_web_actors::ws;
+use actix_web::{rt, web, HttpRequest, HttpResponse};
+use std::path::Path;
+use tokio::net::UnixStream;
 
 #[derive(serde::Serialize)]
 struct VMInfoAndState {
@@ -324,5 +325,19 @@ pub async fn vnc(
     };
 
     log::info!("Start VNC connection on socket {socket_path}");
-    Ok(ws::start(VNCActor::new(&socket_path).await?, &req, stream)?)
+
+    let socket_path = Path::new(&socket_path);
+    if !socket_path.exists() {
+        log::error!("VNC socket path {socket_path:?} does not exist!");
+        return Ok(HttpResponse::ServiceUnavailable().json("VNC socket path does not exists!"));
+    }
+
+    let socket = UnixStream::connect(socket_path).await?;
+
+    let (res, session, msg_stream) = actix_ws::handle(&req, stream)?;
+
+    // spawn websocket handler (and don't await it) so that the response is returned immediately
+    rt::spawn(vnc_handler::handle(session, msg_stream, socket));
+
+    Ok(res)
 }

virtweb_backend/src/utils/net_utils.rs

@@ -57,7 +57,7 @@ pub fn is_net_interface_name_valid<D: AsRef<str>>(int: D) -> bool {
 /// Get the list of available network interfaces
 pub fn net_list() -> Vec<String> {
     let mut networks = Networks::new();
-    networks.refresh_list();
+    networks.refresh(true);
 
     networks
         .list()

virtweb_backend/src/utils/rand_utils.rs

@@ -1,12 +1,6 @@
-use rand::distributions::Alphanumeric;
-use rand::Rng;
+use rand::distr::{Alphanumeric, SampleString};
 
 /// Generate a random string
 pub fn rand_str(len: usize) -> String {
-    let s: String = rand::thread_rng()
-        .sample_iter(&Alphanumeric)
-        .take(len)
-        .map(char::from)
-        .collect();
-    s
+    Alphanumeric.sample_string(&mut rand::rng(), len)
 }

virtweb_frontend/package.json

@@ -4,17 +4,17 @@
   "type": "module",
   "private": true,
   "dependencies": {
-    "@emotion/react": "^11.13.5",
-    "@emotion/styled": "^11.13.5",
-    "@fontsource/roboto": "^5.1.0",
+    "@emotion/react": "^11.14.0",
+    "@emotion/styled": "^11.14.0",
+    "@fontsource/roboto": "^5.2.5",
     "@mdi/js": "^7.2.96",
     "@mdi/react": "^1.6.1",
-    "@mui/icons-material": "^6.1.8",
-    "@mui/material": "^6.1.8",
-    "@mui/x-charts": "^7.22.3",
-    "@mui/x-data-grid": "^7.22.3",
+    "@mui/icons-material": "^6.4.8",
+    "@mui/material": "^6.4.8",
+    "@mui/x-charts": "^7.28.0",
+    "@mui/x-data-grid": "^7.28.0",
     "@testing-library/jest-dom": "^6.6.3",
-    "@testing-library/react": "^16.0.0",
+    "@testing-library/react": "^16.2.0",
     "@testing-library/user-event": "^14.5.2",
     "@types/humanize-duration": "^3.27.1",
     "@types/jest": "^29.5.14",
@@ -26,15 +26,15 @@
     "date-and-time": "^3.6.0",
     "filesize": "^10.1.6",
     "humanize-duration": "^3.29.0",
-    "mui-file-input": "^6.0.0",
+    "mui-file-input": "^7.0.0",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
-    "react-router-dom": "^7.0.1",
+    "react-router-dom": "^7.4.0",
     "react-syntax-highlighter": "^15.6.1",
-    "react-vnc": "^2.0.2",
+    "react-vnc": "^2.0.3",
     "typescript": "^4.9.5",
-    "uuid": "^11.0.3",
-    "vite": "^6.0.0",
+    "uuid": "^11.1.0",
+    "vite": "^6.2.2",
     "vite-tsconfig-paths": "^5.1.3",
     "web-vitals": "^3.5.2",
     "xml-formatter": "^3.6.0"