progress bar

client-gui/src/gui_app.rs

@@ -5,8 +5,9 @@ use client_network::{
 };
 use crossbeam_channel::{Receiver, Sender};
 use egui::{
-    Align, CentralPanel, CollapsingHeader, Color32, Context, CornerRadius, Frame, Layout, Response,
+    Align, CentralPanel, CollapsingHeader, Color32, Context, CornerRadius, Frame, Layout,
-    ScrollArea, SidePanel, Stroke, TopBottomPanel, Ui, ViewportCommand,
+    ProgressBar, Response, ScrollArea, SidePanel, Stroke, TopBottomPanel, Ui, Vec2,
+    ViewportCommand,
 };
 use std::collections::HashSet;
 use std::{collections::HashMap, fmt::format, io::Seek};
@@ -54,6 +55,13 @@ pub struct P2PClientApp {
 
     current_downloading_file_map: MerkleTree,
     remaining_chunks: HashSet<[u8; 32]>,
+
+    // total number of chunks expected for the current download (set when download starts)
+    current_total_chunks: Option<usize>,
+
+    // number of chunks received so far (count of removed remaining_chunks)
+    current_received_chunks: usize,
+
     root_downloading_file: String,
 }
 
@@ -87,6 +95,8 @@ impl P2PClientApp {
             active_server: "".to_string(),
             shared_tree: generate_base_tree(),
             current_downloading_file_map: current_downloading_file_map,
+            current_total_chunks: None,
+            current_received_chunks: 0,
             root_downloading_file: "".to_string(),
             remaining_chunks: HashSet::new(),
         }
@@ -103,6 +113,14 @@ impl P2PClientApp {
     pub fn clear_success(&mut self) {
         self.success_message = None;
     }
+
+    fn set_current_total_chunks(&mut self, len: Option<usize>) {
+        self.current_total_chunks = len
+    }
+
+    fn set_current_received_chunks(&mut self, arg: usize) {
+        self.current_received_chunks = arg
+    }
 }
 
 // --- eframe::App Trait Implementation ---
@@ -291,6 +309,7 @@ impl eframe::App for P2PClientApp {
                                     true,
                                 ));
                                 self.remaining_chunks.insert(entry);
+                                self.set_current_total_chunks(Some(self.remaining_chunks.len()));
                             }
                             self.remaining_chunks.remove(&hash);
                         }
@@ -299,6 +318,13 @@ impl eframe::App for P2PClientApp {
                         }
                         _ => {}
                     }
+
+                    if let Some(total) = self.current_total_chunks {
+                        // recompute received (safer than incrementing)
+                        let received = total.saturating_sub(self.remaining_chunks.len());
+                        self.current_received_chunks = received;
+                    }
+
                     if self.remaining_chunks.is_empty() {
                         /*let file = OpenOptions::new()
                             .append(true)
@@ -323,6 +349,8 @@ impl eframe::App for P2PClientApp {
                                 }
                             }
                         }*/
+                        self.current_total_chunks = None;
+                        self.current_received_chunks = 0;
                         println!("bigfile téléchargé");
                     }
                 }
@@ -403,26 +431,35 @@ impl eframe::App for P2PClientApp {
         TopBottomPanel::bottom("bottom_panel").show(ctx, |ui| {
             ui.horizontal(|ui| {
                 match self.server_status {
-                    ServerStatus::Loading => {
+                    ServerStatus::Loading => ui.spinner(),
-                        ui.spinner();
+                    ServerStatus::Connected => ui.label("Registered but no server peer chosen..."),
+                    ServerStatus::NotConnected => ui.label("No connection.."),
+                    ServerStatus::ConnectedHandshake => ui.label("📡"),
+                };
+
+                ui.add_space(8.0); // small gap
+
+                // desired progress bar width
+                let bar_width = 220.0f32;
+                // push it to the right by adding space equal to remaining width minus bar width
+                let push = (ui.available_width() - bar_width).max(0.0);
+                ui.add_space(push);
+
+                if let Some(total) = self.current_total_chunks {
+                    let received = self.current_received_chunks;
+                    let frac = if total == 0 {
+                        1.0
+                    } else {
+                        received as f32 / total as f32
+                    };
+
+                    ui.add(
+                        ProgressBar::new(frac)
+                            .show_percentage()
+                            .animate(true)
+                            .desired_height(10.0),
+                    );
                 }
-                    ServerStatus::Connected => {
-                        ui.label("Registered but no server peer chosen...");
-                    }
-                    ServerStatus::NotConnected => {
-                        ui.label("No connection..");
-                    }
-                    ServerStatus::ConnectedHandshake => {
-                        let str = format!("📡");
-                        ui.label(str);
-                    }
-                }
-                ui.add_space(ui.available_width() - 30.0);
-                // formater mm:ss
-                let secs = self.remaining.as_secs();
-                let minutes = secs / 60;
-                let seconds = secs % 60;
-                ui.label(format!("{:02}:{:02}", minutes, seconds));
             });
         });
 
@@ -453,7 +490,11 @@ impl eframe::App for P2PClientApp {
                 });
 
                 ui.separator();
