Add more debug logging points

CHANGELOG.md

@@ -4,6 +4,12 @@ This file is a running track of new features and fixes to each version of the pa
 
 This project follows [Semantic Versioning](http://semver.org) guidelines.
 
+## v2.2.0
+
+### Changes
+
+- Added more debug logging points.
+
 ## v2.1.0
 
 ### Changes

src-rust/src/util/api/novnc.rs

@@ -21,6 +21,7 @@ pub struct NoVncCredentials {
 
 pub async fn create_novnc_credentials(server_uuid: String) -> Result<NoVncCredentials, reqwest::Error> {
     async {
+        debug!("Begin creating noVNC creds");
         let mut body = HashMap::new();
         body.insert("type".to_owned(), "novnc".to_owned());
 
@@ -41,9 +42,12 @@ pub async fn create_novnc_credentials(server_uuid: String) -> Result<NoVncCreden
         if response.status().is_success() {
             let data: Value = serde_json::from_str(&response.text().await.unwrap()).unwrap();
             let credentials: NoVncCredentials = serde_json::from_value(data["data"].clone()).unwrap();
+
+            debug!("NoVNC creds created");
             Ok(credentials)
         } else {
+            debug!("Failed to create NoVNC creds");
             Err(response.error_for_status().unwrap_err())
         }
-    }.instrument(debug_span!("Getting NoVNC credentials for server {uuid}", uuid = server_uuid)).await
+    }.instrument(debug_span!("Getting NoVNC creds {server_uuid}", server_uuid = server_uuid)).await
 }

src-rust/src/util/api/xtermjs.rs

@@ -4,7 +4,7 @@ use dotenv::var;
 use reqwest::Client;
 use serde::Deserialize;
 use serde_json::Value;
-use tracing::{debug_span, Instrument};
+use tracing::{debug, debug_span, Instrument};
 
 use crate::util::api::http::get_headers_with_authorization;
 
@@ -24,6 +24,7 @@ pub struct XTermjsCredentials {
 
 pub async fn create_xtermjs_credentials(server_uuid: String) -> Result<XTermjsCredentials, reqwest::Error> {
     async {
+        debug!("Begin creating xterm.js creds");
         let mut body = HashMap::new();
         body.insert("type".to_owned(), "xtermjs".to_owned());
 
@@ -44,8 +45,10 @@ pub async fn create_xtermjs_credentials(server_uuid: String) -> Result<XTermjsCr
         if response.status().is_success() {
             let data: Value = serde_json::from_str(&response.text().await.unwrap()).unwrap();
             let credentials: XTermjsCredentials = serde_json::from_value(data["data"].clone()).unwrap();
+            debug!("xterm.js creds created");
             Ok(credentials)
         } else {
+            debug!("Failed to create xterm.js creds");
             Err(response.error_for_status().unwrap_err())
         }
     }.instrument(debug_span!("Getting xterm.js credentials for server {uuid}", uuid = server_uuid)).await

src-rust/src/util/terminals/novnc.rs

@@ -8,72 +8,83 @@ use tokio::join;
 use tokio::net::TcpStream;
 use tokio::sync::Mutex;
 use tokio_tungstenite::{MaybeTlsStream, tungstenite::Message as TMessage, WebSocketStream};
-use tracing::{debug, error, Instrument};
+use tracing::{debug, debug_span, error, Instrument};
 
 use crate::util::api::novnc::{create_novnc_credentials, NoVncCredentials};
 use crate::util::api::proxmox::{build_ws_request, Credentials};
 use crate::util::crypto::des;
 use crate::util::websocket::{convert_axum_to_tungstenite, convert_tungstenite_to_axum};
 
 pub async fn start_novnc_proxy(server_uuid: String, client_ws: WebSocket) {
-    let credentials = create_novnc_credentials(server_uuid).await.unwrap();
-
-    let (request, connector) = build_ws_request(
-        Credentials::NoVnc(credentials.clone())
-    );
-    let remote_ws = match tokio_tungstenite::connect_async_tls_with_config(
-        request,
-        None,
-        false,
-        Some(connector),
-    ).await {
-        Ok((ws, _)) => ws,
-        Err(e) => {
-            error!(
+    let span = debug_span!("noVNC proxy {server_uuid}", server_uuid = server_uuid.clone());
+
+    async move {
+        debug!("Starting proxy...");
+        let credentials = create_novnc_credentials(server_uuid).await.unwrap();
+
+        let (request, connector) = build_ws_request(
+            Credentials::NoVnc(credentials.clone())
+        );
+        let remote_ws = match tokio_tungstenite::connect_async_tls_with_config(
+            request,
+            None,
+            false,
+            Some(connector),
+        ).await {
+            Ok((ws, _)) => ws,
+            Err(e) => {
+                error!(
                 "Failed to connect to Proxmox ({proxmox}): {error}",
                 proxmox = credentials.node_fqdn,
                 error = e,
             );
 
-            client_ws.close().await.unwrap();
-            return;
-        }
-    };
+                client_ws.close().await.unwrap();
+                return;
+            }
+        };
 
-    let (client_sender, client_receiver) = client_ws.split();
-    let (remote_sender, remote_receiver) = remote_ws.split();
+        let (client_sender, client_receiver) = client_ws.split();
+        let (remote_sender, remote_receiver) = remote_ws.split();
 
-    let client_sender = Arc::new(Mutex::new(client_sender));
-    let client_receiver = Arc::new(Mutex::new(client_receiver));
+        let client_sender = Arc::new(Mutex::new(client_sender));
+        let client_receiver = Arc::new(Mutex::new(client_receiver));
 
-    let remote_sender = Arc::new(Mutex::new(remote_sender));
-    let remote_receiver = Arc::new(Mutex::new(remote_receiver));
+        let remote_sender = Arc::new(Mutex::new(remote_sender));
+        let remote_receiver = Arc::new(Mutex::new(remote_receiver));
 
-    authenticate(
-        client_sender.clone(),
-        client_receiver.clone(),
-        remote_sender.clone(),
-        remote_receiver.clone(),
-        credentials,
-    ).await;
+        authenticate(
+            client_sender.clone(),
+            client_receiver.clone(),
+            remote_sender.clone(),
+            remote_receiver.clone(),
+            credentials.clone(),
+        ).await;
 
-    let client_to_remote = async {
-        while let Some(Ok(msg)) = client_receiver.lock().await.next().await {
-            remote_sender.lock().await.send(convert_axum_to_tungstenite(msg)).await.unwrap();
-        }
+        debug!("Authenticated connection");
 
-        remote_sender.lock().await.close().await.unwrap();
-    };
+        let client_to_remote = async {
+            debug!("Forwarding client-to-remote");
+            while let Some(Ok(msg)) = client_receiver.lock().await.next().await {
+                remote_sender.lock().await.send(convert_axum_to_tungstenite(msg)).await.unwrap();
+            }
 
-    let remote_to_client = async {
-        while let Some(Ok(msg)) = remote_receiver.lock().await.next().await {
-            client_sender.lock().await.send(convert_tungstenite_to_axum(msg)).await.unwrap();
-        }
+            remote_sender.lock().await.close().await.unwrap();
+        };
 
-        client_sender.lock().await.close().await.unwrap();
-    };
+        let remote_to_client = async {
+            debug!("Forwarding remote-to-client");
+            while let Some(Ok(msg)) = remote_receiver.lock().await.next().await {
+                client_sender.lock().await.send(convert_tungstenite_to_axum(msg)).await.unwrap();
+            }
+
+            client_sender.lock().await.close().await.unwrap();
+        };
+
+        join!(client_to_remote, remote_to_client);
 
-    join!(client_to_remote, remote_to_client);
+        debug!("Proxy connection closed");
+    }.instrument(span).await;
 }
 
 async fn authenticate(
@@ -83,7 +94,7 @@ async fn authenticate(
     remote_receiver: Arc<Mutex<SplitStream<WebSocketStream<MaybeTlsStream<TcpStream>>>>>,
     credentials: NoVncCredentials,
 ) {
-    let span = tracing::debug_span!("Authenticating noVNC connection for VMID {vmid}", vmid = credentials.vmid);
+    let span = tracing::debug_span!("Auth-ing noVNC connection {vmid}", vmid = credentials.vmid);
 
     async move {
         let capture_client_messages = async {

src-rust/src/util/terminals/xtermjs.rs

@@ -3,68 +3,76 @@ use futures_util::{SinkExt, StreamExt};
 use tokio::join;
 
 use tokio_tungstenite::tungstenite::Message as TMessage;
-use tracing::{debug, error, Instrument};
+use tracing::{debug, debug_span, error, Instrument};
 
 use crate::util::api::proxmox::{build_ws_request, Credentials};
 use crate::util::api::xtermjs::create_xtermjs_credentials;
 use crate::util::websocket::{convert_axum_to_tungstenite, convert_tungstenite_to_axum};
 
 pub async fn start_xtermjs_proxy(server_uuid: String, client_ws: WebSocket) {
-    let credentials = create_xtermjs_credentials(server_uuid).await.unwrap();
+    let span = debug_span!("Xterm.js proxy {server_uuid}", server_uuid = server_uuid.clone());
 
-    let (request, connector) = build_ws_request(
-        Credentials::XTerm(credentials.clone())
-    );
-    let remote_ws = match tokio_tungstenite::connect_async_tls_with_config(
-        request,
-        None,
-        false,
-        Some(connector),
-    ).await {
-        Ok((ws, _)) => ws,
-        Err(e) => {
-            error!(
+    async move {
+        debug!("Starting proxy...");
+        let credentials = create_xtermjs_credentials(server_uuid.clone()).await.unwrap();
+
+        let (request, connector) = build_ws_request(
+            Credentials::XTerm(credentials.clone())
+        );
+        let remote_ws = match tokio_tungstenite::connect_async_tls_with_config(
+            request,
+            None,
+            false,
+            Some(connector),
+        ).await {
+            Ok((ws, _)) => ws,
+            Err(e) => {
+                error!(
                 "Failed to connect to Proxmox ({proxmox}): {error}",
                 proxmox = credentials.node_fqdn,
                 error = e,
             );
 
-            client_ws.close().await.unwrap();
-            return;
-        }
-    };
+                client_ws.close().await.unwrap();
+                return;
+            }
+        };
 
-    let (mut client_sender, mut client_receiver) = client_ws.split();
-    let (mut remote_sender, mut remote_receiver) = remote_ws.split();
+        let (mut client_sender, mut client_receiver) = client_ws.split();
+        let (mut remote_sender, mut remote_receiver) = remote_ws.split();
 
-    async {
-        debug!("Sending payload");
-        let payload = format!(
-            "{username}@{realm_type}:{ticket}\n",
-            username = credentials.username,
-            realm_type = credentials.realm_type,
-            ticket = credentials.ticket
-        );
-        remote_sender.send(TMessage::Text(payload)).await.unwrap();
-        debug!("Payload sent");
-    }.instrument(tracing::debug_span!("Authenticating xterm.js connection for VMID {vmid}", vmid = credentials.vmid)).await;
+        async {
+            debug!("Sending payload");
+            let payload = format!(
+                "{username}@{realm_type}:{ticket}\n",
+                username = credentials.username,
+                realm_type = credentials.realm_type,
+                ticket = credentials.ticket
+            );
+            remote_sender.send(TMessage::Text(payload)).await.unwrap();
+            debug!("Payload sent");
+        }.instrument(tracing::debug_span!("Auth-ing xterm.js connection {server_uuid}", server_uuid = server_uuid)).await;
 
+        let client_to_remote = async {
+            debug!("Forwarding client-to-remote...");
+            while let Some(Ok(msg)) = client_receiver.next().await {
+                remote_sender.send(convert_axum_to_tungstenite(msg)).await.unwrap();
+            }
 
-    let client_to_remote = async {
-        while let Some(Ok(msg)) = client_receiver.next().await {
-            remote_sender.send(convert_axum_to_tungstenite(msg)).await.unwrap();
-        }
+            remote_sender.close().await.unwrap();
+        };
 
-        remote_sender.close().await.unwrap();
-    };
+        let remote_to_client = async {
+            debug!("Forwarding remote-to-client...");
+            while let Some(Ok(msg)) = remote_receiver.next().await {
+                client_sender.send(convert_tungstenite_to_axum(msg)).await.unwrap();
+            }
 
-    let remote_to_client = async {
-        while let Some(Ok(msg)) = remote_receiver.next().await {
-            client_sender.send(convert_tungstenite_to_axum(msg)).await.unwrap();
-        }
+            client_sender.close().await.unwrap();
+        };
 
-        client_sender.close().await.unwrap();
-    };
+        join!(client_to_remote, remote_to_client);
 
-    join!(client_to_remote, remote_to_client);
+        debug!("Proxy connection closed");
+    }.instrument(span).await;
 }