-                ScrollArea::vertical().show(ui, |ui| {
+                ScrollArea::vertical()
+                    .auto_shrink([false; 2])
+                    .show(ui, |ui| {
+                        ui.style_mut().visuals.widgets.inactive.bg_fill =
+                            ui.style().visuals.widgets.inactive.bg_fill; // no-op to get mutable borrow
                         if self.known_peers.is_empty() {
                             ui.add_space(10.0);
                             ui.label("No active peers.");
@@ -505,7 +546,10 @@ impl eframe::App for P2PClientApp {
                                         };
                                         frame
                                             .show(ui, |ui| {
-                                            ui.selectable_label(is_active, format!("{}", peer.0))
+                                                ui.selectable_label(
+                                                    is_active,
+                                                    format!("{}", peer.0),
+                                                )
                                             })
                                             .inner
                                     } else {
@@ -516,9 +560,12 @@ impl eframe::App for P2PClientApp {
 
                                     if self.loading_peers.contains(&peer.0) {
                                         // push spinner to right by expanding a spacer before it
-                                    ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
+                                        ui.with_layout(
+                                            Layout::right_to_left(Align::Center),
+                                            |ui| {
                                                 ui.spinner();
-                                    });
+                                            },
+                                        );
                                     }
 
                                     // use resp (click handling etc.)
@@ -531,7 +578,8 @@ impl eframe::App for P2PClientApp {
                                             .contains_key(self.active_peer.as_ref().unwrap())
                                         {
                                             //todo!();
-                                        let _ = self.network_cmd_tx.send(NetworkCommand::Discover(
+                                            let _ =
+                                                self.network_cmd_tx.send(NetworkCommand::Discover(
                                                     peer.0.clone(),
                                                     "root".to_string(),
                                                     self.connected_address.clone(),
@@ -674,13 +722,17 @@ impl eframe::App for P2PClientApp {
             ui.separator();
 
             if let Some(active_peer) = &self.active_peer {
-                if let Some(tree) = self.loaded_fs.get(active_peer) {
+                if let Some(tree) = self.loaded_fs.clone().get(active_peer) {
                     ScrollArea::vertical().show(ui, |ui| {
                         // Start drawing the tree from the root hash
                         self.draw_file_tree(ui, tree);
                     });
                 } else {
+                    ui.horizontal(|ui| {
                         ui.label(format!("Loading root for peer: {}", active_peer));
+                        ui.add_space(8.0);
+                        ui.spinner(); // or conditional: if is_loading { ui.spinner(); }
+                    });
                 }
             } else {
                 ui.label("Connect to a peer to view a file tree.");
@@ -730,7 +782,7 @@ impl eframe::App for P2PClientApp {
 // --- Helper for Drawing the Recursive File Tree ---
 
 impl P2PClientApp {
-    fn draw_file_tree(&self, ui: &mut Ui, tree: &MerkleTree) {
+    fn draw_file_tree(&mut self, ui: &mut Ui, tree: &MerkleTree) {
         assert!(self.active_peer.is_some());
         assert!(
             self.loaded_fs
@@ -747,7 +799,7 @@ impl P2PClientApp {
     }
 
     fn draw_file_node(
-        &self,
+        &mut self,
         ui: &mut Ui,
         to_draw: NodeHash,
         tree: &MerkleTree,

client-network/src/lib.rs

@@ -340,9 +340,53 @@ pub fn start_p2p_executor(
                                 sd.messages_list(),
                                 sd.handshake_peers.get_username_peerinfo_map(),
                             );
+                            let server_address = {
+                                match get_server_address(username.to_owned(), ip.to_owned()).await {
+                                    Some(addr) => addr.to_string(),
+                                    None => {
+                                        match event_tx.send(NetworkEvent::Error(
+                                            "Couldn't fetch server socket address.".to_owned(),
+                                            username.to_owned(),
+                                        )) {
+                                            Ok(_) => {}
+                                            Err(e) => {
+                                                println!("Network Event Error : {}", e.to_string());
+                                            }
+                                        }
+                                        "".to_owned()
+                                    }
+                                }
+                            };
+                            if server_address.to_owned().eq(&"".to_owned()) {
+                                continue;
+                            }
 
-                            let res =
+                            sd.set_servername(username.to_owned());
-                                perform_handshake(&sd, username, ip, event_tx.clone(), true).await;
+                            sd.set_serveraddress(server_address.to_string());
+                            println!("SET SERVERADDRESS");
+
+                            match perform_handshake(
+                                &sd,
+                                username.to_owned(),
+                                ip,
+                                event_tx.clone(),
+                                (true, server_address.to_string()),
+                            )
+                            .await
+                            {
+                                true => {
+                                    match event_tx.send(NetworkEvent::Success(
+                                        "Handshake established ✔️".to_string(),
+                                        username.to_owned(),
+                                    )) {
+                                        Ok(_) => {}
+                                        Err(err) => {
+                                            println!("Network Event Error : {}", err.to_string());
+                                        }
+                                    };
+                                }
+                                false => {}
+                            };
                         } else {
                             println!("no shared data");
                         }
@@ -360,7 +404,9 @@ pub fn start_p2p_executor(
                     NetworkCommand::Discover(username, hash, ip) => {
                         // envoie un handshake au peer, puis un root request
                         if let Some(sd) = shared_data.as_ref() {
-                            let res = sd.handshake_peers.get_peer_info_username(username.clone());
+                            let res = sd
+                                .handshake_peers
+                                .get_peer_info_username(username.to_owned());
                             match res {
                                 Some(peerinfo) => {
                                     let id = generate_id();
@@ -395,14 +441,31 @@ pub fn start_p2p_executor(
                                 }
                                 None => {
                                     // envoyer un handshake
-                                    let res = perform_handshake(
+                                    match perform_handshake(
                                         &sd,
-                                        username,
+                                        username.to_owned(),
                                         ip,
                                         event_tx.clone(),
-                                        false,
+                                        (false, "".to_string()),
                                     )
-                                    .await;
+                                    .await
+                                    {
+                                        true => {
+                                            match event_tx.send(NetworkEvent::Success(
+                                                "Handshake established ✔️".to_string(),
+                                                username.to_owned(),
+                                            )) {
+                                                Ok(_) => {}
+                                                Err(err) => {
+                                                    println!(
+                                                        "Network Event Error : {}",
+                                                        err.to_string()
+                                                    );
+                                                }
+                                            };
+                                        }
+                                        false => {}
+                                    }
                                 }
                             }
                         } else {
@@ -756,7 +819,16 @@ pub async fn get_socket_address(
         }
     };
 
-    let addresses = parse_addresses(&s); // assumes parse_addresses: &str -> Vec<SocketAddr>
+    let addresses: Vec<SocketAddr> = {
+        let temp = parse_addresses(&s);
+        temp.iter()
+            .filter_map(|a| match a {
+                SocketAddr::V4(_) => Some(*a),
+                SocketAddr::V6(_) => None,
+            })
+            .collect()
+    };
+
     if addresses.is_empty() {
         return Err(FetchSocketAddressError::NoRegisteredAddresses);
     } else if !addresses.iter().any(|a| matches!(a, SocketAddr::V4(_))) {

client-network/src/message_handling.rs

@@ -314,7 +314,7 @@ pub fn parse_message(
 
         ERROR => {
             if let Ok(err_received) =
-                String::from_utf8(received_message[LENGTH..(msg_length + LENGTH + 4)].to_vec())
+                String::from_utf8(received_message[LENGTH..(msg_length + LENGTH)].to_vec())
             {
                 let err_msg = format!("Error received from peer {} : {}", ip, err_received);
                 let _ = cmd_tx_clone.send(NetworkEvent::Error(err_msg, "".to_owned()));

client-network/src/registration.rs

@@ -2,6 +2,7 @@ use crate::NetworkEvent;
 use crate::P2PSharedData;
 use crate::cryptographic_signature::CryptographicSignature;
 use crate::get_server_address;
+use crate::get_socket_address;
 use crate::message_handling::EventType;
 use crate::messages_structure::construct_message;
 use crate::server_communication::generate_id;
@@ -55,25 +56,49 @@ pub async fn perform_handshake(
     username: String,
     ip: String,
     event_tx: Sender<NetworkEvent>,
-    is_server_handshake: bool,
+    is_server_handshake: (bool, String),
-) {
+) -> bool {
     println!("username: {}, ip: {}", username.clone(), ip.clone());
     let crypto_pair = sd.cryptopair_ref();
     let senders = sd.senders_ref();
 
     let id = generate_id();
-    let server_addr_query = get_server_address(username.clone(), ip.clone());
+
-    match server_addr_query.await {
+    let address = {
-        Some(sockaddr_bytes) => {
+        if is_server_handshake.0 {
-            sd.set_servername(username);
+            is_server_handshake.1
-            // first: &SocketAddr
+        } else {
+            let server_addr_query =
+                get_socket_address(username.clone(), ip.clone(), Some(sd)).await;
+
+            match server_addr_query {
+                Ok(sockaddr_bytes) => sockaddr_bytes.to_string(),
+                Err(err_msg) => {
+                    match event_tx.send(NetworkEvent::Error(
+                        err_msg.to_string(),
+                        username.to_owned(),
+                    )) {
+                        Ok(_) => {}
+                        Err(err) => {
+                            println!("Network Event Error : {}", err.to_string());
+                        }
+                    }
+                    "".to_string()
+                }
+            }
+        }
+    };
+
+    if address.eq(&"".to_string()) {
+        return false;
+    }
+
     let mut payload = Vec::new();
     payload.extend_from_slice(&0u32.to_be_bytes());
     payload.extend_from_slice(&crypto_pair.username.clone().as_bytes());
     let hello_handshake = construct_message(1, payload, id, crypto_pair);
-            if is_server_handshake {
+    if is_server_handshake.0 {
         sd.add_message(id, EventType::Hello);
-                sd.set_serveraddress(sockaddr_bytes.to_string());
     } else {
         sd.add_message(id, EventType::HelloThenRootRequest);
     }
@@ -82,19 +107,19 @@ pub async fn perform_handshake(
         Some(handshake_message) => {
             senders.send_dispatch(
                 handshake_message,
-                        sockaddr_bytes.to_string(),
+                address,
-                        is_server_handshake,
+                is_server_handshake.0,
                 sd.messages_list(),
             );
         }
         None => {}
     }
-        }
+
-        None => {
+    //let server_addr_query = get_socket_address(username.clone(), ip.clone(), Some(sd)).await;
-            let err_msg = format!("failed to retreive socket address:").to_string();
+    //match server_addr_query {
-            let res = event_tx.send(NetworkEvent::Error(err_msg, "".to_owned()));
+    //    Ok(sockaddr_bytes) => {}
-        }
+    //    Err(err_msg) => {}
-    }
+    //}
 
     /*let mut list = messages_list.lock().expect("Failed to lock messages_list");
     match list.get(&id) {
@@ -112,6 +137,7 @@ pub async fn perform_handshake(
     let hello_handshake_received = UDPMessage::parse(buf.to_vec());
     hello_handshake_received.display();*/
     //TODO
+    return true;
 }
 
 #[cfg(test)]